A programmable JSON engine is a layer that exposes your entire project, every shot, clip, track, and parameter, as structured JSON you can read and change with commands instead of clicks. In CoreReflex it sits over the editor state, so anything you could do by hand in the timeline. You can also do programmatically. That turns a creative tool into something you can query, script, and automate.
What "editor state as JSON" really means
Most creative apps keep their project state locked inside the UI. You can see it, but you can't address it, there's no clean way to ask "what shots are in this project?" or "change every clip on track 2" without doing it by hand. CoreReflex treats the project as data first. The timeline, the shots, their prompts, camera moves, durations, and scores all live in a structured document, and the editor is just one view onto it.
Because the state is structured, two kinds of operations become possible: reading it (queries) and changing it (commands). Both return structured results, so a program can act on what it gets back. This is the same philosophy that makes code-driven video predictable, applied to an agentic studio.
Querying: read shots, clips, and the timeline
A query asks a question about the project and gets a structured answer. Representative things you can ask:
- List every shot in a project, with its role, prompt, and quality score.
- Find all shots that failed a specific quality check.
- Return the timeline as an ordered set of clips with durations and tracks.
- Pull the provenance trace for a given generated asset.
A representative response shape looks like this:
{
"project": "launch-teaser",
"shots": [
{ "id": "s1", "role": "hook", "score": 0.92, "passed": true },
{ "id": "s2", "role": "product", "score": 0.71, "passed": false }
]
}Because the result is JSON, you can pipe it straight into logic: regenerate everything under a score threshold, count shots flagged for claims risk, or build a dashboard of project health. The exact fields are documented in the docs.
Commanding: change the project programmatically
A command mutates the state. Instead of dragging a clip or retyping a prompt, you describe the change and the engine applies it to the same project document the editor renders from. Representative commands include adding a shot with a role and prompt, retiming a clip, swapping a track's audio, or triggering selective regeneration of the shots that failed a gate.
The important property is that commands operate on the same canonical state the UI uses. There's no separate "API project" that drifts from what you see, change it in code and the editor reflects it, change it in the editor and a query sees it. That single source of truth is what makes scripting safe.
How it connects to the wider platform
The JSON engine is the foundation the rest of the automation stack stands on. A public API, API keys, and an SDK give you programmatic access from your own code, and an MCP server exposes the same surface to AI agents and assistants. On top of that sit the higher-level recipes, our explainer on JSON workflow recipes in CoreReflex shows how a sequence of these commands becomes a reusable pipeline.
Once you can express a project as commands, you can schedule it. That's how teams move from clicking "generate" to scheduling hands-free video generation, the Autopilot scheduler runs JSON workflows on a cadence, producing assets without anyone in the editor.
Why structured state matters: reproducibility and control
Two benefits fall out of this design that you don't get from a UI-only tool.
First, reproducibility. Because every generation carries a portable trace, model, prompt, parameters, score, and the project itself is just data, the same manifest renders the same cut every time on the deterministic render path. That's the backbone of reproducible AI generations with provenance: you can replay exactly what produced an asset.
Second, governance. When a project is data, you can put rules around it, budget caps on a run, quality thresholds every shot must clear, checkpoints that pause for human approval. We cover this in depth in budget governance for creative automation, because programmable power without limits is how you wake up to a drained credit balance.
A simple mental model
Think of CoreReflex as a database with a creative renderer attached. The programmable JSON engine is the query-and-command interface; the editor is one client; Autopilot is another client that runs on a schedule; the SDK and MCP are how your code and your agents become clients too. They all read and write the same structured state. Browse the automation guides to see how the pieces combine into full production lines.
Frequently asked questions
What is the programmable JSON engine?
It is a layer that exposes CoreReflex's editor state as structured JSON you can read with queries and change with commands. Anything in your project, shots, clips, tracks, prompts, parameters, scores, is addressable as data. That lets you script and automate work that would otherwise require clicking through the UI.
Can I query a project's shots and timeline?
Yes. You can read the full set of shots with their roles, prompts, and quality scores, and you can return the timeline as an ordered set of clips with durations and tracks. Because the response is structured JSON, you can feed it directly into your own logic or build tooling on top of it.
How do JSON commands change editor state?
Commands operate on the same canonical project document the editor renders from, so a change made in code shows up in the UI and vice versa. You describe the change, add a shot, retime a clip, regenerate the shots that failed a gate, and the engine applies it to the shared state. There is no separate copy that can drift out of sync.
Do I need to be a developer to use it?
To call the API or SDK directly, yes, but most people interact with the engine indirectly through Workflow recipes and the Autopilot scheduler, which wrap it in a higher-level interface. The MCP server also lets AI agents drive it conversationally, so you can describe what you want rather than writing the JSON by hand.
Put your project on programmable rails
When your creative project is data you can query and command, automation stops being a bolt-on and becomes the native way you work. Read the state, change it in code, schedule the result, and replay it whenever you need to. Start free with CoreReflex, no credit card required and see the editor state behind your first project.