Revid

Edit project

edit_project

Destructive

Edit an existing project in place, with the same tools as the assistant in the Revid editor. Send every change for one video in one call as edits: they run in order and save as one revision. Either all apply or none, unless a paid edit already ran. Changing words in a motion graphic: list_composition_text to read them, then replace_composition_text ({ mediaId, replacements: [{ find, replace }] }). Free, instant, nothing else in the scene moves, wherever the words live. Other free edits: update_text, set_caption_text, translate_captions (every caption line into another language in one call, the audio untouched), set_caption_style, apply_caption_preset, set_media_props, set_animation, set_transition, move_media, trim_media, split_media, remove_media, close_gap, duplicate_media, add_text_media, add_image_media, add_video_media, add_audio_media, add_music, rename_project. Paid, charged like in the editor, and needing an active plan: edit_composition (rebuild a motion graphic's design, layout or motion from a prompt: 5 credits, several minutes and up to 15 on a long scene; do it before split_media, since a rebuilt piece restarts its animation; it retypes the whole scene, so read sourceChanges when it lands, and restore_composition undoes it for free), generate_motion_graphic, generate_video (replaceMediaId redoes a clip), generate_image, edit_image, generate_voiceover, generate_music, generate_sound_effect. Long ones return a jobId: follow it with get_edit_job. At most one of generate_image, edit_image, create_ingredient, generate_title_graphic, generate_music, generate_voiceover, generate_sound_effect per call: each takes up to 90 seconds, so split a batch with more and send the parts in order. While a paid edit runs on a project, other edits to it answer 409 EDIT_IN_PROGRESS: if a call times out, wait, then call get_timeline before trying again, never resend a paid edit blind. dryRun: true returns the credit estimate of a batch and saves nothing. describe_edit_tools gives every tool and its schema; an invalid call answers with the schema too. Check the result with view_frames. It does not change any mp4 already exported: call export_video when the edit is right.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "pid": "<pid>",
      "edits": "<edits>"
    },
    "name": "edit_project"
  }
}

Input Schema

Name	Required	Description
`pid`	Yes	Revid project id.
`edits`	Yes	The changes, in order.
`dryRun`	No	Validate and price the batch without saving or charging.
`baseRevision`	No	The editRevision you read from get_timeline. If the project changed since, the call is refused and nothing is overwritten.

Output Schema

Name	Required	Description	Default
`ok`	Yes
`data`	No
`error`	No
`method`	Yes
`status`	Yes
`endpoint`	Yes
`retryAfterSeconds`	No

Schema Changelog

Changes observed during successful MCP inspections.

First observedNov 5, 2026

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already flag destructive, non-idempotent, and open-world behavior, so the bar is lower. The description still adds real value beyond them: all-or-nothing batch semantics with the partial-charge caveat, credit costs and runtimes, the 409 EDIT_IN_PROGRESS concurrency rule, dryRun pricing, and the fact that already-exported mp4s are untouched.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The core semantics are front-loaded well (batch, ordering, atomicity), but the middle degrades into a long comma-separated inventory of roughly twenty sub-tool names, which is dense and hard to parse as prose. Much of that enumeration is routing-relevant, yet it inflates length at the cost of readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a batch-mutation tool with 25-item arrays, a nested tool router, and paid side effects, the description covers cost, timing, ordering hazards, concurrency, verification, and export follow-up. An output schema exists, and the description still names jobId and get_edit_job so the agent knows how to handle async results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and all four parameters are documented there, so baseline 3 applies. The description reinforces that all changes for one video should go in one call and that edits execute in order, but it adds no new syntax or format detail for baseRevision or dryRun beyond the schema text.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("Edit an existing project in place") and immediately clarifies the mechanism: a batch of named sub-tool edits run in order and saved as one revision. It is unmistakable against siblings like get_timeline, rename_project, or describe_edit_tools, which it explicitly routes to.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit routing rules: which edits are free vs paid, that paid ones need an active plan, that edit_composition must precede split_media, that at most one of a named set may appear per call with batch-splitting advice, and that describe_edit_tools reveals every schema. It also prescribes recovery (wait, then get_timeline on 409/timeout) and the follow-up step (view_frames, then export_video).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All Revid tools Inspect

Try in Browser

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources

Need Help?