Connect an AI assistant with Sequence MCP

Requirements

MCP lets a compatible AI assistant inspect projects, create or refine cuts, open variants, and start exports through Sequence's local CLI server. It is a connection to the app on your Mac, not a cloud account integration.

Install the current CLI and use the app described in the CLI compatibility section. Keep Sequence open, signed in, activated, and unlocked, with the main workspace available. Turn on Settings → Automation → Enable Automation.

Available tools depend on the app and CLI you have installed. The tool names and settings below describe the implemented contract, not a promise that an older downloaded app exposes every tool. If a tool is absent from your host's list, check both components before relying on that workflow.

Install and connect

Manual, host-managed setup is a normal way to connect Sequence MCP, including with the Mac App Store app, Cursor, OpenCode, T3 Code, and terminal/TUI assistants that support local MCP servers. You do not need Sequence's plugin installer.

1. Keep Sequence open, signed in, activated, and unlocked, with the main workspace available. Enable Settings → Automation → Enable Automation.

2. Install the CLI and connect it to the app by running this in Terminal:

   brew install rockstarsunlimited/sequence/sequence && sq app connect
   

   If the CLI is already installed, run brew update, brew upgrade sequence, then sq app connect. Use sq --version and sq app doctor to check the installation.

3. Wait for the CLI status in Sequence to show Connected.

4. Find the CLI's absolute executable path:

   command -v sq
   

   Use that full path in your assistant's configuration. The examples below use /opt/homebrew/bin/sq; replace it if your result differs.

Manual local MCP setup

Configure your assistant to launch sq mcp serve as a local stdio server on the same Mac as Sequence. The host starts and manages the server process; you do not need to leave a separate sq mcp serve running in Terminal. There is no server URL or API key to enter.

Merge the appropriate entry into your host's existing configuration rather than replacing other servers or settings. Restart or reconnect the host's MCP connection after saving.

Cursor

Add this to ~/.cursor/mcp.json for all projects, or .cursor/mcp.json in a project for that project only:

{
  "mcpServers": {
    "sequence": {
      "type": "stdio",
      "command": "/opt/homebrew/bin/sq",
      "args": ["mcp", "serve"]
    }
  }
}

Cursor uses a mcpServers object with a server name, type: "stdio", an executable command string, and a separate args array. See the official Cursor MCP documentation for configuration locations and current host behavior.

OpenCode

Add this to ~/.config/opencode/opencode.json for user-wide setup, or opencode.json in your project:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sequence": {
      "type": "local",
      "command": ["/opt/homebrew/bin/sq", "mcp", "serve"],
      "enabled": true
    }
  }
}

OpenCode uses an mcp object, type: "local", and a single command array containing both the executable and its arguments, rather than Cursor's separate command and args fields. This is MCP server configuration for OpenCode, including its TUI; it does not belong in tui.json. See the official OpenCode local MCP documentation and configuration locations.

Codex, including T3 Code

T3 Code runs through your chosen agent provider. Configure Sequence MCP for that provider, rather than looking for a Sequence-specific T3 Code installer.

For a Codex-backed T3 Code session:

The commands below run in Terminal and require the Codex CLI on your PATH. T3 Code's managed Codex runtime does not provide a Terminal codex executable. If command -v codex does not return a path, install the Codex CLI and run codex login before continuing.

1. In T3 Code's Settings → Providers, select the Codex provider on the same Mac where Sequence and sq are running.

2. In Terminal on that Mac, add the local server to Codex:

   codex mcp add sequence -- /opt/homebrew/bin/sq mcp serve
   codex mcp list
   

   Replace /opt/homebrew/bin/sq with the result of command -v sq. If your T3 Code provider uses a custom CODEX_HOME, run the commands with that same home so they update the configuration used by that provider.

3. Restart the provider session or start a new thread in T3 Code, then check that the Sequence tools are available before requesting edits.

Codex stores the server in its config.toml; this is not a T3 Code JSON configuration. Other T3 Code providers use their own MCP setup and may expose different capabilities. See T3 Code provider setup, its Codex configuration guide, and the official Codex MCP instructions.

