JSON workflow recipes turn a creative pipeline into code, a structured, machine-readable definition of how a piece of content gets planned, generated, scored, and assembled, so CoreReflex can run it hands-free and repeat it exactly. Instead of clicking through an editor every time you need a video, you describe the pipeline once and let Autopilot execute it on demand, on a schedule, or in bulk, this guide explains what a recipe is, why JSON is the right format, what goes inside one, and who should use them.
What is a JSON workflow recipe?
A JSON workflow recipe is a declarative file that captures an entire production pipeline as data: the inputs it expects, the steps it runs, the quality bar each step must clear, and the governance limits it operates under. Because it's plain structured data rather than a sequence of clicks, it can be saved, versioned, shared, and replayed without drift.
Think of it as the sheet music for a production. A human can read it, a machine can perform it, and every performance follows the same score. That's the foundation of Autopilot, programmable recipes that companies schedule for hands-free generation.
Why JSON instead of clicking or prompting
A single clever prompt can produce one good clip, it can't reliably produce the hundredth, because there's no structure to enforce, no record of what the prompt was, no quality check, no way to rerun it identically. Manual editing has the opposite problem: it's precise but doesn't scale, because every asset costs human time.
JSON sits in the sweet spot. It's explicit enough to be deterministic, the same recipe and inputs yield the same pipeline every time, and structured enough to be programmatic, so software can generate, validate, and run thousands of variations. It pairs naturally with CoreReflex's JSON engine over editor state and public API, which means a recipe isn't a closed format; it's something you can produce and trigger from your own systems.
For the lower-level editing model behind that format, see the guide to the programmable JSON content workflow, which explains why editor state needs to be queryable data rather than an opaque prompt result.
Anatomy of a recipe
A recipe is built from a handful of named sections. You don't need to memorize a syntax to understand the shape:
inputs, the variables a run accepts, such as a product name, a brief, an aspect ratio, or a brand kit to bind. This is what makes one recipe reusable across many outputs.plan, how the Director should board the work: shot roles, camera moves, and prompts, or the slides and copy for a deck. Planning is free, so this is where the structure is shaped before spend.generate, which models and parameters produce each asset on the Vertex AI stack (Veo or Kling for video, Imagen for stills, Lyria for music, TTS for voice).gates, the quality checks every output must pass, like prompt match, sharpness, motion coherence, text legibility, on-brand, and claims risk. Failures regenerate selectively.budget, the spending ceiling and per-step limits for a run, so a recipe can't overspend.checkpoints, the points where the pipeline pauses for human approval before continuing.assemble, how passing assets are rendered and where the finished file lands in your storage.
The power is in the combination: inputs make a recipe general, gates and budget make it safe, and the plan and assemble sections make it produce something finished rather than raw.
How recipes run on Autopilot
Once a recipe exists, running it is the easy part, you can trigger it three ways: on demand for a one-off, on a schedule via the automation scheduler so content ships without anyone pressing a button, or in bulk to fan one recipe out across many inputs. The same recipe that makes one launch video can make fifty regional variants, see batch generate videos at scale for that pattern.
Because every generation carries a portable trace, model, prompt, parameters, and score, a scheduled run isn't a leap of faith, you can inspect why any asset passed or failed, reproduce it, and trust the output enough to let the pipeline run unattended. That combination of repeatability and auditability is what makes hands-free generation safe to depend on.
Recipes versus prompt templates
The two are easy to confuse, so here's the honest distinction.
| Prompt template | JSON workflow recipe | |
|---|---|---|
| Scope | One generation step | The whole pipeline |
| Output | A clip or image | A finished, assembled cut |
| Quality control | You judge it | Gates score it automatically |
| Governance | None | Budget caps and checkpoints |
| Reuse | Copy and paste | Inputs and versioning |
A prompt template is a useful building block, and recipes often contain them inside the generate step. But a template stops at "make this thing," while a recipe carries the work all the way to a shippable deliverable with checks and limits along the way.
Who should use JSON workflow recipes
- Agencies standardizing how every client's content gets made, so quality doesn't depend on which editor caught the project. It's how teams scale video without hiring.
- Marketing teams running always-on, multi-variant campaigns from one definition.
- SaaS and product teams that ship constantly and want launch and feature videos to keep pace automatically.
- Developers wiring CoreReflex into their own apps through the API, SDK, and MCP, triggering recipes as part of a larger system.
If your content needs are repeatable and your quality bar is non-negotiable, recipes are the format that lets you have both.
Frequently asked questions
What is a JSON workflow recipe?
It's a declarative, machine-readable definition of a complete content pipeline, its inputs, planning, generation steps, quality gates, budget, checkpoints, and assembly, that CoreReflex can run hands-free and reproduce exactly. Because it's structured data, you can save, version, share, and rerun it without the result drifting between runs.
How do JSON recipes differ from prompt templates?
A prompt template governs a single generation step and produces one asset that you then judge yourself. A recipe orchestrates the entire pipeline, planning, generating, scoring, governing, and assembling, and produces a finished, quality-checked deliverable. Recipes often contain prompt templates inside them, but they add the structure, gates, and limits a template lacks.
Do I need to code to build a recipe?
No. Recipes are authored from the studio without writing JSON by hand, and the structured format exists so that the work is repeatable and auditable, not so that you have to be a developer. If you do write code, the same recipes are fully programmable through the API, SDK, and MCP, so engineering teams can generate and trigger them from their own systems.
Can a recipe run on a schedule?
Yes. Recipes are built to run unattended, on demand, on a recurring schedule through the automation scheduler, or in bulk across many inputs. Quality gates and budget governance keep scheduled runs inside the limits you set, so hands-free doesn't mean hands-off control.
Turn your pipeline into something you can run on repeat
A JSON workflow recipe is the difference between making a video and owning a production line: define the pipeline once, govern it with gates and budgets, and let Autopilot run it on demand or on a schedule with a trace behind every asset. That's how content stops being a series of one-off projects and becomes infrastructure. Start free with no credit card and build your first recipe.