WebMCPv4.0.518

Remotion Studio exposes WebMCP tools that allow an AI agent to inspect and steer it.

Capabilities

Agents can:

See which items you currently have selected
See selectable items and select them
Duplicate sequences and inspect pending edits
See available compositions and navigate to them
Inspect render jobs, cancel queued or running renders, and reopen saved render settings
Read the error currently shown in the Studio error overlay
Get the current HTML of your composition
See current outlines of elements and their geometry
Get your current playhead position and playback state
Play, pause and seek
Set timeline zoom, playback rate, looping, volume and mute state
See, add and remove guides
Install packages into the current project
Transcribe audio and video assets
Remove the background from video assets
Restart or shut down the Studio server

Requirements

Start the Remotion Studio and open it in a browser with an AI agent that supports WebMCP.

Compatible agents

Out of the major harnesses, only ChatGPT Codex supports WebMCP. We hope more agents add support soon.

Available tools

note

The shape of inputs and outputs is not currently stable.

Tools that edit sequences or guides require a composition to be open. Playback tools work with compositions and, from v4.0.540, ready audio and video asset and rendered-output previews. This includes local browser-rendered outputs. Images, image-sequence directories and text files are not supported by playback tools.

Playback tools run locally in all four Studio modes: regular, detached, read-only deployed and Browser Studio. They require a ready preview, not an attached Studio server. Rendered outputs use their native audio/video controls and keep their own volume, mute, rate and loop settings. They have no timeline zoom and do not support reverse playback.

`install_package`v4.0.523

Installs an npm package into the current Remotion project. Remotion packages use the current Remotion version. Auxiliary packages such as @huggingface/transformers use Remotion's recommended version.

Input
{
  packageName: string;
  version?: string;
}

version must be an exact semantic version when specified.

Output
{
  installed: true;
  packageName: string;
}

`transcribe_asset`v4.0.523

Transcribes an audio or video asset from the public/ folder and adds the work to the Jobs queue. The output is a JSON file containing a Caption[] array.

If assetPath is omitted, the asset currently open in the Studio is used.

Input
{
  assetPath?: string;
  outputPath?: string;
  model?: string;
  language?: string;
  task?: 'transcribe' | 'translate';
  chunkLengthInSeconds?: number;
  strideLengthInSeconds?: number;
  forceFullSequences?: boolean;
  doSample?: boolean;
  temperature?: number;
  topK?: number;
  repetitionPenalty?: number;
  noRepeatNgramSize?: number;
}

The default model is small.en. The default output is <asset>-captions.json. See transcribe() for the Whisper options and their defaults.

Output
{
  success: true;
  jobId: string;
  outputPath: string;
}

The job continues in the background and can be followed in the Jobs panel.

This tool is always exposed. If @remotion/whisper-webgpu is not installed, it returns:

Missing package output
{
  success: false;
  error: string;
  installPackage: {
    tool: 'install_package';
    packageName: '@remotion/whisper-webgpu';
  }
}

Call install_package with the returned package name and retry. Studio also installs the recommended @huggingface/transformers version.

`remove_video_background`v4.0.523

Removes a video asset's background and saves a transparent WebM file in the public/ folder. The work is added to the Jobs queue.

If assetPath is omitted, the video asset currently open in the Studio is used.

Input
{
  assetPath?: string;
  outputPath?: string;
  model?: string;
  audio?: 'keep' | 'none';
  videoBitrate?:
    | 'very-low'
    | 'low'
    | 'medium'
    | 'high'
    | 'very-high'
    | number;
}

The default model is ben2-base, the input audio is kept, and video quality defaults to very-high. The output name defaults to <asset>-no-background.webm.

Output
{
  success: true;
  jobId: string;
  outputPath: string;
}

The job continues in the background and can be followed in the Jobs panel.

This tool is always exposed. If @remotion/video-matting is not installed, it returns:

Missing package output
{
  success: false;
  error: string;
  installPackage: {
    tool: 'install_package';
    packageName: '@remotion/video-matting';
  }
}

Call install_package with the returned package name and retry. Studio also installs the recommended @huggingface/transformers version.

`restart_studio`v4.0.521

Restarts the Studio server using restartStudio(). Requires a writable Studio with a running server. No composition needs to be open. The browser temporarily disconnects and reconnects when Studio is ready.

