How your agent edits a take
TakeOne runs no model of its own. The agent you already use reads what was said, where you clicked and the moments worth pointing at, writes the cuts, zooms and captions, and publishes when you let it.
Connect it once
Through MCP. TakeOne’s MCP server is at https://mcp.takeone.dev/mcp, hosted on MCPCloud, which rebuilds it whenever the API changes. Open takeone.dev/connect/mcpcloud, sign in with TakeOne and approve the scopes, then add the server to Claude Code, Claude Desktop, Codex, Cursor, VS Code or any other MCP client. Your agent only ever holds a short-lived pass, and Disconnect cuts it off at its next call.
Through the API. The REST API is at https://api.takeone.dev/v1, described by an OpenAPI contract at /v1/openapi.json. Make a token with only the scopes the job needs and send it as Authorization: Bearer; revoke it whenever you like. The MCP server has one tool per API operation, named the same.
What it reads
- The transcript (
getTranscript): what was said, with times. With none yet, the agent fetches the narration’s audio (getAssets), transcribes it with its own speech-to-text tool and writes the result back (putTranscript). - The clicks (
getEvents): where the pointer moved and clicked, recorded by the Chrome extension, the Mac app or the beacon in your own app. - The keyframes (
getKeyframes): the moments worth pointing at, the trim, each zoom and each cluster of clicks. - The picture (
getAssets): the timeline strip, the whole take in 24 frames with the time of each, so an agent that reads images sees what was on screen before it decides where to cut or zoom; and frames at the moments it picks (getFrames), up to 12 at a time and as large as 1920 px. - The edit and the notes (
getEdit,getRecording): what the take looks like now, its title, description and private script. - How it is doing (
listRecordings,getRecording): how many times the share link was played, the number your share settings show. A count only: TakeOne never records who watched.
Every time is milliseconds from the start of the recording, before any trim or speed-up, so a cut lands on the right second.
What it writes
- Cuts, zooms, speed-ups, the frame and the poster's frame into the working edit (
putEdit). - The title, the public description and the private script (
patchNotes), and a folder for the take (moveRecording). - A transcript, which gives the share page captions and chapters.
A write that breaks a rule is refused with the rule’s name, such as OVERLAPPING_SPEEDUPS, so the agent can fix the edit and try again. Edits land as unpublished changes: you can check them in the editor before anyone sees them.
Asking you for a take
Some footage only you can make: your screen, your voice. createRecordingRequest takes a title, and optionally a script and a folder, and returns one link to the recorder. Open it signed in and the recorder shows the title and the script to read from; when you stop, the take carries both, lands in the folder, and take.ready names the request, so the agent carries on without asking again. The link fills in a take only for the account that made it, and lapses after a week unless the agent asks for longer (listRecordingRequests shows which are still open). The iPhone app opens the same link and names the take with its title.
Publishing
With the publish scope, publishRecording renders the working edit and puts it on the share page, the way Publish in the editor does. An open TakeOne tab of yours renders it; on Starter and Pro, when no tab is open, the render runs on our side, so an agent can publish on its own. While it renders, getRecording says how far it got, and if it fails, why. Webhooks tell an agent or your own service when a take is ready, is published, or fails to save or render (take.ready, take.published, take.failed), so the work can start the moment you stop recording.
Scopes
Give each agent only what its job needs: an agent that adds chapters never needs to publish.
read- Read recordings, notes, transcripts and the files behind them.
write:notes- Write the title, description and script, sort recordings into folders, and ask you to record.
write:edit- Write the edit: cuts, zooms, speed-ups and the frame. Never publishes.
write:transcript- Upload a transcript for a recording.
write:webhooks- Register and remove webhooks.
publish- Render the working edit and put it on the share page.
Skills
The common jobs come packaged as skills with their guardrails: each works on one take, shows the plan before writing and never publishes unless that is the job. They are listed with the TakeOne server in MCPCloud’s marketplace.
- Transcribe the narration: “Transcribe my latest take.”
- Describe a take from its transcript and keyframes.
- Draft the script, one timecoded block per keyframe.
- Zoom to the clicks, from clusters of clicks.
- Tighten the take: trim and speed up the silences.
- Publish a take and report its share link.
Limits
The API and MCP allow 100 calls a day on Free, with no publishing; 1,000 on Starter; and 2,000 on Pro. Starter includes 60 minutes a month of video an agent publishes with no tab open, and Pro 300. Your agent’s own usage stays on the plan you have with its provider.