OpenCut Rewrite: Open Source Video Editor Gets Plugins, Headless Mode, MCP Server, and Multi-Platform Support

On May 27, 2026, the OpenCut team announced they're rebuilding their open source video editor from the ground up. What started as a web-only video editor is evolving into something much bigger: a multi-platform video editing engine with plugins, headless rendering, scripting capabilities, and an MCP server for AI integration.

The rewrite addresses a fundamental architectural decision: the original TypeScript engine running in a browser was fine when web was the only platform. But OpenCut is now expanding to Desktop, Android, and iOS—each becoming a thin UI layer wrapped around the same underlying engine.

Beyond platform expansion, the rewrite introduces four major capabilities that weren't possible in the original architecture: a plugin system, headless mode, a scripting tab, and an MCP server. These additions transform OpenCut from a traditional video editor into a programmable video platform that developers can build on.

This article covers what's changing, why the team chose a complete rewrite, the new capabilities being added, and how to follow along with development.

Why rewrite from the ground up?

The OpenCut team made a clear decision: complete rewrite rather than incremental refactoring. The reason comes down to architecture.

The original OpenCut was built with a TypeScript engine running in the browser. That architecture works well for a web-only editor, but it creates friction when expanding to native platforms:

• Platform-specific UI — Each platform needs its own interface layer
• Rendering consistency — The same edit should produce identical output everywhere
• Feature parity — New capabilities should work across all platforms
• Performance optimization — Native platforms have different performance characteristics

Rather than maintaining separate codebases or dealing with cross-platform compromises, the team chose to rebuild the engine as a platform-agnostic core that any UI can wrap around.

The rewrite also enables capabilities that would be difficult to retrofit into the existing codebase:

1. Plugin architecture — Requires clean separation between core and extensions
2. Headless rendering — Needs an engine that can run without a UI
3. Scripting interface — Requires a fully programmable API
4. MCP server — Needs structured access to all editing operations

In the team's words: "Everything in this post comes from one decision." That decision is the foundation rewrite.

Platform expansion: Web, Desktop, Android, iOS

After the rewrite, OpenCut will run on four platforms:

Each platform gets a thin UI layer optimized for its input methods and design conventions, but the editing engine, rendering pipeline, and feature set remain identical across all platforms.

This architecture means:

• Edit on mobile, export on desktop — Projects are fully portable
• Consistent rendering — A 60fps export looks the same everywhere
• Unified plugins — A plugin written once works on all platforms
• Shared development — New features ship everywhere simultaneously

The web version remains the primary development target, with other platforms following as the engine stabilizes.

New UI and keyboard-first mode

The rewrite includes a brand new user interface designed from the ground up. While the team calls it "revolutionary" with a touch of humor, the real focus is on workflow efficiency.

Key UI improvements:

• Modern design — Cleaner, more professional appearance
• Keyboard-first mode — Optional mode for power users who prefer keyboard shortcuts
• Improved timeline — Better snapping, grouping, and multi-track editing
• Faster renderer — More stable export pipeline with better performance

The keyboard-first mode is particularly interesting for developers and power users. When enabled, you can perform most editing operations without touching the mouse—similar to Vim or Emacs workflows in code editors.

Feature additions that users requested

Beyond the architectural changes, the rewrite brings several features users have been requesting:

Auto caption fixes

Improved automatic caption generation with better accuracy and formatting options.

Transitions and filters

A much bigger effects library with professional transitions, filters, and color grading tools. Effects are GPU-accelerated for real-time preview.

Group elements

Finally, you can group multiple timeline elements and edit them as a unit—essential for complex compositions.

Faster, more stable renderer

The new rendering pipeline is rebuilt for performance and reliability, with better memory management and progress reporting.

These improvements set the stage for the bigger architectural additions.

1. Plugin system: extend OpenCut however you want

OpenCut is getting a full plugin system that allows users to install third-party plugins from the Plugin Store or build and publish their own.

How the plugin system works

• Same API — Built-in features and third-party plugins run on the same Plugin API
• Disable built-ins — You can turn off any built-in feature you don't want
• Install from store — Browse and install community plugins
• Publish your own — Build plugins and share them with the community

The Plugin API provides structured access to:

• Timeline manipulation (add, remove, move clips)
• Effects and transitions
• Export settings and presets
• UI customization
• File import and export