Input
{
}

Output
{
}

The output acknowledges the restart request; it does not wait for the restarted server to be ready.

`shut_down_studio`v4.0.521

Gracefully shuts down the Studio server using shutDownStudio(). Requires a writable Studio with a running server. No composition needs to be open. Start Studio again from the terminal to reconnect.

Input
{
}

Output
{
}

The output acknowledges the shutdown request; the connection closes as Studio shuts down.

`get_render_jobs`v4.0.540

Returns the server and browser render jobs shown in Studio, including pending cancellation and availability of saved render settings. Transcription and background removal jobs are excluded. Available in all Studio modes; no composition needs to be open.

Input
{}

Output
{
  jobs: Array<{
    id: string;
    type: 'still' | 'sequence' | 'video' | 'client-still' | 'client-video';
    compositionId: string;
    outputName: string;
    status: 'idle' | 'running' | 'saving' | 'done' | 'failed' | 'cancelled';
    cancelling: boolean;
    canCancel: boolean;
    canRetry: boolean;
    retryUnavailableReason: string | null;
    progress: number | null;
    error: string | null;
  }>;
}

`jobs`

The jobs currently known to this Studio tab. Server job updates require an attached Studio server; a disconnected tab may retain the last received state. Browser render jobs run locally in the tab.

`id`

The identifier to pass as jobId to cancel_render_job.

`type`

still, sequence and video identify server renders. client-still and client-video identify browser renders.

`compositionId`

The ID of the composition being rendered.

`outputName`

The selected output filename or image-sequence directory. A job listed here has not necessarily produced its output yet.

`status`

idle means queued, running means rendering, and saving means a browser render is saving its output. done, failed and cancelled are terminal outcomes. An intentional cancellation is reported as cancelled, without an error message.

`cancelling`

Whether a cancellation request started in this Studio tab is pending. The job may still report running while cancellation is in progress.

`canCancel`

Whether the shared Studio cancellation action is currently available for this job. This is false while cancellation is pending or the job is no longer cancellable. Server renders require a connected Studio server; queued or running browser renders can be cancelled locally in all Studio modes.

`canRetry`

Whether open_render_job_settings can reopen this job’s saved settings. Requires a terminal job, its registered composition and the original rendering settings. Server jobs also require a connected interactive Studio.

`retryUnavailableReason`

The reason saved settings cannot currently be reopened, or null when canRetry is true.

`progress`

The current render progress from 0 to 1. Queued jobs report 0 and completed jobs report 1. null means no progress value is available, including failed, cancelled and browser-saving jobs.

`error`

The failure message for a failed job, otherwise null.

`open_render_job_settings`v4.0.540

Opens the same prefilled render dialog as Studio's Retry control for a completed, failed or cancelled job. It restores the job's output name, render type and saved rendering settings. Opening the dialog does not enqueue or start a render; rendering starts only when you submit it. The render uses the current composition code.

If this job's dialog is already open, its unsaved changes are preserved. Opening a different job replaces the dialog with that job's saved settings.

Server render settings require a connected interactive Studio. Browser render settings can reopen locally in all four Studio modes. The composition must still be registered, and the original settings must be available. Browser renders restored after a page reload only retain output information, so their settings cannot be reopened. Read canRetry and retryUnavailableReason from get_render_jobs before calling this tool.

Input
{
  jobId: string;
}

`jobId`

Required. A non-empty job identifier returned by get_render_jobs.

Output
{jobId: string} & (
  | {status: 'opened'; renderMode: 'server' | 'browser'; outputName: string}
  | {status: 'not-found' | 'not-retryable' | 'unavailable' | 'error'; reason: string}
)

`status`

opened means the prefilled settings dialog opened. No render was started.

not-found means the job is no longer in the queue. not-retryable means it is still queued, running or saving. unavailable means the Studio mode, missing composition or unavailable original settings prevent reopening the dialog. These results leave the current dialog unchanged.

error means preparing the saved settings failed. Invalid input rejects the tool call before opening a dialog.

`renderMode`

The opened dialog's rendering mode, present when status is opened.

`outputName`

The job's original output filename or image-sequence directory, present when status is opened. This identifies the saved job; an already-open dialog may contain an edited output name.