The agent provider and MCP process must run on the Mac with Sequence. Connecting T3 Code's GUI to an agent on a remote Linux machine does not give that agent access to the app's local connection.

Other terminal or TUI hosts

If your host supports local MCP servers, use its documented configuration format or server-add command with these values:

If the host asks for a single command line instead, use /opt/homebrew/bin/sq mcp serve, replacing the executable path with yours and quoting it if it contains spaces. Host configuration formats differ; do not assume every host accepts the Cursor or OpenCode JSON above. A host that only accepts a remote server URL cannot use this local stdio connection.

Optional assistant installers

Sequence's assistant setup buttons are optional shortcuts, only in distributions that provide them. After the CLI connects, non–Mac App Store builds offer Settings → Automation → Model Context Protocol → Connect Your Agent:

• ChatGPT: Sequence writes a local plugin. Restart ChatGPT to finish. If Sequence asks for folder access, select your account's home folder.
• Claude: Sequence opens an .mcpb extension installer. Confirm the installation in Claude.

The Mac App Store app does not provide a plugin installer. Its Download Installer button opens this guide; it does not install an integration. Use the manual host-managed setup above with a compatible local MCP host. Neither route signs you into an assistant or links your Sequence account to it.

What you can ask

For example:

Find my Launch Talk project, preview a two-minute cut, then create a new variant called Social Cut and open it in Sequence for me to review.

The assistant should resolve the source, preview if requested, and begin an explicit edit session before applying changes. Begin-edit makes the copy by default; auto-clip does not make another copy. Review the result in Sequence before exporting.

Safe edit workflow

These are MCP tool-call payloads, not shell commands. Replace the placeholder IDs with real values returned by Sequence.

1. Find the source with sequence_find_project:

   { "name": "sequence_find_project", "arguments": { "query": "Launch Talk", "limit": 20 } }
   

   Use projectId instead of query for an exact UUID lookup. If several projects match, choose the intended one before continuing.

2. Optionally preview a rough cut without an edit session or any saved changes:

   {
     "name": "sequence_auto_clip",
     "arguments": { "variantId": "<source-variant-id>", "durationSeconds": 120, "preview": true }
   }
   

3. Begin the edit and name the copy:

   {
     "name": "sequence_begin_edit",
     "arguments": { "projectId": "<source-variant-id>", "name": "Social Cut" }
   }
   

   A root project ID selects the currently active tab only if it belongs to that project's family; it does not silently select the first variant. Select the intended family tab in Sequence, or pass the exact child variant ID. An explicitly named child or group-owned Multi-Cam program is copied unless you opt into editing it in place with editExisting: true. That option cannot authorize an in-place edit from a root ID. Without name, the copy is named <source name> Copy, with a numeric suffix if needed.

   Keep the returned editSessionId and variantId: they identify the session and its editable target. Begin-edit also opens the target. If the result includes openError, keep those IDs and retry sequence_open with {"projectId":"<returned-variant-id>"} rather than beginning again.

4. Apply changes to the returned variant, with the returned session ID on every editorial write:

   {
     "name": "sequence_auto_clip",
     "arguments": {
       "variantId": "<returned-variant-id>",
       "editSessionId": "<returned-session-id>",
       "durationSeconds": 120
     }
   }
   

   Auto-clip disables likely retakes, reorders remaining sentences in source order, and adds clips. It does not remove silence or filler words. Use sequence_remove_silence or sequence_remove_filler separately, with the same variantId and editSessionId. Silence removal optionally accepts thresholdSeconds from 0.5 to 20; omitting it uses the saved threshold, or 2 seconds if unset. Omitting durationSeconds keeps the full useful runtime. A duration target counts spoken sentence time, not final exported runtime, and a whole final sentence can exceed it. Auto-clip also accepts exportPath for an FCPXML export after applying the cut.

5. End the session after editing:

   { "name": "sequence_end_edit", "arguments": { "editSessionId": "<returned-session-id>" } }
   

   Ending does not delete or undo the saved variant. Only one session can be active per MCP connection. Repeating begin-edit for the same source and options reuses the session without creating another copy; end it explicitly before starting a different edit or a fresh copy. Session IDs do not survive reconnecting the MCP server.