Plugin ideas from the team

The announcement includes several plugin concepts that illustrate the system's flexibility:

Custom snapping — Snap to audio peaks in the timeline instead of just frame boundaries. Useful for syncing video edits to music beats.

Cross-platform publishing — Publish to TikTok, YouTube, Instagram, and more inside the editor. No need to export and upload manually.

Silence remover — Scan the timeline and automatically cut any silence longer than a threshold you set. Essential for podcast editing.

Third-party developers can build plugins for niche workflows like:

• Custom subtitle styles and animations
• Template systems for recurring content
• Integration with stock footage libraries
• Color grading presets and LUTs
• Audio processing and noise reduction

The plugin system transforms OpenCut from a fixed-feature editor into a platform that grows with its community.

2. Headless mode: render videos without opening the editor

Headless mode is one of the most powerful additions for developers: the ability to run OpenCut's engine without a UI.

What headless mode enables

Instead of opening the editor, clicking through menus, and manually exporting, you script what you want and OpenCut renders a finished video.

Batch rendering — Queue 50 clips with the same template, come back to finished files. Perfect for generating multiple versions of the same content.

Template pipelines — Define your format once, swap the assets, re-render. What took an hour of clicking is now a script you run. Ideal for recurring content like weekly shows or product demos.

Server-side rendering — Build anything on top of OpenCut. Your users click a button and a render comes out. They never see the editor. This enables SaaS products built on OpenCut's engine.

Example use cases

Automated social media clips — A script watches a folder for new podcast episodes, extracts 1-minute clips based on transcript timestamps, adds branded intros and subtitles, and uploads to YouTube Shorts.

Personalized video at scale — An e-learning platform generates custom certificate videos for each student by swapping names and achievement data into a template.

Data visualization videos — A financial dashboard exports monthly reports as videos by feeding chart data into OpenCut templates and rendering overnight.

Headless mode makes OpenCut a video rendering engine, not just an editor.

3. Scripting tab: automate tasks without writing plugins

While plugins are for permanent additions, the scripting tab is for one-off automation and experimentation.

The scripting tab is a panel in the editor where you can write scripts that talk directly to OpenCut:

// Example: Add a 1-second fade transition between all clips
const clips = timeline.getClips();
for (let i = 0; i < clips.length - 1; i++) {
  timeline.addTransition(clips[i], clips[i+1], 'fade', 1.0);
}

Use cases:

• Bulk operations — Apply the same effect to 50 clips at once
• Custom automation — Implement a workflow the UI doesn't expose
• Prototyping — Test plugin ideas before building a full plugin
• Learning — Explore OpenCut's API interactively

The scripting tab provides immediate feedback, making it easy to experiment with the Editor API without setting up a development environment.

4. MCP server: AI agents as editing collaborators

OpenCut will expose an MCP (Model Context Protocol) server, allowing AI agents to work alongside you while editing.

What the MCP server enables

While you're editing, an AI agent can:

• Manipulate the timeline — Add clips, adjust timing, rearrange sequences
• Apply transitions — Intelligently add transitions based on content
• Run scripts — Execute automation scripts you've written
• Suggest improvements — Analyze your edit and propose changes

The MCP server works with Cursor, Claude Code, and any MCP-compatible client.

Example workflow

You're editing a product demo video. You tell your AI agent:

"Add a 0.5-second crossfade between every scene, then boost audio by 3dB on all voiceover clips."

The agent uses OpenCut's MCP server to:

1. Query the timeline for scene boundaries
2. Insert crossfade transitions at each boundary
3. Identify audio clips marked as voiceover
4. Apply +3dB gain to those clips
5. Report completion

This level of AI integration turns OpenCut into a collaborative editing environment rather than a solo tool.

For developers unfamiliar with MCP, it's a protocol that allows AI agents to access application functionality through a standardized interface. Learn more at ExplainX's MCP guide.

The Editor API: build anything on OpenCut

All four new capabilities—plugins, headless mode, scripting, and MCP—rely on the Editor API: a fully public API that exposes everything you can do in the editor.

The team's promise:

"Everything you'll be able to do in the editor, you'll be able to do through a fully public API. Build on it, script it, automate it, ship products on top of it."

This is the foundation that makes OpenCut more than a video editor—it's a programmable video platform.

Following along with development

OpenCut is building in the open. You can:

• Watch progress on the tracking issue on GitHub
• Ask questions and get early builds in Discord
• Contribute to the open source project
• Request features and vote on priorities

The team posts sneak peeks and early builds to Discord first, so join if you want to test features before official releases.

Complete picture: what's coming

Here's the full scope of the rewrite:

Platform support:

• Web (current + modernized)
• Desktop (Windows, Mac, Linux)
• Android
• iOS

New capabilities:

• Plugin system with Plugin Store
• Headless rendering mode
• Scripting tab for automation
• MCP server for AI agents
• Public Editor API

Requested features:

• Brand new UI
• Keyboard-first mode (optional)
• Auto caption improvements
• Transitions and filters
• Group elements
• Faster, more stable renderer
• Larger effects library

The rewrite is in active development with no firm release date. The team is prioritizing stability and quality over speed.

ExplainX perspective: open source platforms for AI integration

At ExplainX, we teach MCP integration, AI agent development, and automation workflows. OpenCut's rewrite exemplifies a trend we've been tracking: open source tools becoming platforms for AI and automation.

Key observations:

• MCP adoption — More tools exposing MCP servers for agent integration
• Headless-first — Rendering engines that work without UIs enable automation
• Public APIs — Tools that expose full APIs unlock developer ecosystems
• Plugin architectures — Extensibility through well-defined APIs

OpenCut's approach—complete rewrite to support programmability—is the right move for a tool aiming to be a platform, not just an app.

The combination of headless mode + MCP server + scripting creates a powerful foundation for:

• Automated content pipelines
• AI-assisted editing workflows
• Custom video tools built on OpenCut's engine
• Enterprise integrations with existing content systems

We're excited to see what developers build on top of OpenCut.

Technical Architecture: How the Rewrite Works

Understanding OpenCut's architectural evolution helps explain why a complete rewrite was necessary rather than incremental refactoring.

Original Architecture (Pre-Rewrite)

The first version of OpenCut was built as a browser-based video editor with:

• TypeScript rendering engine running entirely in WebAssembly
• Canvas-based timeline for UI rendering
• Web Audio API for audio processing
• WebCodecs API for video encoding/decoding
• IndexedDB for project storage

This architecture was elegant for web-only deployment but created constraints:

• No native file access - limited by browser sandbox restrictions
• Performance ceiling - WebAssembly and JavaScript have overhead vs. native code
• Platform fragmentation - rewriting the same logic in Swift (iOS), Kotlin (Android), and Electron (Desktop) would fragment the codebase

New Architecture (Post-Rewrite)

The rewrite introduces a platform-agnostic core with native wrappers:

Core Engine Layer (TypeScript/Rust hybrid):

• Timeline management: Track organization, clip arrangement, transition timing
• Rendering pipeline: FFmpeg-based encoding with GPU acceleration where available
• Effect system: Shader-based filters and transitions (WebGL on web, Metal on iOS, Vulkan on Android)
• Plugin runtime: Sandboxed execution environment for third-party code
• State management: Immutable state tree with undo/redo support

Platform Adapter Layer:

• Web: WebAssembly + WebGL + Web Audio API
• Desktop: Tauri wrapper with native file dialogs and system integration
• iOS: Swift wrapper with AVFoundation for media handling
• Android: Kotlin wrapper with MediaCodec for hardware acceleration

API Layer:

• Editor API: Public TypeScript API for programmatic control
• Plugin API: Subset of Editor API with security restrictions
• MCP Server: gRPC-based service for agent communication
• Headless Runtime: Node.js-compatible server for batch rendering

This layered approach means core logic is written once (in the engine layer) and platform-specific code is minimal (just the adapter layer).

Performance Optimizations

The rewrite includes several performance improvements:

GPU acceleration:

• All transitions and effects are compiled to GPU shaders (GLSL/MSL)
• Video decoding uses hardware decoders where available (VideoToolbox on macOS/iOS, MediaCodec on Android)
• Timeline rendering is offloaded to GPU for 60fps preview even on 4K footage

Memory management:

