[ReelMy · the agent surface]
Your agent. Your subscription. Our editor.
ReelMy isn't a chatbot we host and bill you for. It's ReelM's editor exposed as an MCP server — 79 tools driving your live timeline — operated by an agent CLI you already have installed, on a model plan you already pay for.
NO ASSISTANT FEES · NO PER-PROMPT CREDITS · BRING YOUR OWN CLI
- TOOLS
- 79 · MCP
- AGENTS
- 5 CLIs
- SKILLS
- 2 + 3 subagents
- MODES
- express · plan
- BATCH
- 50 edits, 1 undo
- CHECKPOINTS
- 10 deep
[How it's wired]
Three parts, and none of them guess
Your agent CLI runs locally in your project folder. It reaches the editor through ReelM's relay, which forwards a call only when it can prove your desktop app is the one on the other end.
Your agent CLI
Claude Code, Codex, OpenCode, MiMo Code or Antigravity — spawned in your project directory, streaming its output straight into ReelM's panel.
The MCP relay
Streamable HTTP with a per-user API key. Stock searches are answered by the relay itself, so they keep working even with the desktop offline.
The live editor
Tool calls land on the running project's command layer — the same one your keyboard uses. Live, undoable, autosaved. Never a raw file write.
A stolen key is a dead key. Every app run mints a fresh pairing secret that lives only in memory and never touches disk. The relay acts on a tool call only when that secret matches a currently connected desktop — so a copied API key does nothing anywhere else.
[Bring your own agent]
Five CLIs. One tool surface.
MODELS AND EFFORT LEVELS ARE READ FROM THE CLI ITSELF — NEVER INFERRED.
| Agent | Transport | Models | Effort |
|---|---|---|---|
Claude Code Anthropic Long-context aliases are surfaced explicitly, so switching model never silently drops you from a 1M window to 200k. | Streaming JSON | Opus 4.8Sonnet 5Haiku 4.5 | low → max |
Codex OpenAI Runs through the app server specifically to get per-token streaming, with the API key passed by environment variable — never on the command line. | App-server JSON-RPC | gpt-5.6-terragpt-5.6-luna | minimal → ultra |
OpenCode OpenCode MCP configuration is handed over the protocol at session start, so nothing is written to disk. | ACP over stdio | Any configured provider | — |
MiMo Code Xiaomi Reasoning effort is expressed as the model variant itself rather than a separate flag. | ACP over stdio | mimo-automimo-v2.5-pro | Baked into model variant |
Antigravity Google The only CLI that expands no variables, so it is also the only one documented as receiving a literal key on disk. | One-shot | Gemini 3.5 Flash | — |
[Watch a turn]
Real prompts, real tool names
Every call below is a tool that exists. Pick a scenario and watch the turn run end to end.
[The turn, step by step]
Read, plan, snapshot, edit, look, lint
The last two steps are the ones most agents skip — and the reason ReelMy's output holds up.
Reads the real project
get_project, list_items, and get_selection — the actual state, including what you have highlighted right now.
Writes a plan (if you asked it to)
A title, a summary, numbered steps, assumptions, and open questions — submitted for approve, reject, or request-changes.
Takes a checkpoint
A full project snapshot before the risky part, so rejecting mid-execution restores exactly where you were.
Applies edits atomically
Up to fifty tool calls in one transaction against the live editor — all landing together as a single undo entry.
Renders a frame and looks at it
render_frame and render_contact_sheet return real images from the same pipeline the export uses.
Checks the layout before it stops
check_layout runs eight rules against the destination platform. Errors block completion — it doesn't get to say it's done.
[The tool surface]
All 79 tools, by name.
Before it changes anything, ReelMy can see the whole project — settings, tracks, every item, and what you currently have selected.
The same command layer your keyboard uses. Every call is an ordinary, undoable timeline edit.
Stock search across seven providers, the built-in SFX library, and full asset management with automatic relinking.
The deepest part of the surface — down to restyling a single substring inside an existing headline.
Filter presets by id, raw grade values, GPU effects, masks, and the chroma keyer.
Presets when a preset will do, raw keyframes with explicit easings when it won't.
Named regions instead of guessed pixels, real alignment operations, and an eight-rule linter that gates completion.
ReelMy renders real frames and contact sheets through the same pipeline as the export — so it checks the actual output, not a description of it.
Templates for pacing, a design system for consistency — the two things that stop a generated video looking generated.
Atomic multi-edit transactions, full project checkpoints, and the plan gate — the machinery that makes an autonomous agent safe to run.
[Autonomy]
Two modes, and the gate lives in the app
Plan mode is enforced by ReelM's own bridge rather than a CLI flag — because the permission model has to hold identically across five different agents.
Express
No gate. ReelMy reads the project, makes the edit, and tells you what it did. Checkpoints and undo are still there if you don't like it.
- Edits land immediately
- Every change is undoable
- Best for small, well-specified asks
Plan
Every mutating tool is refused until you approve a written plan. ReelMy submits a title, a summary, numbered steps, its assumptions, and any questions it has.
- Approve, reject, or request changes
- A checkpoint is taken on approval
- Step-by-step progress reported live
[Skills]
It knows the editor, and it knows editing
Two skills, installed globally into your agent. One teaches the mechanics; the other teaches judgement. Both load their references only when they're needed.
How the editor actually works — twelve reference documents the agent loads only when it needs them, plus a project validator it can run.
Why an edit works — scriptwriting, hooks and retention, pacing, platform conventions, and visual design. The difference between a correct video and a good one.
- reelm-video-editorThe full editing toolset, for execution.
- reelm-plannerRead-only plus research and plan submission.
- reelm-layout-auditorRead-only audit against the layout rules.
Typed straight into your agent — no ReelM window required.
[The panel]
A chat that knows where you're pointing
ReelMy lives beside the timeline, not in a browser tab — so it can see your selection, the range you marked, and the assets you mention.
Streaming, with its thinking shown
Token-by-token output, live reasoning in a disclosure, and tool calls rendered as real cards — not a wall of JSON.
It sees what you're pointing at
Your current selection and any range you mark on the ruler ride along with every message, drawn as a band on the timeline.
Mention anything
@timeline picks an item, @asset picks a file, and you can attach local files or links — all resolved into context the agent can actually use.
History that travels with the project
Sessions are written into the project folder, per agent — so a conversation moves with the work instead of living in your home directory.
Honest context accounting
Window occupancy and cost come from the CLI itself. Where a CLI doesn't report a number, ReelM says so rather than inventing one.
Commands where they make sense
/context, /model, /compact, /new and /clear — each shown only for the agents that support it, with a stated reason when they don't.
[Why it's safe to let it drive]
Nothing it does is a one-way door
A pairing secret that never touches disk
Every app run generates a fresh secret held only in memory. The relay acts on a tool call only when its secret matches a currently connected desktop — so a copied API key is inert anywhere else.
Atomic edits, one undo
Up to fifty edits can be submitted as a single transaction. All of them land or none of them do, and the whole batch collapses into one ⌘Z.
Ten checkpoints deep
Full project snapshots the agent takes before risky work — and that restoring is itself undoable. Checkpoints are cleared when you switch projects, so one project's snapshot can never land in another.
The gate lives in the app
Plan mode is enforced by ReelM's own bridge, not by a CLI flag — because the permission model has to hold identically across five different agents.
It can't declare victory on a broken layout
The linter is a completion gate: ReelMy cannot mark a plan complete while any layout error remains outstanding.
It edits the live project, not the file
Every tool call goes through the running editor's command layer. The agent is explicitly forbidden from hand-editing the project file — no races, no corrupted saves.
[Say it like this]
Eight things to try on day one
Each of these maps to real tools — no prompt engineering required.
"Make this a TikTok, not just vertical"
It sets the platform properly — canvas, frame rate, and measured safe areas together — then re-checks every element against TikTok's actual occluded bands.
"Make the word 'free' pop in the headline"
style_text_range restyles a single substring inside the existing text item. The rest of the headline is untouched.
"Whip pan on every cut in the b-roll track"
One bulk call applies the transition to every adjacent pair on that track — and one ⌘Z takes it all back.
"Warmer, and lift the shadows a touch"
Vague direction becomes real slider positions on temperature and shadows — or an adjustment layer if it should cover the whole sequence.
"Find me b-roll of a city at night"
It searches seven stock providers, downloads the winner into your assets folder, and places it on the timeline at the right length.
"Does this look right?"
It renders a contact sheet of the composition, looks at the frames, and tells you what's off — with the layout linter's verdict alongside.
"Build a 30-second product showcase"
It applies a template with real beats, pins a design system so every scene agrees, and fills the typed slots from your assets.
"Actually, undo all of that"
A batch is one undo step, and a checkpoint restores the whole project. Nothing the agent does is a one-way door.
[Questions]
ReelMy, answered
Whichever one you already use. ReelMy drives an agent CLI you have installed — Claude Code, Codex, OpenCode, MiMo Code, or Antigravity — and the models available are the ones that CLI offers.
No. ReelM does not charge for assistant usage. You bring your own agent CLI and your own model subscription, and the cost the CLI reports is shown in the panel.
The agent CLI runs locally in your project folder. It reaches the editor through ReelM's MCP relay, which only forwards a call when the pairing secret matches a currently connected desktop app.
It can edit it — that's the point — but every edit is an ordinary undoable command, batches collapse to a single undo, and checkpoints snapshot the whole project. In plan mode nothing mutates until you approve.
Yes. ReelM exposes the editor as an MCP server over streamable HTTP. Any MCP-capable client with your key and a running desktop app can call the same tools.
No, and it's explicitly forbidden from doing so. Every change goes through the running editor's command layer, so it's live, undoable, and autosaved like any other edit.
It renders real frames from the export pipeline and looks at them, and it runs an eight-rule layout linter against your target platform. Outstanding errors block it from marking a plan complete.
[Launching July 22, 2026]
Your next reel is one prompt away
Get early access before July 22, 2026 — no card, no watermark. The moment it lands, ReelMy cuts the first pass while you grab coffee, then you take the timeline as far as you want.