Available tools

The CLI tool accepts the exact arguments that follow sq, without a shell command string:

{
  "name": "sequence_cli",
  "arguments": { "arguments": ["app", "projects", "find", "Launch Talk", "--json"] }
}

Editorial writes through sequence_cli also require editSessionId and must target the returned variantId. --confirm is accepted through this tool only with a valid session ID. See the CLI guide for supported commands and edit previews.

The generic tool is not an escape hatch around edit sessions. Use sequence_begin_edit to create the target copy; variants create, variants create-from-plan, and auto-clip with --copy are rejected through MCP because they would make another variant outside the session. Actions that change root-owned stream roles or apply package presets to multiple projects are also not session-scoped editorial commands. A command being available in Terminal does not guarantee that an assistant may run it through this tool.

Dedicated tools supply confirmation for their actions, but your host's tool approval settings still determine when it asks permission. Enabling MCP is not a preview-only mode.

Hosts advertising the MCP Apps UI extension can show a read-only Sequence result card with status, a summary, available metrics, and project IDs. It is not an edit preview or an export-progress monitor. Hosts without that UI support receive text and structured tool results.

Export tools

The dedicated tools below select the export destination by name. The general sequence_export tool accepts only projectId, outputPath, and optional destination (final-cut-pro or resolve, defaulting to Final Cut Pro). It does not accept the dedicated tools' export settings, catalogId, or editSessionId.

For each dedicated tool, pass a project UUID as projectId; optionally pass catalogId to check it belongs to the expected catalog. To export your edit, use the variantId returned by begin-edit as projectId. Exports do not require an edit session and do not accept editSessionId or a destination field: the tool name selects the destination. Except for sequence_add_to_assets, they require an absolute outputPath with the extension in the table and no .. path segments. Its parent folder must already exist and be writable and accessible to Sequence. Existing output files and companion files are never overwritten.

For NLE exports, includeCaptions and includeKeywords default to true; captionStyle is regularTitles (the default) or fcpSubtitles. Use regularTitles for Resolve; Final Cut's Subtitle template requires Final Cut Pro 12.3 or later. resolution and frameRate default to source. removeSilentChannels defaults to false, and convertMP3ToM4A defaults to true. Caption formatting can be set explicitly with captionSplitMode (words or sentences), sentenceLimitMode (auto, words or duration), maxCharactersPerLine (8–120), wordsPerCaption (1–30), maxWordsPerSentence (2–100), and maxDurationSeconds (1–30). Defaults are sentence splitting, automatic limits, 42 characters, 5 words per caption, 10 words per sentence and 3 seconds. NLE titles are capped at five words per title, with a warning if a larger setting is reduced. These defaults do not inherit the inspector's saved preferences. Missing transcript data disables transcript-derived titles without preventing a media-only timeline export.

For package exports, includeSourceMedia defaults to true; omitting encryptionCode produces an unencrypted package. Encryption protects editing data, not the source media. Share the code separately from the package and keep it available for the recipient.

Direct Export uses the app's project snapshot and delivery pipeline, including edits, framing, audio mixes, overlays, and inserted assets. includeVideo and includeAudio default to true; at least one must remain enabled. videoCodec accepts auto, h264, hevc, proRes422, proRes422HQ, proRes4444, or proRes4444XQ; audioCodec accepts auto, aac, alac, or pcm. container is auto, mp4, or mov and must agree with the video output extension when set explicitly. ProRes and PCM video delivery require MOV. For audio-only output, set includeVideo: false and use WAV with PCM, or M4A otherwise. Optional integer bitrates are videoBitrateKbps (1–300000) and audioBitrateKbps (1–1536); audioChannels is source, mono, or stereo.

Direct Export does not burn transcript captions or add subtitle tracks. Its automatic video codec is HEVC for a primary HEVC source and H.264 otherwise; automatic audio uses AAC. The project's HDR output cannot be delivered as H.264, so choose HEVC or ProRes when preserving HDR. Requested H.264/HEVC and AAC bitrates are capped by known source bitrates; without those facts, the render planner clamps video bitrate to 500–300000 kbps and AAC bitrate to 32–1536 kbps. ProRes ignores video bitrate, and ALAC/PCM ignore audio bitrate. Silent-channel removal only applies to an unmixed original bus, not an approved mixed audio bus.