`reason`

The reason the dialog could not be opened, present for every result except opened. Studio shows the same message when its Retry action cannot proceed. Environment variables and input props are not included in the tool output.

`cancel_render_job`v4.0.540

Requests cancellation using the same action as Studio's Cancel render control. Pending cancellation appears immediately in get_render_jobs, and repeated requests do not start another cancellation. A failed request clears its pending state and shows the same error notification as the UI.

Server render cancellation requires a connected interactive Studio. It is unavailable when the server is detached or in a read-only deployed Studio or Browser Studio. Queued or running browser render jobs can be cancelled locally in all four modes. Queued jobs are cancelled without starting their render. No composition needs to be open.

Input
{
  jobId: string;
}

`jobId`

Required. A non-empty job identifier returned by get_render_jobs.

Output
{jobId: string} & (
  | {status: 'requested' | 'already-pending' | 'not-cancellable' | 'not-found'}
  | {status: 'error'; reason: string}
)

`status`

requested means the cancellation request was accepted. Read get_render_jobs to observe the terminal outcome; a render that finished before cancellation can still report done.

already-pending means a request for this job is already in progress. not-cancellable means the job's state or Studio mode does not allow cancellation. not-found means the job is no longer in the render queue. None of these results starts another request.

error means the request failed. Invalid input rejects the tool call before cancellation starts.

`reason`

The failure message, present when status is error.

`get_current_error`v4.0.520

Returns the error currently shown in the Studio error overlay. It waits for source map symbolication and includes symbolicated stack frames when available, while preserving the raw stack as a fallback. Returns null when the error overlay is not visible.

Input
{
}

Output
type ScriptLine = {
  lineNumber: number;
  content: string;
  highlight: boolean;
};

type SymbolicatedStackFrame = {
  originalFunctionName: string | null;
  originalFileName: string | null;
  originalLineNumber: number | null;
  originalColumnNumber: number | null;
  originalScriptCode: ScriptLine[] | null;
};

null | {
  name: string;
  message: string;
  stack: string | null;
  symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
}

`get_compositions`

Returns the mounted compositions in the same nested folder hierarchy shown in the Studio sidebar.

Input
{
}

Output
type CompositionTreeItem =
  | {
      type: 'composition';
      compositionName: string;
    }
  | {
      type: 'folder';
      folderName: string;
      children: CompositionTreeItem[];
    };

{
  compositions: CompositionTreeItem[];
}

`select_composition`

Opens a registered composition by ID. From v4.0.540, the tool acknowledges after the canvas selection has committed, so a following tool targets that composition. Preview metadata and media may still be loading.

Input
{
  compositionName: string;
}

Output
{
  currentContent: {
    type: 'composition';
    compositionId: string;
  }
}

`get_sequences`

Returns the timeline sequences mounted for the current composition, including their hierarchy, timing, effects, source stack and selection support.

Input
{
}

Output
{
  currentContent: CurrentContent | null;
  pendingTimingEdits: Array<{
    id: number;
    operation: 'move' | 'trim-start' | 'trim-end' | 'slip-source';
    nodes: Array<{
      absolutePath: string;
      nodePath: Array<string | number>;
    }>;
  }>;
  pendingDuplications: Array<{
    absolutePath: string;
    nodePath: Array<string | number>;
  }>;
  pendingSplits: Array<{
    absolutePath: string;
    nodePath: Array<string | number>;
    sourceFrame: number;
  }>;
  pendingEffectDeletions: Array<{
    absolutePath: string;
    nodePath: Array<string | number>;
    effectIndices: number[];
  }>;
  sequences: Array<{
    sequenceId: string;
    name: string | null;
    type: 'sequence' | 'audio' | 'video' | 'image';
    parentSequenceId: string | null;
    depth: number;
    startFrame: number;
    endFrame: number;
    durationInFrames: number;
    stack: string | null;
    selectable: boolean;
    duplicating: boolean;
    splitting: boolean;
    effects: Array<{
      effectIndex: number;
      type: string;
      label: string;
      canDelete: boolean;
      deleting: boolean;
    }>;
  }>;
}

`effectIndices`

The zero-based effect indices in the chain before the deletion started. These indices do not refer to the remaining effects after the preview refreshes.

