MCP server
Give your agent
video-editing capability.
An agent that can write the brief can now finish the edit. The MCP server exposes the whole workflow as tools: find the footage, compose a cut against the brief, read the plan, render the files.
Nothing is generated. Every segment is lifted from your own footage and named in a plan the agent can read before any render.
13 tools · one Bearer key · streamable HTTP
YOU The clearest answer we gave on data residency,
45 seconds, vertical. Show me the plan first.
list_source_groups → "Town hall · 12 Aug" · ready
create_cut → c7d2… · "planning"
get_cut_plan → v1 · 3 segments · 46.2 s
revise_cut_plan "Lead with the answer itself."
→ v2 · 3 segments · 44.8 s
──────── plan approved · the next call spends ────────
render_cut → 9:16 · queued
The plan arrives as a document with source timecodes. render_cut is the step that produces the file. It spends nothing: source minutes are counted at ingest.
Video becomes an action an agent can complete.
Agents already research, write and file. Video has stayed a handoff: the workflow produces a request for an editor, then stops. These tools carry the task through to the finished file.
The brief is already written
Your agent holds the context: the campaign, the audience, the argument it is making. create_cut takes that context as a prompt of up to 2,000 characters and plans an edit from the footage to match it.
The plan is machine-readable
Planning returns a document: ordered segments, each naming its source and timecodes, with an estimated duration against the target. An agent can check the result against the brief and correct it before anything renders.
Same contract as your code
Each tool delegates to the same service as the REST API. Same validation, same lifecycle, same structured errors. What your agent does and what your pipeline does cannot disagree.
Thirteen tools cover the workflow.
Grouped the way an agent uses them. Every tool is listed here by its real name, and each one delegates to the same service as the REST API, so behaviour is identical call for call.
| Tool | Scope | What it does |
|---|---|---|
| Explore footage | ||
list_source_groups | read | Browse the footage library, with durations and camera counts. |
get_source_group | read | One group in detail: its files and whether they are ready. |
get_transcript | read | The diarized transcript, as segments, words or captions. |
get_speakers | read | Who spoke and for how long, with sample quotes to tell them apart. |
| Plan cuts | ||
create_cut | write | The brief, the source groups (up to four) and the settings. Planning starts. |
get_cut_plan | read | The plan document, segment by segment. A revise leaves the previous version readable while it runs - the cut's status is the signal. |
update_cut_plan | write | Structural edits: remove, reorder, pin, unpin. Synchronous, at no cost. |
revise_cut_plan | write | A plain-language instruction, up to 500 characters. The cut returns to planning. |
| Render | ||
render_cut | write | Render the plan in one to three aspects. This is the call that spends. |
get_renders | read | Statuses, signed URLs and sidecar files for every render. |
| Manage | ||
list_brand_kits | read | The brand kits a cut can carry: colours, captions, logo, end card. |
name_speakers | write | Give diarized speakers their display names. |
delete_render | admin | Remove a rendered file. The one tool that needs an admin key. |
Schemas, worked sessions and connection detail are in the MCP docs →
Plan, read, revise. Then render.
Planning is asynchronous: create_cut returns at once and the plan follows as a document the agent reads like any other structured result. Rendering is a separate, explicit call.
If the plan misses the brief, the agent has two correction paths. update_cut_plan applies structural edits synchronously at no cost: remove a segment, reorder, pin the ones that must survive. revise_cut_plan sends the whole plan back with an instruction, and a new version comes out of planning.
Every version is kept, and the loop can run as many passes as the brief needs before the render is requested. Source minutes are counted once, at ingest; planning, revising and rendering use none. Paid plans start at £39 a month for 240 source minutes. See pricing →
The honesty is in the schema
render_cut · “THIS SPENDS MONEY”
That warning is in the tool description itself, in capitals, where an agent reads it before every call. Twelve tools explore, plan and manage. One renders, and it announces what that means.
What you say to the agent.
Three asks these tools can carry end to end, each inside the real limits: a target between 10 and 600 seconds, up to three aspects, up to four source groups per cut.
You, to your agent
“Take Tuesday's town hall and cut the clearest answer we gave on data residency. 45 seconds, vertical, and show me the plan before anything renders.”
create_cut · target_duration_s: 45 · aspects: ["9:16"] · 1 group
You, to your agent
“Search all four customer interviews for the moments where someone describes their first week, and compose a 90-second landscape reel in their own words.”
create_cut · target_duration_s: 90 · aspects: ["16:9"] · 4 groups
You, to your agent
“Make a 30-second square teaser from the keynote. Keep the running order chronological and apply our brand kit.”
create_cut · target_duration_s: 30 · aspects: ["1:1"] · chronology: "strict" · brand_kit_id: "b1a4…"
One endpoint, one header.
The server is anjin-media, version 1.0.0. Any MCP client that speaks streamable HTTP and can send an Authorization header can connect.
- Endpoint
https://anjin-media-api.fly.dev/mcp- Transport
- Streamable HTTP, stateless. There is no session to establish or keep alive; every call stands on its own.
- Auth
Authorization: Bearer mk_live_…on every call. The same keys as the REST API, minted in the dashboard and shown once.- Scopes
- Checked per tool: read, write or admin. A read key can explore footage and plans; it cannot create, revise or render.
- Batching
- JSON-RPC batch arrays are rejected with a 400: send one request per call.
{
"mcpServers": {
"anjin-media": {
"type": "http",
"url": "https://anjin-media-api.fly.dev/mcp",
"headers": {
"Authorization": "Bearer mk_live_…"
}
}
}
}Keys are minted under Settings → API keys and carry the scopes you choose. The connection guide walks through the first session.
Built for agents you have to trust.
An agent with tools is an agent with your allowance and your footage. The server is arranged so the risky step is explicit and everything before it is inspectable.
- What stops an agent overspending?
- Spend is concentrated in one explicit call. The plan arrives first as a readable document, the agent can hold it for your approval, and render_cut's own description warns that it spends money. Leave auto_render off and nothing renders until that call is made.
- What can a scoped key not do?
- Scopes are checked on every tool call. A read key explores footage and reads plans. A write key composes, revises and renders. Only an admin key can delete a render, and an agent doing composition work never needs one.
- Can the render drift from what was approved?
- render_cut accepts a plan_version, so the agent renders the exact version that was reviewed rather than whatever is latest. Every version is kept, whether the planner wrote it, a revision produced it, or update_cut_plan edited it.
- What happens when a call is malformed?
- Validation is identical to the REST API, and a failed call returns the same structured problem JSON inside the tool result: a stable code, a human-readable detail and a documented type URL. The agent reads the failure and corrects the call.
Questions
- Which MCP clients can connect?
- Any client that supports the streamable HTTP transport and can send an Authorization header. The server is stateless, so there is no session to establish or keep alive; each tool call authenticates itself with the Bearer key.
- Do I need a separate key for MCP?
- No. The server accepts the same Bearer keys as the REST API. Mint one in the dashboard under Settings → API keys, scope it read, write or admin, and revoke it whenever you choose. The raw key is shown once.
- Can the agent render without my approval?
- Only if you arrange it that way. render_cut is a separate, explicit call, and the plan is readable before it is made. Two things to know: setting auto_render on create_cut renders the first plan automatically, and a write-scoped key is allowed to call render_cut. For a human gate, keep auto_render off and have the agent hand you the plan.
- What does the agent get back after a render?
- For each aspect: the finished MP4 behind a signed URL, SRT and WebVTT captions, an EDL as JSON naming every segment's source and timecodes, and a QC report. get_renders returns them all in one call.
- Is MCP behaviour different from the REST API?
- No. Each tool delegates to the same service as the corresponding REST route, so validation, lifecycle and errors are identical. The difference is ergonomics: typed tools an agent can discover and call directly, one request per call, with failures returned as structured problem JSON inside the tool result.
The edit is now a tool call.
13 tools · the same engine as the app and the API