An AI video editor where the agent has hands.
NeoMotion exposes its whole production surface over MCP. Your agent doesn't write a description of a video — it creates the project, pulls the footage, cuts out the images, casts the presets, keyframes the timeline, voices it, and hits export. On your machine, on the AI subscription you already pay for, with no API key in the middle.
Claude Code · Claude Desktop · Cursor · Codex · and now claude.ai and ChatGPT
claude mcp add --transport http neomotion \
http://127.0.0.1:4399/mcp \
--header "Authorization: Bearer $NM_MCP_TOKEN"Your agent can already write a video. It still can't make one.
Point any good coding agent at a render library and you get a file full of code. Here's what's still missing at that point — and what NeoMotion hands the agent instead.
Agent + a render library
- Writes code that describes a video
- You still source every asset by hand
- No background removal, no colour match
- Re-render the whole thing to see a change
- Non-developers can't touch the result
- You own a repo, not a composition
Agent + NeoMotion
- Operates a real editor, verb by verb
- Searches stock, generates what's missing
- Cuts subjects out, matches the grade
- Change one layer, keep the render
- Hands off to anyone who can use a timeline
- You own a project file that keeps opening
A hundred verbs, grouped the way a production runs.
Every one is a real MCP tool call, schema-validated, running against the app on your desktop — and every one is also a shell command, so an agent that doesn't speak MCP still gets in. Nothing here is a prompt template.
Project
Open a workspace and read its state.
- create_project
- list_projects
- get_manifest
- update_manifest
- set_project_style
Material
The part other tools skip: getting, reading and preparing real assets.
- search_media
- import_media
- import_local_media
- generate_image_asset
- generate_3d_asset
- probe_media
- media_filmstrip
- media_waveform
- transcribe_media
- analyze_project_assets
Direction
Turn a topic or a script into an approved storyboard.
- start_director
- compose_storyboard
- compose_scenes
- approve_scenes
- start_auto_edit
- review_auto_edit_scenes
- polish_auto_edit_plan
Authoring
When no preset fits, the agent writes the motion itself.
- draft_component
- submit_user_motion
- submit_scene_component
- draft_expression
- draft_fx_effect
- compose_motion_block
Style
Read a look off a reference and hold every scene to it.
- list_styles
- get_style_atoms
- start_style_pack_decode
- submit_style_pack_reading
- merge_style_pack_clusters
Output
Render locally, at the format you actually ship.
- start_export
- get_export_status
- assemble_scenes_into_project
- promote_scene_component
Custom motion the agent writes is gated before it lands: schema validation, capability lint, and a determinism byte-probe. Same input, same frames, every run.
Connect it.
Token-gated, and bound to 127.0.0.1 until you decide otherwise. Web chats reach it through a relay you switch on and approve — never by default.
Turn on the control surface
In NeoMotion: Settings → Local agent server. Toggle it on and copy the session token. It binds to 127.0.0.1 and nothing else.
Register the server
One command for Claude Code and Kimi, a one-click extension for Claude Desktop, the standard mcpServers block for Cursor. For claude.ai or ChatGPT, switch on Cloud Link and add the URL as a connector — then on ChatGPT, upload the skill (Settings → Download SKILL.md) so it gets the same directing playbook Claude agents install automatically. No MCP support at all? Every verb is also a shell command — the neomotion CLI ships with the app, so anything that can run a command can drive it.
Brief it like a crew
Ask in plain language. The agent picks the verbs, shows you the plan, and you approve before assets are fetched or anything renders.
{
"mcpServers": {
"neomotion": {
"type": "http",
"url": "http://127.0.0.1:4399/mcp",
"headers": {
"Authorization": "Bearer <token from Settings → Local agent server>"
}
}
}
}You brief it. It does the production.
Real briefs, not prompt engineering. The agent decomposes them into verbs and shows you the plan first.
Make me a 60-second explainer on why global coffee prices spiked this year. Documentary look, big stats, cutout photos.
What it runs · Researches the topic, writes the narration, storyboards it, pulls and cuts out the photos, casts stat and headline presets, builds the comp.
Here's my raw talking-head recording. Cut the dead air, add kinetic captions, and drop b-roll wherever I mention a product.
What it runs · Transcribes word-by-word, proposes an edit plan anchored to your actual words, fetches b-roll only after you approve it.
I need a lower-third that matches this screenshot. Make it editable so my editor can swap the name later.
What it runs · Authors a native layout of text and shape layers, installs it as a preset, and expands into per-element layers on the timeline.
Build me an animated radar sweep with a scanning line and four blips.
What it runs · Writes a deterministic React/Remotion module, passes the capability lint and byte-probe, and installs it as one editable timeline layer.
We don't resell you tokens.
You already pay Anthropic, or OpenAI, or whoever. Bring that. NeoMotion charges for the app, never for the inference — there are no bundled credits to run out of at the worst possible moment, and no markup hiding in a subscription. If you'd rather not manage keys at all, the app ships with a built-in agent too.
- Bring your own Claude, ChatGPT, Cursor or Kimi subscription
- Voiceover and English transcription run locally — no key, no bill
- Renders run on your own GPU — unmetered, on every plan
- Token-gated, local by default, and your files never leave the disk
The questions engineers ask.
It stops before the expensive part. The storyboard comes back for approval before a single asset is fetched or generated. Reject it and you've spent a script's worth of tokens, not a production's.
The composition layer is. Presets carry semantic metadata and render the same frames from the same input, and any custom component the agent authors has to pass a byte-probe before it installs. The model's creative choices vary; the rendering underneath them doesn't.
It doesn't get installed. Submitted motions and components run a schema check, a capability lint, and a render probe first, and failures come back to the agent with the reason so it can fix them. A human still confirms the install.
By default, no — the MCP server binds to 127.0.0.1 and requires a bearer token from the app, and a local agent talks to it over loopback. Your media, projects, and renders stay on disk either way. Two things change that, and both are yours to switch on: connecting claude.ai or ChatGPT routes the agent's instructions through our relay (never your media), and any provider key you add sends that request straight to that provider. Voiceover and English transcription run locally, so those never leave at all.
Not for the core chain. Your agent's own subscription does the thinking, your machine does the rendering, and voiceover and English transcription now run on local models we ship. Keys are left for generated imagery and background cutouts (Replicate), and for the built-in director if you'd rather NeoMotion drove itself than brief it yourself.
Yes. It's a plain MCP server over streamable HTTP. Anything that can hold a session and call a tool works — a shell script, a CI job, your own orchestrator.
Your agent is ready for this. Give it hands.
Early access is open. Founding pricing is locked while the cohort is.
Start free — 14 daysmacOS & Windows · No credit card · Bring your own model