`delete_effect`v4.0.540

Deletes an effect using the same action as the Studio interface. The preview updates optimistically; a failed deletion restores the effect.

Requires a composition to be open and editable effect source in a connected interactive Studio or Browser Studio. Unavailable when the preview server is detached or the Studio is deployed as read-only. Deleting an effect edits the source and affects every runtime instance of that JSX node.

Input
{
  sequenceId: string;
  effectIndex: number;
}

`sequenceId`

Required. The ID of a sequence returned by get_sequences.

`effectIndex`

Required. A non-negative integer from the sequence's current effects list in get_sequences.

Output
{sequenceId: string; effectIndex: number} & (
  | {status: 'success'}
  | {status: 'already-pending'}
  | {status: 'error'; reason: string}
)

`status`

success means the deletion was saved to source. The preview may still be refreshing.

already-pending means an effect deletion for the same source node is already in progress. No additional deletion was requested.

error means deletion failed. Invalid inputs, unavailable effect editing, and missing sequences or effects reject the tool call before deletion starts.

`reason`

The failure message, present when status is error.

`duplicate_sequence`v4.0.540

Duplicates the source JSX node for a sequence using the same action as the Studio inspector.

Studio selects the copied sequence roots once they are available in the preview. Changing the selection or switching away from the composition while duplication is pending prevents this automatic selection. If overlapping source refreshes make the copied nodes ambiguous, Studio preserves the current selection; select a copy after the preview finishes updating.

A clip directly inside a <Track>, including through anonymous fragments, is copied into a separate sibling track with its timing preserved. If an intervening element or expression prevents this, duplicate the enclosing track instead.

Requires a composition to be open and source editing to be available in a connected interactive Studio or Browser Studio. Unavailable when the preview server is detached or the Studio is deployed as read-only. Transitions and sequences whose source is unavailable cannot be duplicated.

Input
{
  sequenceId: string;
  confirmProgrammaticDuplication: boolean;
}

`sequenceId`

Required. The ID of a sequence returned by get_sequences.

`confirmProgrammaticDuplication`

Required. When one source node produces multiple runtime instances, copying it creates a copy for every instance. Set true to confirm this behavior. Set false to cancel duplication of programmatically repeated nodes. A single-instance node is duplicated with either value.

Output
{sequenceId: string} & (
  | {status: 'success'}
  | {status: 'already-pending'}
  | {status: 'cancelled'}
  | {status: 'error'; reason: string}
)

`status`

success means the source copy was saved. The preview may still be refreshing; new sequence IDs appear in get_sequences afterward.

already-pending means a duplication of this source node is already in progress. No additional copy was requested.

cancelled means no copy was requested, for example because a programmatically repeated node was not confirmed.

error means duplication failed. Invalid inputs, unavailable source editing, and missing or unsupported sequences reject the tool call before duplication starts.

`reason`

The failure message, present when status is error.

`select_sequence`

Selects and reveals a sequence using a sequenceId returned by get_sequences.

Input
{
  sequenceId: string;
}

Output
{
  currentContent: {
    type: 'composition';
    compositionId: string;
  }
  selectedSequence: {
    sequenceId: string;
    name: string | null;
    type: 'sequence' | 'audio' | 'video' | 'image';
    parentSequenceId: string | null;
    depth: number;
    startFrame: number;
    endFrame: number;
    durationInFrames: number;
    stack: string | null;
    selectable: boolean;
  }
}

`get_composition`

Returns metadata and the current frame for the open composition. All fields are null when the canvas is showing an asset or other non-composition content.

While calculateMetadata is pending, currentFrame is null and metadata fields use the registered values where available. Once it resolves, the fields report the calculated values.

Input
{
}

Output
{
  compositionName: string | null;
  stack: string | null;
  durationInFrames: number | null;
  height: number | null;
  width: number | null;
  fps: number | null;
  currentFrame: number | null;
}

`get_canvas_html`

Returns the rendered composition HTML at the current frame without the surrounding Studio interface. The returned HTML is capped at 100,000 characters. Canvas and WebGL pixels are not represented.

While composition metadata is loading, currentFrame and html are null.

Input
{
}

