A JSON video engine treats your timeline as structured data instead of a panel of buttons, you query the state of a project, send commands to change it, and get structured results back, all without ever opening the editor. CoreReflex exposes exactly this: a programmable JSON layer that sits over the live editor state so you can read, reason about, and rewrite a film headlessly. For developers, agencies, and teams automating creative work, that shift from clicking to describing as data is the difference between hand-editing one project and operating thousands.
What a JSON video engine actually is
Most video tools store your edit as an opaque binary or a proprietary project file you can only touch through their UI. A JSON video engine inverts that. The project, its shots, layers, clips, audio, captions, timing, and the Director's shot board, is represented as plain, addressable data. Anything you can do with a mouse has a structured equivalent you can express in JSON and send over the wire.
The practical consequence is that editing becomes a two-way conversation with structured payloads. You ask the engine a question ("what shots are in scene two, and which failed the quality gate?") and it answers with structured results. You issue an instruction ("set the camera move on shot four to a slow push-in and re-board it") and it applies the change to the same state the editor would. There's no screen-scraping, no brittle macros recording clicks, the data model is the API surface.
This is the foundation of CoreReflex's programmable JSON engine over editor state: one canonical representation that both humans and machines drive.
Query your timeline, command your timeline
The engine splits cleanly into two halves: reads and writes. Keeping them distinct is what makes automation safe. You can inspect before you mutate, and you can build logic that only acts when the data says it should.
Reading state with queries
A query returns a structured view of the project without changing anything. You might pull the full shot list, filter to clips on a specific track, fetch every caption to audit on-screen text, or read the quality-gate score attached to each generated shot. Because results come back as data, not a rendered screenshot, you can pipe them straight into your own logic. Counting shots that scored low on prompt match, collecting the duration of every B-roll clip, or extracting the soundtrack's tempo are all just field reads.
Queries are free and instantaneous because they don't touch generation. In CoreReflex, planning, scoring, and editing never cost credits, only generation does, so you can interrogate a project as often as you like while you build automation around it.
Writing state with commands
A command changes the project. Add a shot, retime a clip, swap a voiceover, set a transition, update a caption, or rewrite a shot's prompt and camera move. Each command targets a specific node in the data and applies a deterministic change, so the same command against the same state always produces the same result. That property is what lets you replay a sequence of edits or generate hundreds of variants from one template by changing a handful of fields.
Camera direction is a first-class part of the shot spec rather than an afterthought, which is why you can express a dolly, pan, or push-in declaratively, the mechanics of that are covered in how camera moves live in the JSON shot spec.
Why edit-as-data beats clicking through a UI
A UI is perfect for one project and one person. It does not scale to a hundred localized cuts, a nightly batch of product videos, or a marketing team that wants the same brand intro stamped onto every asset. Edit-as-data scales to all of those because the work is expressible, repeatable, and diffable.
- Repeatability. A JSON document describing a film can be version-controlled, reviewed, and re-run. You can diff two cuts the way you diff two commits.
- Composition. Small structured edits compose into pipelines. One workflow can produce a master cut; another can fan that master out into platform-specific variants.
- Auditability. Because every generated shot carries a portable provenance trace, model, prompt, parameters, and score, you can replay exactly how an asset was produced. Nothing about the result is mysterious or unreproducible.
- Headless operation. No human has to be in the loop for the edit to happen. That's the precondition for scheduling generation to run while your team sleeps.
That last point is where the engine connects to Autopilot's scheduled, hands-off generation: the JSON engine is the substrate, and Autopilot is the scheduler that runs structured recipes against it on a cadence you define.
How the JSON engine fits the agentic Director
The engine is not a separate product bolted onto the editor, it's the same state the agentic Director reads and writes as it works. CoreReflex's Director runs a loop: PLAN the shots, PRODUCE the generations, CRITIQUE each result against a quality gate, and ASSEMBLE the cut. Every one of those stages reads from and writes to the JSON state.
When the Director boards a shot, it's writing a structured node with a role, a camera move, and a prompt. When the quality gate scores a shot on concrete checks, prompt match, sharpness, motion coherence, on-screen text legibility, on-brand fit, and claims risk, the score lands on that node as data you can query. When a shot fails, the Director triggers selective regeneration of just that shot rather than starting over, and the new generation overwrites the node while preserving the trace. Because you're reading the same data, your automation can watch this unfold: poll for shots that haven't passed, surface them for human review, or kick off your own follow-up commands.
From JSON to a rendered cut
Structured editing is only useful if the data turns into a real file. The JSON engine hands off to a deterministic render path: a Remotion render-worker claims the job, renders the manifest, uploads the result to your storage, and records an asset row. Because the manifest is derived from the canonical JSON state, the same manifest always renders the same cut, there's no drift between what you described and what ships.
That determinism is why edit-as-data is trustworthy at scale. You can generate a thousand manifests programmatically and know each will render exactly as specified, with retries and a dead-letter queue catching the rare infrastructure hiccup instead of silently producing a broken file.
Working with the engine: API, SDK, and MCP
There are three ways to drive the engine, and they share the same underlying data model.
- The public API. Authenticate with an API key and send queries and commands directly over HTTP. This is the lowest-level, most flexible entry point and the one to reach for when you're integrating CoreReflex into an existing backend.
- The SDK. A typed client wraps the API so you spend less time on request plumbing and more on logic. The fastest way to your first programmatic render is the CoreReflex SDK quickstart, which walks from an API key to a finished cut.
- MCP. The Model Context Protocol server exposes the engine to AI agents as tools, so an autonomous agent can plan, board, score, and assemble films through the same structured interface a developer uses. We go deeper on that in the MCP server that turns the studio into a tool for AI agents.
Whichever surface you choose, the contract is identical: structured in, structured out, reproducible every time. Full reference material lives in the developer documentation.
Frequently asked questions
What is the CoreReflex JSON engine?
It's a programmable layer that represents your entire editor project, shots, clips, audio, captions, timing, and the Director's shot board, as structured JSON. You send queries to read that state and commands to change it, and you get structured results back. It's the same state the agentic Director reads and writes, so automation and the editor stay perfectly in sync.
Can I edit a project without using the UI?
Yes. Everything the editor can do has a structured equivalent you can express as a command and send through the API, SDK, or MCP. You can build, modify, score, and render a complete project headlessly without ever opening the interface, which is what makes batch and scheduled generation possible.
Does using the JSON engine cost credits?
Reading state and issuing edit commands are free, planning, scoring, and editing never cost credits. Youonly spend credits when you generate media, that means you can query and restructure a project as much as you want while building automation, and pay only for the generations you actually run.
Is a programmatic edit reproducible?
Yes. Every generated shot carries a portable provenance trace, and the render path is deterministic, the same manifest renders the same cut. Combined with version-controllable JSON. That means any edit or render can be replayed and audited exactly.
Start editing video as data
The JSON engine turns video from something you assemble by hand into something you describe, query, and command at scale, backed by a quality gate on every shot and a render path that ships the same cut every time. If you'd rather operate a studio than babysit a timeline, that's the whole point. Start free with no credit card and run your first structured edit today.