An AI clipping agent is a language model with a brief, a set of video tools it can call, and a loop that keeps going until the brief is met. This page opens one up: the four parts every agent has, what one tool call actually looks like, the five levels of autonomy, the three ways people deploy them, the ways they fail, and what a run costs. If you want the short definition first, read what is an AI clipping agent; if you want a ranking, see best AI clipping agents.
Strip the branding off any clipping agent, hosted or home-built, and this is what's left.
A language model (Claude, GPT, Gemini, or a local model) that reads the brief, decides which tool to call next with which arguments, reads the result, and decides again. It never touches video; it reasons about descriptions of video: transcripts, scores, timestamps, URLs.
Typed functions the brain can call: find moments, cut a clip, reframe, caption, dub, publish, check quota. Exposed through an MCP server or an API. Each tool has a name, a description and a JSON schema for its inputs, which is how the brain knows what it can do.
The brief, the conversation so far, tool results, and (in good agents) what you approved and rejected last time. Short-term memory is the context window; long-term memory is a file or database the agent reads at the start of each run.
The rules that stop a loop doing damage: approve-before-publish, a credit or dollar cap per run, a maximum number of steps, forbidden actions (no deletes, no posting without a confirmation link), and a human checkpoint on anything irreversible.
Brief: "Clip the best three moments from this episode for TikTok, reframed vertical, with captions, and queue them for my approval."
On connecting, the client asks the MCP server for its tools. The brain now knows there's a find_moments that takes a video URL and a count, a cut_clip that takes start and end, a render that takes a clip ID and an aspect ratio. No code was written for this; the schemas are the instructions.
The brain writes itself a plan: call find_moments with count 6 (over-fetch, then choose), inspect the scores and transcripts, pick three that stand alone, cut each with padding, render 9:16 with captions, then stop and ask. Good agents state the plan; it's your first chance to redirect.
The brain emits a structured call: tool name plus arguments that match the schema. The server validates it (wrong types or missing fields are rejected before any video is touched), runs the job, and streams progress. Long jobs return a job ID the agent polls, or a webhook fires when done.
Back comes JSON, not a chat message: six candidates with start, end, score, transcript and a reason. The brain reads them the way it reads any text and can reason: "candidate 4 starts mid-sentence; candidate 2 and 5 cover the same story; keep 1, 2, 3."
After cutting, the agent checks its own output (a contact sheet, the clip's transcript) against the brief. Clip 2 cuts a word off at the end: widen the out-point by a second and re-render. This is the difference between an agent and a script: it notices and tries again, within its step budget.
The brief said "for my approval", so the agent stops with three clips, their hooks and a one-line reason each. Publishing is irreversible, so it's behind a human yes. Approve, reject or edit; the good agents remember which, and pick differently next week.
MCP is JSON-RPC. The brain produces the call; the client sends it; the server answers with content the brain can read. The tool and field names here are illustrative but match the shape of real servers such as Katto's (16 tools) and OpusClip's (26).
tools/call with the tool name and arguments matching its schema.isError flag. The brain reads it and decides the next call.get_job or waits for a webhook.More on servers, transports and setup: AI clipping MCP servers.
// agent → server
{
"jsonrpc": "2.0", "id": 7,
"method": "tools/call",
"params": {
"name": "find_moments",
"arguments": {
"video_url": "https://youtube.com/watch?v=…",
"count": 6,
"min_s": 25, "max_s": 60,
"brief": "hooks about pricing, for founders"
}
}
}
// server → agent
{
"jsonrpc": "2.0", "id": 7,
"result": {
"content": [{ "type": "text", "text":
"[{\"start\":2462,\"end\":2501,\"score\":91,
\"reason\":\"strong claim, self-contained\",
\"transcript\":\"The pricing mistake every…\"}, …]"
}],
"isError": false
}
}"Agent" covers a wide range. Knowing the level tells you what you're trusting it with.
You upload, it returns candidates, you do everything else. Every AI clipper is at least this. OpusClip, Klap, Vizard in the browser.
You chat with an assistant that calls the tool for you: "clip this link, pick three". One brief, one run, you review. Claude + Katto MCP; ChatGPT + ClipTalk.
Multi-step with self-correction, stops at checkpoints. It plans, finds, cuts, checks, re-cuts, then asks before publishing. Claude Code + an MCP server with approve-before-post. Where most people should be.
Runs on a trigger (new upload, a daily cron) without being asked, queues output for approval. OpusClip Auto Import; a scheduled task that calls katto_create_clip_job on each new VOD.
Publishes without a human in the loop, within caps. Only sensible once weeks of L3 approvals show the picks are reliable and the brand rules are encoded. Vizard Auto Schedule above a virality threshold; StreamClipping AutoPilot (with email-before-post).
The clipper ships its own agent features: Auto Import, Auto Schedule, AutoPilot, Agent Opus. Zero setup, vendor's model, vendor's guardrails. You configure thresholds and caps; you can't change the loop.
Claude, Cursor or ChatGPT as the brain; a clipper's MCP server as the hands. You write the brief in chat, the assistant runs the loop, you approve. Flexible, cheap to start, and the guardrails are yours to write.
A script or agent runtime on a cron: poll a channel, create jobs through an API, wait on webhooks, filter by score, drop results in a review folder or a scheduler. Most control, most maintenance.
Each one has a guardrail. Build the guardrail before the first unsupervised run.
Retries that each cost credits. Guardrail: an estimate-first rule (estimate_cost, dry-run tools) and a per-run cap.
"Not good enough, try again" with no exit. Guardrail: a maximum step count and a "stop and ask" after N retries.
Irreversible actions taken on a misread brief. Guardrail: approve-before-post, or a vendor confirmation link (OpusClip's MCP requires one).
Context fills with tool output; the brief drifts. Guardrail: summarise results, keep the brief pinned, one episode per run.
Checkpoints that confirm themselves on a timer (Agent Opus after five idle minutes). Guardrail: turn timers off for claims, licensed assets, regulated content.
Posts by virality score alone; the score ranks, it doesn't forecast. Guardrail: feed real view data back and raise the threshold from evidence.
Two meters run at once: the brain's tokens and the tool's credits. Worked example: one 90-minute podcast, six candidates, three clips rendered and dubbed.
A supervised run is a few dozen tool calls and maybe 50–150K tokens including tool output. Cheap on hosted assistants (often inside a subscription); near zero with a local model.
Depends entirely on billing unit: 90 credits on OpusClip or Vizard (≈ $4–9 at plan rates); one video on Katto (≈ €0.49–0.89); one project on ClipForge; about $8.44 on Klap's API; $0 on self-hosted SupoClip.
Writing the brief and approving three clips, versus 45–60 minutes doing it by hand. Multiply by episodes per month to see whether the agent is worth setting up.
The tool cost dominates, so pick the billing unit for your sources before picking the brain. Model it against campaign payouts in the earnings calculator.
Buy (Pattern A) if one channel feeds one brand and the vendor's loop fits: OpusClip Auto Import plus the scheduler covers "clip every episode and queue it" with nothing to maintain.
Build (Pattern B) if you run several brands or clients, want a custom brief per run, need to combine tools (one for picks, one for captions, one for posting), or want the loop in your own assistant where you already work. Katto's free tier plus Claude Code is a working L2 agent for €0.
Both is common: a bought clipper for the picking engine, your own loop around it for the brief, the checks and the approvals.
No. The brain reads text about the video: transcripts, timestamps, scores, reasons, and sometimes a contact sheet image. The clipping tool does the watching. That's why the video never enters the model's context and why tool quality matters as much as model quality.
Any model that handles tool calling reliably. Hosted assistants (Claude, ChatGPT, Cursor's models) are the easy path; a local model via Ollama works for privacy with SupoClip. The brain mostly reads JSON and makes choices, so it doesn't need to be the largest model available.
MCP when a general assistant drives the loop and you want tools discovered automatically. API when you're writing a pipeline in code. Many clippers offer both; Katto and OpusClip do, SupoClip does self-hosted.
It can find, cut, caption and queue. Posting on your account, adding the campaign hashtag and #ad, and submitting the link are the parts to keep human until you've encoded every rule, because one miss voids the clip. See clipping campaigns.
A tool does one task when you ask. An agent holds the plan, chains tasks, checks its own work and keeps going until the brief is met or a checkpoint stops it. Every agent uses tools; most tools aren't agents. See best AI clipping tools for the tools and best AI clipping agents for the agents.