# Workflows, Recipes & Autopilot

Run an entire creative pipeline — copy, images, voice, music, video, and the final render — from one brief: pick a starter recipe or wire your own node graph, watch it run live, approve the creative decisions, feed it a spreadsheet for bulk output, or schedule it to run hands-off.

---

## On this page

- [What workflows are](#what-workflows-are)
- [Where workflows live](#where-workflows-live)
- [Before you start](#before-you-start)
- [The starter library](#the-starter-library)
- [Run a workflow from the dashboard](#run-a-workflow-from-the-dashboard)
- [Know the cost before you run](#know-the-cost-before-you-run)
- [Review gates: approve or send back](#review-gates-approve-or-send-back)
- [Run history](#run-history)
- [Autopilot: schedule hands-off runs (Pro)](#autopilot-schedule-hands-off-runs-pro)
- [The workflow graph: watch a run as a live dataflow](#the-workflow-graph-watch-a-run-as-a-live-dataflow)
- [Build a custom pipeline on the canvas](#build-a-custom-pipeline-on-the-canvas)
- [Bulk create from a CSV](#bulk-create-from-a-csv)
- [Where the outputs land](#where-the-outputs-land)
- [Tips](#tips)
- [Troubleshooting](#troubleshooting)
- [Related pages](#related-pages)

---

## What workflows are

A **workflow** (also called a **recipe**) is a saved, multi-step creative pipeline. Instead of generating one asset at a time, you hand the workflow a short brief — a topic, a product, a concept — and it runs a whole production line for you: it can write the copy, generate a set of images, synthesize a voiceover, compose an original music bed, board and shoot a film shot by shot, assemble everything into a real editable project, and queue the finished MP4 render.

Three ideas make workflows more than a batch button:

- **Stages with hand-offs.** A workflow is built from stages — *write*, *plan*, *shoot*, *score*, *compose*, *render* — and each stage passes its output (the script, the shot plan, the clips, the music) to the next. You can see this hand-off drawn as a live node graph.
- **Governance.** Every run shows a credit estimate up front, can carry a budget with a hard cap, and can pause at **review gates** so a human approves the creative direction before the expensive steps spend anything.
- **Repeatability.** A workflow is saved. Run it once, run it again with a different brief, run it 200 times from a spreadsheet, or put it on a schedule and let it produce unattended.

Runs execute in the background — start one, keep working, and come back to the result. Nothing blocks while video generates or a render bakes.

---

## Where workflows live

There are two main surfaces, sharing the same engine and the same saved recipes:

| Surface | How to get there | Best for |
|---------|------------------|----------|
| **Dashboard — Workflows view** | Sign in at corereflex.com, then top nav **Create → Workflows**. The **Autopilot recipes** section is the cockpit. | Quick runs, schedules, bulk CSV batches, run history, approvals. |
| **Editor — Workflow mode** | Open the Studio (the timeline editor) and click **Workflow** in the mode switcher at the top. The dashboard home card **"Run a workflow" → Open Workflow Studio** takes you straight there. | Seeing the pipeline as a live node graph, and building custom pipelines node by node. |

The editor's top bar also has an **Autopilot** button — a compact wizard that runs or schedules a starter without leaving whatever you're editing.

Everything is scoped to your workspace: your team sees the same saved recipes, runs, and schedules.

---

## Before you start

- **Any plan can run workflows.** Creating recipes, running them, approvals, the graph, and bulk CSV all work on every tier.
- **Scheduling is a Pro feature.** Hands-off Autopilot schedules ride the same automation engine as [Client Operations](client-operations.md), so the cadence controls only appear on Pro and above.
- **Paid steps draw credits.** Video generation (per shot), image generation (per image), music, voiceover, AI copywriting, upscaling, and rendering are metered; assembling, saving, and delivery steps are free. Every run shows an estimate first — see [Plans & Billing](plans-and-billing.md) for how credits work.
- **Rendering needs the render worker.** If your instance's render worker isn't switched on yet, a workflow that ends in a render doesn't fail — it delivers the finished, editable project and tells you the MP4 step was skipped.

---

## The starter library

Starters are curated, ready-to-run pipelines organized by category. Pick one, fill its brief, and run. Each starter's brief fields are tailored to what it makes.

### Writing (brief → saved document)

| Starter | What it produces | Brief fields |
|---------|------------------|--------------|
| **Blog post** | An authoritative, structured blog post, saved as a document. | Topic, audience, tone, length |
| **Email sequence** | A 4-email nurture sequence with subject lines, saved as a document. | Offer, audience, tone |
| **Landing page copy** | Hero headline, benefit sections, social-proof line, and CTA, saved as a document. | Product, audience |
| **Social post pack** | 7 distinct short posts mixing hooks, insights, and a CTA, saved as a document. | Theme, audience |

### Image (brief → image set, composed for review and export)

| Starter | What it produces | Brief fields |
|---------|------------------|--------------|
| **Ad creative set** | A set of ad image variations (hero shot, lifestyle, flat-lay, text-space layout), composed into a project. | Product, style, count, aspect |
| **Moodboard** | A cohesive set of visual-direction frames on one theme. | Theme, style, frame count, aspect |

### Video (brief → assembled film, with render)

| Starter | What it produces | Brief fields |
|---------|------------------|--------------|
| **Cinematic film** | The full agentic pipeline: boards a shot plan, generates every shot, scores it, cuts it, and queues the render. | Concept, aspect, score mood |
| **Guided film (approval gate)** | The same film pipeline, but it **pauses after the shot plan for your approval — before spending anything on video**. Approve to continue, or send it back for a new plan. | Concept, aspect, score mood |
| **Video sales letter** | Your script as a voiceover over a generated visual, with a music bed, composed and rendered. | Script, voice, aspect, music bed |
| **Social short (scripted)** | Multi-modal: writes a punchy hook and script, voices it, generates matching b-roll and a music bed, and cuts a vertical short. | Concept, aspect, music bed |
| **Explainer** | Writes an explainer script, voices it, generates a set of supporting visuals, and cuts them together. | Concept, frame count, aspect, music bed |

### Audio

| Starter | What it produces | Brief fields |
|---------|------------------|--------------|
| **Music track** | An original instrumental track, dropped into a project ready to build visuals around. | Mood/style, canvas aspect |

### Campaign (multi-output)

| Starter | What it produces | Brief fields |
|---------|------------------|--------------|
| **End-to-end campaign** | One brief in, two deliverables out: the campaign messaging saved as a document, **and** a boarded, shot, scored, and rendered film. | Brand brief, audience, brand voice, aspect, score mood |
| **Social repurpose pack** | Platform-ready captions saved as a document, plus a set of scroll-stopping thumbnail variations. | Source concept, brand voice, style, count, aspect |

### Custom

**Custom workflow** is the escape hatch: an empty pipeline you assemble yourself, node by node, on the editor's builder canvas — see [Build a custom pipeline](#build-a-custom-pipeline-on-the-canvas).

---

## Run a workflow from the dashboard

1. Sign in at **corereflex.com**.
2. In the top navigation, open **Create** and click **Workflows**.
3. Scroll to the **Autopilot recipes** section.
4. Open the starter dropdown (top-left of the composer) and pick a workflow. Starters are grouped by category — Campaign, Video, Image, Writing, Audio. A short description appears under the dropdown, along with the step count and whether the workflow pauses for your approval.
5. Fill in the brief fields. Short fields are single-line inputs; long-form fields (a concept, a script, a brief) get a full-width text box. Script fields have a **✨ Generate script** button that drafts spoken lines for you from your other inputs — click it, then edit the result freely.
6. Choose a **budget mode** from the dropdown next to the starter: **observe** (measure spend, never block), **warn** (allow but flag overages), or **cap** (hard-stop any step that would exceed the budget).
7. Click **Create & run**. The workflow is saved as a recipe, a cost line appears (for example `≈ 120–240 credits · balance 1,000`), and the run starts immediately in the background.
8. Watch the run row appear under the recipe. Its status updates automatically: **Running**, **Awaiting approval**, **Completed**, or **Failed**. When it completes you get one-click links — **Open** takes a produced project into the Video editor, **Open document** opens a produced document in the Write studio. A `spent N credits` line shows what the run actually drew.

Every saved recipe stays in the list below the composer with **Run**, **Runs** (history), **Schedule** (Pro), and **Delete** buttons — so a workflow you set up once is a one-click rerun forever.

---

## Know the cost before you run

Workflows are the most powerful spend surface in the product, so cost is shown before anything runs:

- **Single runs** show an estimated credit range next to the composer as the run starts, plus your live balance and whether it covers the high end. Video is a range because the shot count isn't known until the plan is boarded (the estimate assumes 3–6 shots); image sets are priced per image; copy, voice, music, and render are flat per step. Composing, saving, and delivery steps are free.
- **Bulk CSV batches** are always priced with a dry run first — per-row and whole-batch ranges against your balance — and an unaffordable batch is blocked before it starts. See [Bulk create from a CSV](#bulk-create-from-a-csv).
- **Budget modes** govern the run itself:
  - **Observe** — the default. The run records spend but never blocks.
  - **Warn** — allows a step that would exceed the budget, but flags it.
  - **Cap** — reserves each paid step's credits *before* it runs and hard-stops the run if a step would push past the budget, so an over-budget step never spends. A small slice of the budget is held back as headroom.
- **Your balance is always the final gate.** With billing on, a paid step that your balance can't cover stops the run with a clear message about what it needed versus what you had — you're told before the spend, not after.

The graph view and the run rows both show what a run has actually spent as it goes.

---

## Review gates: approve or send back

Some workflows pause at creative decision points instead of running straight through. The **Guided film** starter is the canonical example: it boards the shot plan, then **pauses for your approval before generating a single second of video** — the expensive part only starts once you've signed off on the plan.

When a run hits a review gate:

1. Its status changes to **Awaiting approval**, and the row (or the run panel in the editor) shows which stage it's paused at — for example `paused at "plan"`.
2. **Approve** resumes the run from the next stage. Everything already produced is kept — an approved stage is never re-run and never re-billed.
3. **Send back** rejects the paused stage for a fresh take. Type an optional note first (what to change) — it's saved with the run as an audit trail. The run re-runs *that* stage only, then pauses again for another look. Earlier stages keep their outputs.

You can approve or send back from either surface — the dashboard run row or the editor's Workflow mode. In the custom pipeline builder you can put a review gate on **any** node — see [Build a custom pipeline](#build-a-custom-pipeline-on-the-canvas).

Two things to know:

- A double-click can't double-approve: once a decision lands, the other is refused ("Stage already resolved") — the run only resumes once.
- **Scheduled runs never pause.** An unattended Autopilot run auto-approves every gate by design — see the next section.

---

## Run history

- Click **Runs** on any saved recipe to open its history — newest first, with each run's status, start time, credits spent, output links, and the error message if it failed.
- A run paused at a review gate shows its **Approve** / **Send back** controls right in the history.
- Deleting a recipe keeps its past runs — history is never silently lost.
- Bulk batches appear in the same history, one run per row of your CSV.

---

## Autopilot: schedule hands-off runs (Pro)

A schedule turns a workflow into a content machine: it fires on a cadence, runs unattended, and its output lands in your library without anyone clicking anything.

### Put a workflow on a schedule

1. In **Create → Workflows → Autopilot recipes**, pick a starter and fill its brief (these become the inputs for *every* scheduled run).
2. Choose a cadence from the dropdown: **Hourly**, **Every 6h**, or **Daily 09:00 UTC**.
3. Click **Schedule**. The workflow is saved and an automation is created around it.

You can also schedule an existing saved recipe: click **Schedule** on its row, pick a cadence, and confirm.

### Manage schedules

Scheduled workflows appear in the **On autopilot** list, each showing its cadence, next run time, and total runs so far. Per schedule:

- **Runs** — the schedule's own run history: every firing, with status, output links, and error messages.
- **Pause / Resume** — stop the cadence without deleting anything.
- **Remove** — delete the schedule. Past runs are kept.

### How unattended runs behave

- **They auto-approve.** A scheduled run must never sit waiting for a human, so every review gate is automatically approved. If you want human sign-off, run the workflow manually instead of scheduling it.
- **They fail loud.** An unattended run that hits a problem doesn't retry silently or half-succeed quietly — it records **Failed** with the error message, right there in the schedule's run history. Check **Runs** on the schedule to see exactly what happened.
- **They're budget-governable.** The budget mode you set when scheduling applies to every firing — **cap** is the safe choice for anything unattended.

Schedules ride the same automation engine as the Pro client-operations suite — see [Client Operations](client-operations.md) for the broader automation picture.

---

## The workflow graph: watch a run as a live dataflow

The editor's **Workflow mode** shows any pipeline as a node graph — the actual dataflow, not a decorative diagram. Each stage is a node; the wires between them are the real hand-offs (the plan flowing into the shot generator, the clips and music flowing into the composer).

### Open it

1. Open the Studio (the timeline editor).
2. Click **Workflow** in the mode switcher at the top of the screen. (From the dashboard, the home card **Run a workflow → Open Workflow Studio** lands here directly.)

### Read the canvas

- **Left rail** — the workflow library, grouped by category. Click one to load its graph.
- **Center** — the graph. A **Brief** node on the left represents your inputs; stage nodes sit in dependency order left to right; an **Output** node on the right collects the deliverables (project, document, render). Each stage node lists what it consumes and what it produces as labeled ports, and shows its role (director, cinematographer, composer, writer, editor, delivery). Stages with a review gate wear a **review** badge.
- **Right rail** — the **Brief** panel: the workflow's input fields and the **Run workflow** button.

Pan by dragging the canvas, zoom with the controls or scroll, and use the minimap to jump around. The canvas owns its own keyboard, so editor shortcuts won't fight it.

### Brand-aware briefs

If your account has brands set up (Pro — see Brand Studio), the Brief panel shows a **Brand** picker. Selecting a brand pre-fills matching brief fields — audience and brand voice — and marks them with a `· brand` tag. You can still override any inherited value per run. Switching the brand re-applies its context to the current brief.

### Watch a run paint the graph

Click **Run workflow** and the graph comes alive:

- Nodes paint their state in real time — **queued** (waiting on inputs), **running** (pulsing), **done**, **failed** (red), and **awaiting approval** (highlighted) — and the wires animate as data flows between active stages.
- The run panel under the graph shows the overall status, credits spent so far, and — when the run pauses at a gate — the same **Approve** / **Send back** controls (with the optional note) as the dashboard.
- When the run finishes, **Open in Video editor →** jumps straight onto the produced project's timeline, and **Open document →** opens a produced document in the Write studio.

---

## Build a custom pipeline on the canvas

Pick **Custom workflow** in the Workflow mode's left rail and the read-only graph becomes a **builder**: an empty canvas where you assemble your own pipeline from typed stage templates, wire them together, and run the result with the same engine that powers every starter.

### The 10 stage templates

| Template | Role | What it does | Inputs (ports) | Output |
|----------|------|--------------|----------------|--------|
| **Plan film** | director | Boards a shot plan from a concept. | — | `plan` |
| **Generate shots** | cinematographer | Generates every shot in the plan (billed per shot). | `plan` (required) | `clips` |
| **Generate image** | cinematographer | One still (b-roll). Optionally wire a voiceover in to match its on-screen length. | `vo` (optional) | `broll` |
| **Image set** | cinematographer | A batch of 1–8 stills (ads, moodboard, storyboard frames). | — | `shots` |
| **Voiceover** | voice | Synthesizes narration from a script. | — | `vo` |
| **Music** | composer | An original instrumental bed. | — | `music` |
| **Write copy** | writer | Long-form copy, brand-voice aware. | — | `copy` |
| **Save document** | delivery | Persists copy as a Write document. | `copy` (required) | `documentId` |
| **Compose video** | editor | Assembles the wired layers into an editable project. Visual layers stack top-down. | `visual layers` (required, multiple: clips / shots / broll) · `audio layers` (optional, multiple: vo / music) | project |
| **Render** | delivery | Queues the finished MP4 render. | `composition` (required) | `render` |

### Build it, step by step

1. **Name your pipeline** in the field at the top-left (this becomes the saved recipe's name).
2. **Add steps** from the **＋ Add step…** dropdown. Each node lands on the canvas with its own input fields — prompt, script, aspect, count — filled in right on the node.
3. **Wire the ports.** Drag from a node's output port (right side) to another node's input port (left side). Wires *are* the pipeline: a stage only runs once everything wired into it exists.
4. **Trust the validation.** Ports are typed — connecting the wrong artifact is rejected on the spot with a message like *"visual layers takes clips / shots / broll — not vo."* Single-input ports replace their existing wire when you connect a new one; the Compose node's multi-ports stack every wire you add (in connection order — first visual wire is the top layer).
5. **One of each producer.** Output names are the wiring language, so a pipeline can hold only one node of each output type — you can't add two Music nodes. The canvas tells you if a second would collide.
6. **Add review gates where you want control.** Every node header has a **review** badge — click it to toggle a gate on that node. A gated run pauses there for your approval before continuing (exactly like the guided starters).
7. **Edit freely.** Drag nodes to arrange them, click a node or wire to select it and press **Backspace/Delete** to remove it, or use the **×** on a node's header.
8. **Save & run.** The builder checks that every required port is wired and every required field is filled, refuses cycles (*"pipelines must flow one way"*), saves the graph as a recipe, and runs it. Run state paints back onto your own nodes, and review gates pause with the same Approve / Send back controls.

Your custom pipeline is a normal saved recipe from that point on: it appears in the dashboard cockpit, where you can rerun it, see its history, schedule it (Pro), or feed it a bulk CSV.

---

## Bulk create from a CSV

Bulk create runs one workflow **once per row of a spreadsheet** — 50 blog posts, 200 localized ad sets, a batch of VSLs — with the columns filling the matching brief fields per row.

### Prepare the file

- **First row = headers**, and each header should match a brief field name of the workflow (for example `topic`, `audience`, `tone`). Columns that don't match a field are still available to the workflow as extra inputs.
- Every data row fills one run; a row's values override anything you typed into the composer's shared fields.
- Limits: up to **200 rows**, **64 columns**, **4,000 characters per cell**, **2 MB per file**. Headers must be unique, non-empty, and may not start with an underscore. Every row must have the same number of cells as the header — a ragged sheet is rejected with the exact row number rather than silently misaligning your data into paid generations. Quoted cells and commas inside quotes are handled normally.

### Run the batch

1. In **Create → Workflows → Autopilot recipes**, pick the starter and fill any shared brief fields (defaults for columns your sheet doesn't override).
2. Click **Bulk CSV** and choose your file.
3. **Dry run first — nothing generates yet.** The file is parsed and priced, and the estimate line shows what you're about to commit: `Bulk: 48 rows × [topic, audience, tone] · ≈960–1,920 credits (balance 5,000)`. If your balance can't cover the batch, it's blocked here with a clear message.
4. **Confirm with a second click.** The button changes to **Run N rows?** — click it again to start (picking a different starter disarms it). This two-tap confirm is deliberate: a batch is real spend.
5. **Watch the progress.** The batch drains in the background, a few rows at a time (bounded — never all 200 at once), and the estimate line ticks up: `Bulk batch: 12/48 done…`. A toast announces the final tally: completed, failed, and any rows that never started.

### How batches behave

- **Rows never pause for approval** — a bulk batch is unattended by definition, so review gates auto-approve.
- **Out of credits halts the batch early.** If a row fails because the balance ran dry, the remaining rows aren't attempted — no point burning the queue.
- **Each row is a normal run.** Open the recipe's **Runs** history to see every row's individual status, outputs, and errors.

Outputs land exactly like single runs: images in **Files**, projects in **Projects**, documents in the **Write** studio.

---

## Where the outputs land

Everything a workflow makes lands in your normal library — nothing disappears into a separate silo:

| Output | Where to find it |
|--------|------------------|
| Assembled video/image/music project | **Projects** in the dashboard (and **Open in Video editor** from the run) — a fully editable timeline, not a locked file. |
| Rendered MP4 | The render pipeline's output in your library, once the render worker on your instance is live. |
| Generated images | **Files** (the media browser), recorded with generation provenance so you can trace which run made them. |
| Documents (copy, captions, sequences) | The **Write** studio (**Open document** from the run). |
| Voiceover and music | Inside the produced project, on their own tracks. |

---

## Tips

- **Start guided.** For anything with video in it, the **Guided film** starter (or a review gate on your custom plan node) means you approve the shot plan before the expensive generation starts.
- **Cap unattended spend.** Use the **cap** budget mode on schedules and think twice before scheduling anything without one.
- **Let the brand do the typing.** Attach a brand in the editor's Brief panel and audience/voice fill themselves on every run — copy steps automatically write in your brand voice even when you don't pass one.
- **Draft scripts in place.** The **✨ Generate script** button in the dashboard composer writes spoken lines from your other brief fields — seed it with a rough draft and it builds on what you wrote.
- **Reuse saved recipes.** After the first **Create & run**, use the saved recipe's own **Run** button — same workflow, one click, full history in one place.
- **Test one row first.** Before a 200-row batch, run the workflow once with the first row's values typed in manually; then trust the dry-run numbers.

---

## Troubleshooting

- **The run failed with a budget or credits message.** Cap mode stopped a step that would exceed the run's budget, or your balance couldn't cover a paid step. Top up (see [Plans & Billing](plans-and-billing.md)), raise the budget, or switch the budget mode, then run again.
- **"Run is not awaiting approval" / "Stage already resolved."** Someone (or a second click) already decided this gate. Refresh the runs list — the run is already resuming.
- **The run says approval checkpoints aren't available.** On a self-hosted instance whose approval storage isn't provisioned yet, a workflow that *demands* a human gate refuses to silently run through it — that's deliberate. Run it with automatic approvals, or ask your administrator to finish provisioning.
- **"Too many requests."** Run starts and bulk batches are rate-limited per user to protect your spend. Wait a minute and try again.
- **The render step was skipped ("degraded").** The render worker isn't enabled on your instance yet. The run still succeeded — the project is complete and editable; render it once the worker is live. See [Coming Soon](coming-soon.md).
- **"Nothing to persist — the recipe produced no playable clips."** Every visual generation upstream failed or produced nothing, so there was nothing to compose. Check the failed stage in the run history, adjust the prompt, and run again.
- **A stage "did not produce" its output or failed its success criteria.** Each stage must actually deliver what the next stage needs (a real plan with enough shots, a non-empty image set, a playable composition) — a stage that can't is failed loudly instead of passing garbage downstream. Send it back or rerun with a stronger brief.
- **My CSV was rejected.** The error names the exact problem — the row number, cell count, an unterminated quote, a duplicate or empty header, an underscore-prefixed column. Fix that line and re-upload; strictness here is what keeps the wrong value out of a paid generation.
- **I don't see Schedule / cadence controls.** Autopilot scheduling is a Pro feature; see [Plans & Billing](plans-and-billing.md).
- **My custom pipeline won't save.** The builder tells you what's missing: a required port not wired, a required field empty, or a cycle in the graph. Wire or fill what it names and hit **Save & run** again.

---

## Related pages

- [Plans & Billing](plans-and-billing.md) — credits, metered steps, budgets, and top-ups.
- [Directing Films](directing-films.md) — the agentic film pipeline the video starters drive.
- [Writing & Content](writing-and-content.md) — the Write studio where workflow documents land.
- [Editing & Mastering](editing-and-mastering.md) — finishing a workflow-produced project on the timeline.
- [Client Operations (Pro)](client-operations.md) — the automation engine behind Autopilot schedules.
- [Proofing & Approvals (Pro)](proofing-and-approvals.md) — client sign-off on the finished deliverable.