Output
{
  currentContent: CurrentContent | null;
  currentFrame: number | null;
  html: string | null;
  htmlLength: number | null;
  truncated: boolean;
}

`get_outlines`

Returns the measurable selectable component outlines active at the current frame. Coordinates use composition pixels and do not change with the Studio canvas zoom.

While composition metadata is loading, currentFrame is null and outlines is empty.

Input
{
}

Output
{
  currentContent: CurrentContent | null;
  currentFrame: number | null;
  outlines: Array<{
    sequenceId: string;
    parentSequenceId: string | null;
    name: string | null;
    location: {
      filename: string;
      line: number;
    } | null;
    geometry: {
      points: [{x: number; y: number}, {x: number; y: number}, {x: number; y: number}, {x: number; y: number}];
      boundingBox: {
        x: number;
        y: number;
        width: number;
        height: number;
      };
    };
  }>;
}

`get_playback_state`

Returns the current playhead, playback, audio, looping and timeline zoom state. Timeline zoom is normalized between 0 (fully zoomed out) and 1 (maximum zoom). Playback fields are null for unsupported or unready content. Audio/video assets and rendered outputs are supported from v4.0.540.

One-frame compositions report frame 0, duration 1, their configured fps, and playing: false. Seeking in a one-frame composition returns frame 0.

Input
{
}

Output
{
  currentContent: CurrentContent | null;
  currentFrame: number | null;
  playbackStartFrame: number | null;
  fps: number | null;
  durationInFrames: number | null;
  playing: boolean | null;
  muted: boolean | null;
  volume: number | null;
  playbackRate: number | null;
  looping: boolean | null;
  timelineZoom: number | null;
}

`fps`v4.0.540

The preview's frame rate, used to interpret currentFrame and seek_to_frame. Rendered video uses its own media metadata, independently of the previously selected composition. Audio outputs and rendered video without a known frame rate use a 30 fps preview clock. null when no supported preview is ready.

`durationInFrames`v4.0.540

The current preview's duration in its frame clock, or null when unavailable. A rendered video uses the length of its video track when available, with frame 0 at the first picture. While trailing audio finishes, the playhead stays on the last picture. Audio outputs and videos without track timing use the native media duration. An asset preview includes the full soundtrack, even when the audio extends past the video.

`playbackStartFrame`v4.0.540

The rendered output's remembered playback-start frame, using its fps clock. It updates when playback starts, including through native media controls, and stays unchanged while pausing or seeking. It is null before playback has started, and for compositions, assets and unready content.

To pause an output and return to this frame, call pause, then seek_to_frame with playbackStartFrame while the same output remains open.

`timelineZoom`

null for rendered outputs because their native media preview has no Studio timeline.

`currentContent`

Identifies the open canvas content. Server outputs report their path; local browser outputs report their display name, dimensions and size. Blob data and blob retrieval functions are not exposed.

`get_selection`

currentFrame follows the selected composition's playhead. Media assets and rendered outputs report their own preview frame from v4.0.541. A still image or a preview that is still loading returns 0.

Returns source-code context when exactly one supported timeline item is selected. currentSelection is null when there is no selection, multiple items are selected, a guide is selected or the source location cannot be resolved. selectedSequence identifies the owning sequence when a property, effect or keyframe is selected.

Input
{
}

Output
{
  currentFrame: number;
  currentContent: CurrentContent | null;
  currentSelection: string | null;
  selectionType:
    | 'guide'
    | 'sequence'
    | 'sequence-prop'
    | 'sequence-all-effects'
    | 'sequence-effect'
    | 'sequence-effect-prop'
    | 'keyframe'
    | 'easing'
    | null;
  selectedSequence: {
    sequenceId: string;
    name: string | null;
    type: 'sequence' | 'audio' | 'video' | 'image';
    parentSequenceId: string | null;
    depth: number;
    startFrame: number;
    endFrame: number;
    durationInFrames: number;
    stack: string | null;
    selectable: boolean;
  } | null;
}

`get_guides`

Returns guides for the current composition. Vertical positions are x-coordinates from the left edge; horizontal positions are y-coordinates from the top edge.

Input
{
}

Output
{
  currentContent: CurrentContent | null;
  guidesVisible: boolean;
  guides: Array<{
    id: string;
    orientation: 'horizontal' | 'vertical';
    position: number;
    visible: boolean;
  }>;
}