• Lazy loading of video frames (only decode what's visible on screen)
• Intelligent caching of thumbnails and preview renders
• Background garbage collection to prevent memory leaks during long editing sessions

Multi-threading:

• Rendering happens on separate thread pool (doesn't block UI)
• Audio processing runs in dedicated audio thread
• Export pipeline uses all available CPU cores for encoding

Streaming architecture:

• Large video files are streamed in chunks rather than loaded entirely into memory
• Export renders to disk progressively rather than buffering the entire output

Plugin System: Deep Dive

The plugin system is one of the most technically ambitious parts of the rewrite. Here's how it works under the hood:

Plugin API Surface

Plugins get access to a subset of the Editor API with security boundaries:

Allowed operations:

• Read timeline state: Get clips, transitions, effects, metadata
• Modify timeline: Add/remove/move clips (with undo support)
• Register UI components: Add panels, buttons, context menu items
• Access file system: Read/write files within user-granted permissions
• Network requests: Fetch data from external APIs (with user consent)

Restricted operations:

• No direct DOM access: Plugins can't inject arbitrary HTML (prevents XSS)
• No eval or unsafe code: Sandboxed runtime prevents code injection
• Rate limiting: API calls are throttled to prevent abuse
• Permission model: Users must approve each capability the plugin requests

Plugin Lifecycle

When a plugin is loaded:

1. Manifest parsing: OpenCut reads plugin.json for metadata, permissions, and entry point
2. Dependency resolution: If the plugin requires other plugins, they're loaded first
3. Sandbox creation: A JavaScript VM sandbox is created with restricted global scope
4. Plugin initialization: The plugin's init() function is called with the Plugin API
5. Event registration: Plugin registers for timeline events, UI hooks, and keyboard shortcuts

When a plugin is unloaded:

1. Cleanup callback: Plugin's cleanup() function is called
2. Event deregistration: All registered handlers are removed
3. UI teardown: Plugin-added UI elements are destroyed
4. Sandbox destruction: JavaScript VM is garbage collected

Example Plugin: Silence Remover

Here's what a real plugin looks like:

// plugin.json
{
  "name": "silence-remover",
  "version": "1.0.0",
  "permissions": ["timeline.read", "timeline.write", "audio.analyze"],
  "entry": "index.js"
}

// index.js
export default class SilenceRemoverPlugin {
  async init(api) {
    // Register a button in the toolbar
    api.ui.addButton({
      label: "Remove Silence",
      icon: "scissors",
      onClick: () => this.removeSilence(api)
    });
  }

  async removeSilence(api) {
    const tracks = api.timeline.getAudioTracks();

    for (const track of tracks) {
      // Analyze audio for silence
      const silenceRanges = await api.audio.detectSilence(track, {
        threshold: -40, // dB
        minDuration: 0.5 // seconds
      });

      // Remove detected silence
      for (const range of silenceRanges.reverse()) {
        api.timeline.cut(track, range.start, range.end);
      }
    }

    api.ui.showNotification("Removed " + silenceRanges.length + " silence gaps");
  }

  cleanup() {
    // Clean up resources
  }
}

This plugin:

• Requests permission to read/write timeline and analyze audio
• Adds a button to the UI
• Analyzes audio tracks for silence below -40dB lasting >0.5s
• Cuts out the silent ranges
• Shows a notification when done

Plugin Distribution and Security

The Plugin Store is a centralized repository where:

• Developers submit plugins for review
• OpenCut team performs security audits (checking for malicious code, excessive permissions, etc.)
• Approved plugins are signed with a cryptographic signature
• Users can browse, install, and rate plugins

Security measures:

• Sandboxing: Plugins run in isolated VM with no access to system APIs
• Permission system: Users must approve each capability (like mobile app permissions)
• Code signing: Only signed plugins from the store can be auto-installed
• Manual review: Each plugin version is manually reviewed before approval

For enterprise users, OpenCut will support private plugin repositories where companies can host internal plugins without going through the public store.

Headless Mode: Implementation Details

Headless mode transforms OpenCut from an interactive editor into a programmable rendering service.

Headless Architecture

When running headless, OpenCut:

• Skips UI initialization - no Electron window, no React components
• Exposes HTTP API - REST endpoints for project upload, render configuration, and status checking
• Runs as daemon - persistent process that accepts render jobs via queue
• Outputs to file/stream - finished videos are written to disk or streamed over HTTP

Example: Headless Rendering via API

Start the headless server:

opencut serve --headless --port 8080

Submit a render job via HTTP:

curl -X POST http://localhost:8080/render \
  -F "project=@my_project.opencut" \
  -F "output_path=/tmp/output.mp4" \
  -F "resolution=1920x1080" \
  -F "fps=60" \
  -F "codec=h264"

Check render status:

curl http://localhost:8080/render/abc123/status
# Returns: {"status": "rendering", "progress": 0.45, "eta_seconds": 120}

Download finished render:

curl http://localhost:8080/render/abc123/download -o output.mp4

Scripting Headless Renders

For programmatic control, use the Node.js API:

const OpenCut = require('opencut');

async function renderVideo() {
  const editor = await OpenCut.createHeadless();

  // Load project from file
  await editor.loadProject('./template.opencut');

  // Programmatically modify the timeline
  editor.timeline.addClip({
    file: './footage.mp4',
    start: 0,
    duration: 10,
    track: 0
  });

  editor.timeline.addText({
    content: "Hello World",
    start: 2,
    duration: 5,
    style: { fontSize: 48, color: '#ffffff' }
  });

  // Export with custom settings
  await editor.export({
    output: './output.mp4',
    resolution: [3840, 2160], // 4K
    fps: 30,
    codec: 'h265',
    bitrate: '50M'
  });

  console.log('Render complete!');
}

renderVideo();

Headless Use Cases in Production

1. Social Media Automation Platform

A SaaS product that generates branded social videos:

• Users upload raw footage via web UI
• Backend uses OpenCut headless to apply brand templates
• Videos are auto-exported in multiple formats (16:9, 9:16, 1:1)
• Final videos upload to YouTube, TikTok, Instagram APIs

2. E-Learning Content Pipeline

An online course platform generating lecture videos:

• Instructor records talking-head video + screen capture
• OpenCut headless syncs the two sources and adds branded intro/outro
• Auto-generates chapters based on transcript timestamps
• Exports with burned-in captions and chapter markers

3. News Agency Video Generation

A newsroom generating daily video summaries:

• Journalists write scripts in CMS
• Backend fetches relevant stock footage from media library
• OpenCut headless assembles clips, adds lower-thirds, applies color grading
• Final videos go directly to broadcast playout system

MCP Server: AI Agent Integration Patterns

The MCP server is OpenCut's bridge to the AI agent ecosystem. Here's how it works in practice:

MCP Protocol Basics

Model Context Protocol (MCP) is a standardized way for AI agents to communicate with applications. OpenCut's MCP server exposes tools that agents can invoke:

Available MCP tools:

• opencut.timeline.getClips() - List all clips in the timeline
• opencut.timeline.addClip(file, start, track) - Add a video/audio clip
• opencut.timeline.addTransition(clip1, clip2, type, duration) - Insert transition
• opencut.effects.apply(clip, effect, params) - Apply effect to clip
• opencut.export.start(settings) - Begin export with specified settings
• opencut.project.save(path) - Save current project
• opencut.script.execute(code) - Run JavaScript in scripting tab

Example: AI-Assisted Editing Workflow

User working in OpenCut with Claude Code running:

User: "I need to add a 1-second fade transition between every scene in this timeline."

Claude Code (via MCP):

1. Calls opencut.timeline.getClips() to retrieve all clips
2. Analyzes clip metadata to identify scene boundaries
3. For each boundary, calls opencut.timeline.addTransition(clipA, clipB, 'fade', 1.0)
4. Responds: "Added 12 fade transitions between scenes. Timeline updated."

User: "Now export this as a 4K YouTube video."

Claude Code:

1. Calls opencut.export.start({ format: 'mp4', resolution: '3840x2160', preset: 'youtube' })
2. Monitors export progress via opencut.export.status()
3. Responds: "Export started. Estimated completion in 3 minutes."

Multi-Agent Collaboration

Advanced users can run multiple specialized agents simultaneously:

• Content agent: Analyzes footage and suggests shot selection
• Audio agent: Balances levels, removes noise, adds music
• Color agent: Applies color grading based on mood/genre
• Caption agent: Generates and times captions from transcript

Each agent uses the MCP server to read and modify the timeline in coordination. OpenCut's undo system allows reverting any agent-made changes.

Security Model for MCP Access

The MCP server requires authentication to prevent unauthorized access:

• Local-only mode (default): MCP server only accepts connections from localhost
• API key mode: Require bearer token for all MCP requests
• OAuth mode: Integrate with identity providers for enterprise deployments

Users can grant per-agent permissions:

• Agent A can read timeline but not modify it
• Agent B can add clips but not delete existing ones
• Agent C has full access to everything

Comparison: OpenCut vs. Alternatives

How does OpenCut stack up against other video editing tools?

OpenCut vs. DaVinci Resolve

DaVinci Resolve:

• Professional-grade color grading and VFX
• Industry-standard in Hollywood
• Free tier available but limited features
• Closed source, no headless mode, no plugin API

OpenCut:

• Open source with full programmability
• Headless rendering and API access
• Plugin ecosystem for extensibility
• Trade-off: Less mature, fewer professional features

When to choose OpenCut: Automation pipelines, custom workflows, embedding in other tools

When to choose DaVinci: High-end color work, VFX, professional productions

OpenCut vs. FFmpeg

FFmpeg:

• Command-line video processing toolkit
• Extremely powerful and flexible
• No GUI, steep learning curve
• Industry standard for batch processing

OpenCut:

• GUI editor + headless mode
• Easier for non-technical users
• Plugin ecosystem for common tasks
• Built on FFmpeg under the hood

When to choose OpenCut: Need both interactive editing and automation

When to choose FFmpeg: Pure command-line automation, maximum control

OpenCut vs. Remotion

Remotion:

• React-based programmatic video generation
• Code-first approach (write React components that render to video)
• Great for data-driven videos (charts, visualizations)
• Requires JavaScript/React knowledge

OpenCut:

• GUI-first with optional scripting
• Lower barrier to entry
• Better for traditional editing workflows
• Plugin system vs. React components

When to choose OpenCut: Team includes non-developers, need interactive editing

When to choose Remotion: Pure code-first workflow, React expertise available

OpenCut vs. Adobe Premiere Pro

Adobe Premiere Pro:

• Industry-standard professional editor
• Deep Adobe ecosystem integration
• Subscription pricing ($22.99/month)
• Closed source, limited automation

OpenCut:

• Open source and free
• Full API and headless mode
• Plugin system for extensibility
• Trade-off: Fewer built-in effects and templates

When to choose OpenCut: Budget constraints, automation needs, open source requirements

When to choose Premiere: Professional workflows, Adobe ecosystem, advanced features

Roadmap and Future Plans

The OpenCut team has outlined several post-rewrite priorities:

Phase 1: Core Platform (Q2-Q3 2026)

• Complete rewrite of core engine
• Launch web version with new UI
• Basic plugin system and store
• Headless mode beta
• MCP server initial release

Phase 2: Mobile and Desktop (Q4 2026)

• Desktop apps (Windows, Mac, Linux)
• iOS app (App Store)
• Android app (Google Play)
• Plugin API stabilization
• Documentation and tutorials

Phase 3: Enterprise Features (Q1 2027)

• Team collaboration (real-time co-editing)
• Private plugin repositories
• SSO and RBAC for enterprise
• Audit logging and compliance tools
• Self-hosted deployment options

Phase 4: Advanced Capabilities (Q2 2027+)

• AI-powered editing suggestions
• Voice-controlled editing
• Automatic video optimization for platforms
• Cloud rendering farm integration
• Advanced color grading and VFX

Community and Contribution

OpenCut is community-driven with active contribution opportunities:

How to Contribute

Code contributions:

• Core engine development (TypeScript/Rust)
• Platform adapters (Swift, Kotlin, Tauri)
• Plugin development
• Documentation improvements

Design contributions:

• UI/UX improvements
• Icon and asset design
• User flow optimization
• Accessibility enhancements

Community support:

• Answer questions in Discord
• Write tutorials and guides
• Create video demos
• Translate documentation

Governance Model

OpenCut uses a core team + community model:

• Core team: Makes architectural decisions, reviews PRs, maintains roadmap
• Community maintainers: Trusted contributors with merge permissions
• Plugin developers: Anyone can publish plugins to the store

All major decisions are discussed in GitHub Discussions before implementation.

Read next

• MCP servers: complete guide
• What are AI agent skills?
• Agent harnesses and workflow orchestration
• Building automation workflows with AI
• DeepSeek V4-Pro: Benchmarks and Pricing
• Saperly: Phone Carrier for AI Agents

Development is in progress. Feature availability and timelines subject to change. Follow github.com/OpenCut-app/OpenCut/issues/811 for updates. All code examples are illustrative and subject to API changes before final release.