Programmatic editor control means driving the CoreReflex timeline with code instead of a mouse, adding clips, trimming, grading, captioning, and reading the results back as structured data your program can act on. For developers, agencies running the same edit across hundreds of projects, and anyone wiring an AI agent into a real production pipeline, the editor stops being a place you click and becomes an API you call. That shift is what the programmable JSON engine over editor state is built to deliver.
What programmatic editor control means in CoreReflex
A traditional video editor keeps its truth in the UI: the timeline is whatever you've dragged into place, and the only way to change it is to drag again. CoreReflex inverts that. The editor's state, every track, clip, trim, transition, grade, and caption, is data, and that data is addressable. Anything you can do by hand in the editor. You can express as a JSON command and submit programmatically.
The practical consequence: edits become repeatable and composable. You can script "add this intro, trim each clip to four seconds, apply the brand grade, burn in captions" once and run it across an entire library. You can diff two versions of a project the way you diff code. And because the commands return structured results rather than a screenshot, the next step in your program knows exactly what happened.
The JSON engine: editor state as data
At the center is a JSON engine that treats the project as a structured document and exposes operations over it, you don't manipulate pixels; you manipulate the description of the edit, and the render path turns that description into video. If you've worked with document databases or infrastructure-as-code, the mental model is familiar: declare the state you want, submit it, get a structured response.
This is the same idea explored in our piece on treating video as data with the JSON engine, the timeline is a queryable, command-driven object, not an opaque binary. Because the state is structured, you can query it ("how many clips are on the video track, and what's the total duration?") as readily as you command it ("trim clip 3 to start at 00:02").
A command vocabulary for the timeline
Commands map directly onto the edits you'd otherwise perform by hand. The shapes below are illustrative of the model rather than a full reference, the goal is to show how a UI action becomes a structured instruction.
| Editor action | Command shape (illustrative) |
|---|---|
| Add a clip to a track | {"op":"addClip","track":"video","assetId":"…","start":0} |
| Trim a clip | {"op":"trim","clipId":"…","in":"00:02","out":"00:06"} |
| Apply a color grade | {"op":"grade","clipId":"…","preset":"brand"} |
| Add captions | {"op":"caption","clipId":"…","source":"transcript"} |
| Set a camera move on a shot | {"op":"setCamera","shotId":"…","move":"push-in"} |
Camera moves deserve a special note, because they're where generation and editing meet. The JSON shot spec carries the move as a first-class field, and our breakdown of camera moves in the JSON shot spec shows how that field flows through to the underlying model so a "push-in" you write in JSON becomes an actual push-in on screen.
Reading structured results back
The half of programmatic control that gets ignored is the response. A command that silently succeeds or fails is useless to an automated pipeline. CoreReflex returns structured results: the updated state, the IDs of anything created, and, for operations that touch generation or scoring, the quality-gate outcome and the provenance trace. Your program can branch on those results: if a regenerated shot still fails its motion-coherence or on-screen-text check, your code can decide whether to retry, swap the prompt, or surface the shot for human review. Structured-in, structured-out is what makes the loop programmable instead of merely scriptable.
From one command to a scheduled workflow
A single command is useful; a sequence of them is a workflow; a workflow you can schedule is leverage. Because every edit is expressible as data, you can capture a sequence as a reusable recipe and run it without a human in the seat. That's the foundation of Autopilot, programmable JSON workflows that companies schedule for hands-off generation, backed by an automation scheduler. Our overview of scheduling hands-off generation with Autopilot covers how a recipe you author once turns into a standing pipeline that produces, scores, and assembles on a cadence you set.
This is the difference between automating one render and operating a content factory: the same JSON that drives a single timeline edit composes into a workflow that runs on a schedule, with budget and checkpoint governance around it.
Where the SDK, API, and MCP fit
The JSON engine is the substrate; you reach it through several surfaces depending on how you build.
- Public API + API keys. Call the platform directly over HTTP, authenticated with a key, when you're integrating from your own backend.
- SDK. A typed client wraps the API so you're not hand-rolling requests. If you're starting here, the SDK quickstart walks you through your first render.
- MCP server. This is the surface for AI agents. Exposed over the Model Context Protocol, the editor becomes a set of tools an agent can call, boarding shots, running edits, reading results, which is what makes it a film studio that AI agents can operate.
Whichever surface you pick, the underlying contract is the same JSON over the same editor state. Full method-level details live in the developer documentation.
Provenance and determinism for automated edits
Automation raises the stakes on reproducibility: if a pipeline produced something you can't explain or reproduce. You can't trust it in production. Two properties make programmatic control safe to lean on.
First, every generation carries a portable provenance trace, model, prompt, parameters, and score, so an automated edit is auditable after the fact. When a workflow regenerates a shot at 3 a.m., the trace tells you exactly what it did and why. Second, the render path is deterministic: the same manifest produces the same cut, so a workflow that ran last week reproduces byte-stable output this week. Together they mean programmatic edits aren't a black box, they're inspectable, repeatable instructions.
You can find more developer-focused walkthroughs across the developers section of the blog.
Frequently asked questions
Can I control the CoreReflex editor with code?
Yes. The editor's entire state is exposed as a programmable JSON engine, so any edit you'd make by hand, adding clips, trimming, grading, captioning, setting camera moves, can be submitted as a JSON command through the API, the SDK, or the MCP server. The same commands return structured results your program can branch on.
How do JSON commands map to timeline edits?
Each command names an operation and its target, for example, trimming a clip by ID with an in and out point, or applying a grade preset to a clip. The engine applies it to the project state and returns the updated state plus any created IDs, and the render path turns that state into video. There's a direct one-to-one correspondence between UI actions and command shapes.
What's the difference between the API, the SDK, and MCP?
The API is the raw HTTP interface authenticated by key; the SDK is a typed client over that API for your own backend; and MCP exposes the editor as tools for AI agents to call. All three sit on the same JSON engine and the same editor state, so you can mix them, for example, an agent over MCP and a scheduled job over the SDK hitting the same project.
Are programmatic edits reproducible?
They are. Every generation carries a portable provenance trace, and the render path is deterministic, so the same manifest produces the same cut. An automated workflow can be audited after the fact and re-run with stable results.
Build the editor into your pipeline
Programmatic editor control turns CoreReflex from an app you operate into infrastructure you build on. JSON in, structured results out, with provenance and deterministic rendering underneath. Whether you're scripting one repeatable edit or standing up an agent that produces video on a schedule, the JSON engine is the same dependable substrate. Spin up a project and make your first programmatic edit today, start free, no credit card required.