For NLE and video exports, resolution accepts source, p4320, p3160, p2160, p1440, p1080, p720, or p480. frameRate accepts source, fps60, fps5994, fps50, fps30, fps2997, fps25, fps24, or fps23976. Video export defaults to source resolution, frame rate, and audio channels, automatic codecs/container, and no silent-channel removal. Direct delivery never upscales the resolved output or increases its frame rate. Although automation accepts all listed ProRes codecs, the app's native codec menu offers ProRes only for a ProRes source.

Frame export captures the requested project's edited timeline composition without encoding an intermediate movie or relying on the open player. It requires visual content; timestampSeconds must be nonnegative and less than the edited timeline's duration. Transcript tools export the snapshot's visible transcript words with final edited timestamps and project profanity settings, including timing shifts from inserted assets. They require exportable transcript words and do not automatically transcribe speech in placed media. splitMode defaults to sentences and also accepts words.

The dedicated tools reject settings belonging to another destination rather than silently ignoring them. NLE and video deliveries do not automatically generate the transcript sidecars selected in Settings. Start a separate TXT or subtitle delivery if needed, and wait for the first job to finish: only one automated export can be active for a project at a time. NLE bundles retain external source links and are not guaranteed self-contained media copies.

For app workflows and format limits, see Export finished media, Sequence Packages, and Layers and reusable assets.

For example, export the edited variant as video:

{
  "name": "sequence_export_video",
  "arguments": {
    "projectId": "<returned-variant-id>",
    "outputPath": "/Users/you/Movies/Social Cut.mp4",
    "videoCodec": "h264"
  }
}

Exports return a job ID, not a completed file. In a raw MCP tool result, the command envelope is under structuredContent.payload; a successful export start exposes the job ID at structuredContent.payload.result.jobId. Check isError, exitCode, and truncation flags before consuming a tool result. Inspect progress and the resulting output path through sequence_cli:

{
  "name": "sequence_cli",
  "arguments": { "arguments": ["app", "jobs", "poll", "<job-id>", "--json"] }
}

Polling reports the current job state; a successful poll is not proof that the export succeeded. Continue until the job completes, fails, or is cancelled, and inspect warnings and the reported output path. Do not hand off a file while its job is still running.

Cancellation is cooperative: an in-flight encode or source copy may need to finish before the job stops, but a cancelled job does not publish staged files. A completed Add to Assets operation remains linked.

Agent Mode

Agent Mode shows activity on the affected project tabs and library rows, plus transcript progress, without locking workspace or transcript input. You can continue working on another project; avoid competing edits to the variant the assistant is changing. Background-job indicators remain until the job finishes, fails, or is cancelled. Tool-call activity clears automatically if a disconnected client stops renewing it; that activity indication is separate from the explicit edit session.

Turning Automation off or closing Sequence removes the app broker and prevents further MCP access. Product analytics and account preferences remain separate from the Automation setting.

Troubleshooting

• Server not found: run command -v sq and use that full executable path in the host configuration.
• Automation unavailable: open Sequence and enable Automation. MCP requires the app to already be running.
• Sign-in, activation, or unlock required: complete the requested step in Sequence, then retry the tool.
• Command unavailable: check sq --version, the app version, and sq app doctor; update both components as described in the CLI guide.
• Edit session missing or wrong target: begin an edit in the current MCP connection, then pass its exact editSessionId and returned variantId on editorial writes.
• Agent operation interrupted: inspect the saved variant before retrying. A reconnect loses the edit session, not the persisted edit. To resume in place, begin with the exact saved child or program ID and editExisting: true; beginning without that option makes a new copy.

Use sq app doctor --json to inspect app access and installation readiness. Sequence keeps database keys and sandbox access inside the app. The assistant receives the project and transcript information requested by its tools; choose a host whose data handling suits your work.