`set_guides_visible`

Shows or hides every guide in the current composition.

Input
{
  visible: boolean;
}

Output
{
  currentContent: {
    type: 'composition';
    compositionId: string;
  }
  guidesVisible: boolean;
}

`add_guide`

Adds and shows a guide in the current composition. Positions use composition pixels.

Input
{
  orientation: 'horizontal' | 'vertical';
  position: number;
}

Output
{
  currentContent: {
    type: 'composition';
    compositionId: string;
  }
  guide: {
    id: string;
    orientation: 'horizontal' | 'vertical';
    position: number;
    visible: true;
  }
}

`remove_guide`

Removes a guide using an ID returned by get_guides or add_guide.

Input
{
  guideId: string;
}

Output
{
  currentContent: {
    type: 'composition';
    compositionId: string;
  }
  guideId: string;
  removed: true;
}

`play`

Starts playback from the current frame. Composition and asset previews with only one frame cannot be played. A rendered output can play whenever its native media has a positive duration, including one-frame outputs. The tool waits for native playback to start and reports playback errors or navigation away from that output.

Input
{
}

Output
{
  currentContent: CurrentContent;
  playing: boolean;
}

`pause`

Pauses playback at the current frame.

Input
{
}

Output
{
  currentContent: CurrentContent;
  playing: false;
}

`mute`

Mutes audio playback.

Input
{
}

Output
{
  currentContent: CurrentContent;
  muted: true;
}

`unmute`

Unmutes audio playback.

Input
{
}

Output
{
  currentContent: CurrentContent;
  muted: false;
}

`set_volume`v4.0.540

Sets playback volume for the current composition or ready audio/video asset or rendered output. Available locally in all four Studio modes. This changes preview volume, not the composition's audio source properties, and does not change the muted state.

Composition and asset previews share Studio's volume. A rendered output keeps its own volume while mounted.

Input
{
  volume: number;
}

`volume`

Required. A finite number from 0 (silent) through 1 (full volume). Invalid values and unsupported or unready previews return an error before changing volume.

Output
{
  currentContent: CurrentContent;
  volume: number;
}

`set_timeline_zoom`

Sets the timeline zoom using a normalized value between 0 (fully zoomed out) and 1 (maximum zoom). The output contains the effective normalized zoom after Studio applies its supported zoom step. Still compositions and asset previews with only one frame do not have timeline zoom. Rendered-output previews reject this tool because they have no Studio timeline.

Input
{
  zoom: number;
}

zoom must be a finite number between 0 and 1, inclusive.

Output
{
  currentContent:
    | {type: 'composition'; compositionId: string}
    | {type: 'asset'; asset: string};
  timelineZoom: number;
}

`set_looping`v4.0.540

Enables or disables looping for the current composition or ready audio/video preview. For compositions and assets, it updates the Loop control immediately and saves the preference for subsequent previews. For rendered outputs with a positive duration, it changes only the mounted native media element. Returns an error if no supported preview is ready or a composition or asset preview has only one frame.

Input
{
  looping: boolean;
}

looping is required.

Output
{
  currentContent: CurrentContent;
  looping: boolean;
}

`set_playback_rate`

Sets the playback multiplier. Negative values play backwards in compositions and asset previews. Rendered outputs accept only positive rates and retain their own playback rate; a negative rate returns an error without changing playback preferences.

Input
{
  playbackRate:
    | -4
    | -2
    | -1
    | -0.5
    | -0.25
    | 0.25
    | 0.5
    | 1
    | 1.5
    | 2
    | 4;
}

Output
{
  currentContent: CurrentContent;
  playbackRate: number;
}

`seek_to_frame`

Seeks to a zero-based frame. Values beyond the duration are clamped to the final frame. Read fps and durationInFrames from get_playback_state to interpret rendered-output frames. A seek updates the native media element used by the preview controls.

Input
{
  frame: number;
}

frame must be a non-negative integer.

Output
{
  currentContent: CurrentContent;
  currentFrame: number;
}

Example prompts

You can ask a browser agent:

"What is currently selected in the Studio?"
"Fix the error"
"List all mounted compositions and their folders."
"Open the Shapes composition."
"List the sequences and select the Title sequence."
"Duplicate the Title sequence."
"Inspect the HTML rendered on the canvas."
"List the visible components and their canvas geometry."
"What is the current playback state?"
"Set the timeline zoom to 0.5."
"Seek to frame 90, set the playback rate to 0.5x and play."
"List the guides in the current composition."
"Hide the guides."
"Add a vertical guide at 640 pixels."
"Mute the preview."
"Turn off looping for the audio asset preview."
"Transcribe the audio asset that is currently open."
"Remove the background from product-shot.mp4."

The agent chooses and invokes the matching tools. Tool calls affect the open Studio tab immediately.

Browser support

WebMCP is a draft web platform API. Refer to the WebMCP specification and Chrome's WebMCP documentation for current browser and agent support.

Capabilities​

Requirements​

Compatible agents​

Available tools​

install_packagev4.0.523​

transcribe_assetv4.0.523​

remove_video_backgroundv4.0.523​

restart_studiov4.0.521​

shut_down_studiov4.0.521​

get_render_jobsv4.0.540​

jobs​

id​

type​

compositionId​

outputName​

status​

cancelling​

canCancel​

canRetry​

retryUnavailableReason​

progress​

error​

open_render_job_settingsv4.0.540​

jobId​

status​

renderMode​

outputName​

reason​

cancel_render_jobv4.0.540​

jobId​

status​

reason​

get_current_errorv4.0.520​

get_compositions​

select_composition​

get_sequences​

pendingTimingEditsv4.0.540​

id​

operation​

nodes​

absolutePath​

nodePath​

sequences[].duplicatingv4.0.540​

pendingDuplicationsv4.0.540​

absolutePath​

nodePath​

sequences[].splittingv4.0.540​

pendingSplitsv4.0.540​

absolutePath​

nodePath​

sourceFrame​

sequences[].effectsv4.0.540​

effectIndex​

type​

label​

canDelete​

deleting​

pendingEffectDeletionsv4.0.540​

absolutePath​

nodePath​

effectIndices​

delete_effectv4.0.540​

sequenceId​

effectIndex​

status​

reason​

duplicate_sequencev4.0.540​

sequenceId​

confirmProgrammaticDuplication​

status​

reason​

select_sequence​

get_composition​

get_canvas_html​

get_outlines​

get_playback_state​

fpsv4.0.540​

durationInFramesv4.0.540​

playbackStartFramev4.0.540​

timelineZoom​

Capabilities

Requirements

Compatible agents

Available tools

`install_package`v4.0.523

`transcribe_asset`v4.0.523

`remove_video_background`v4.0.523

`restart_studio`v4.0.521

`shut_down_studio`v4.0.521

`get_render_jobs`v4.0.540

`jobs`

`id`

`type`

`compositionId`

`outputName`

`status`

`cancelling`

`canCancel`

`canRetry`

`retryUnavailableReason`

`progress`

`error`

`open_render_job_settings`v4.0.540

`jobId`

`status`

`renderMode`

`outputName`

`reason`

`cancel_render_job`v4.0.540

`jobId`

`status`

`reason`

`get_current_error`v4.0.520

`get_compositions`

`select_composition`

`get_sequences`

`pendingTimingEdits`v4.0.540

`id`

`operation`

`nodes`

`absolutePath`

`nodePath`

`sequences[].duplicating`v4.0.540

`pendingDuplications`v4.0.540

`absolutePath`

`nodePath`

`sequences[].splitting`v4.0.540

`pendingSplits`v4.0.540

`absolutePath`

`nodePath`

`sourceFrame`

`sequences[].effects`v4.0.540

`effectIndex`

`type`

`label`

`canDelete`

`deleting`

`pendingEffectDeletions`v4.0.540

`absolutePath`

`nodePath`

`effectIndices`

`delete_effect`v4.0.540

`sequenceId`

`effectIndex`

`status`

`reason`

`duplicate_sequence`v4.0.540

`sequenceId`

`confirmProgrammaticDuplication`

`status`

`reason`

`select_sequence`

`get_composition`

`get_canvas_html`

`get_outlines`

`get_playback_state`

`fps`v4.0.540

`durationInFrames`v4.0.540

`playbackStartFrame`v4.0.540

`timelineZoom`