Use real software from your AI agent.
Semwright connects MCP-compatible agents to desktop and professional applications.
Work with application objects, control what can run, and inspect the result.
Get started · MCP and Semwright · Documentation · Applications · Build an integration
One prompt updates an aircraft's materials in Blender, renders a camera shot, creates titles in Motion Canvas, and assembles the video with audio through MLT.
Recorded in one take using an existing aircraft project. Waiting periods are accelerated; final playback runs at normal speed. The workflow produces a video and an editable timeline.
The recorded workflow, simplified:
flowchart LR
Blender["Blender: materials and camera"] --> Shot["Rendered shot"]
Shot --> MLT["MLT: assemble video"]
Motion["Motion Canvas: titles"] --> MLT
Audio["Audio"] --> MLT
MLT --> Output["Video and editable timeline"]
You need an MCP-compatible agent and a Linux, macOS or Windows computer. Install Semwright once; the agent and the applications you want to use are installed separately.
Download the package for your system and SHA256SUMS from the 1.0.0 release. Verify the checksum, extract the archive, then run the installer inside it:
| System | Command inside the extracted bundle |
|---|---|
| Linux | ./install.sh |
| macOS | ./install.sh |
| Windows (PowerShell) | .\Install-Semwright.ps1 |
Run the setup command printed by the installer. Setup creates your local configuration and agent connection file, beginning with read-only permissions.
Next, run the Broker command printed by setup and leave that terminal open. This starts the local process that handles your agent's requests.
Package selection, checksum commands and installation help →
Setup creates mcp-client.json with the installed connection command. In your agent's MCP settings, add a local / stdio server named semwright, using the command path from that file. If your client accepts mcpServers JSON, merge the generated entry with your existing servers.
Restart or reconnect the agent to load the tools. Keep the Semwright terminal running.
Find your connection file → · MCP configuration →
Send this to your agent:
Use Semwright to list the capabilities available in this session. Explain what I can try next. Do not modify any files or applications.
The agent should report what is available in your environment. This checks the connection. Application workflows need their own integrations and permissions; setup does not install them or authorize edits.
Next, choose the application you want to use. If the connection fails, run the Doctor command printed by setup and follow the troubleshooting guide.
Semwright is an open runtime that runs locally between your agent and your software.
- Work with application objects. Use typed operations for scenes, documents and other objects. Semwright prefers application APIs, with semantic desktop interfaces and explicit input/capture fallbacks where needed.
- Keep access explicit. Agent, CLI and application requests share the same permissions and approval checks. Discovering an operation does not grant permission to run it.
- Inspect what happened. Readback and execution evidence distinguish what was requested from what was observed. Missing evidence stays unknown.
An operation follows this path:
flowchart LR
Request["Requested operation"] --> Gate{"Authorized?"}
Gate -->|No| Stop["Refuse or request approval"]
Gate -->|Yes| Run["Run the scoped operation"]
Run --> Result["Return observations and evidence"]
Observations describe the available evidence; they do not automatically prove that every intended change succeeded. Read how it works →
Model Context Protocol (MCP) defines how an AI application connects to servers that expose tools, resources and prompts. The server implements what its tools actually do.
Semwright provides the application runtime behind those calls: application integrations, permissions, object references, bounded jobs and execution evidence. Its MCP frontend lets your existing agent use that runtime.
| Component | Role |
|---|---|
| MCP | The communication protocol for discovering and calling tools, and exchanging context. |
| An MCP server | A program that exposes tools and context using that protocol. |
| Semwright | An application execution runtime, reachable through its MCP server or directly through CLI and Recipes. |
flowchart TB
Agent["Your AI agent"] <-->|MCP| Frontend["Semwright MCP frontend"]
Frontend <--> Runtime["Semwright runtime: permissions, objects and audit"]
CLI["CLI / Recipes"] --> Runtime
Runtime <--> Drivers["Application integrations"]
Drivers <--> Blender["Blender"]
Drivers <--> Browser["Chromium"]
Drivers <--> Documents["LibreOffice"]
They work together. Use MCP to connect your agent; use Semwright to discover and run supported application operations through a shared execution and permission model. An MCP server can implement permissions and application logic of its own; Semwright supplies that runtime across its integrations.
Already have an MCP server? Semwright can also bring an owner-configured local stdio server into the same permission and audit path. MCP connection guide → · Governed MCP federation →
These integrations expose selected operations. Coverage varies by application, version, platform and environment; a listed driver does not imply full application support.
| Application | Integration guide |
|---|---|
| Blender | Scene authoring and export |
| Godot | Editor and project operations |
| Chromium | Browser operations through CDP |
| LibreOffice | Selected Writer, Calc and PDF operations |
| Figma | Plugin API integration |
| OBS Studio | WebSocket integration |
| Motion Canvas and MLT | Motion design · Video rendering |
| KiCad | Curated IPC integration |
| Faust and Ardour | Audio synthesis · Managed audio sessions |
Platform requirements → · Verified coverage and limits →
| What you want to connect | Start here |
|---|---|
| An application that owns its model, storage and transactions | Native application SDK |
| An application API or persistent session | Application Driver SDK |
| A narrow external command | Plugin SDK |
| An agent or existing MCP server | CLI · MCP · Governed MCP federation |
The Native SDK builds on the Driver SDK and lets the application remain the source of truth for its own state. Integrations use the same permissions and audit path as the core runtime.
For reusable procedures and project state, see Recipes, Project Graph and Effects.
Setup starts with read-only permissions. Editing applications and other sensitive actions require explicit authority; an agent cannot approve its own sensitive request.
The release's hosted package tests do not certify every interactive desktop or application version. macOS signing/notarization, physical Hyprland certification and unlocked Windows desktop certification have separate limits. See the release notes for the published version's evidence and limits.
Security policy and private reporting · Permissions · Threat model · Verification records
For source builds and the synthetic-desktop smoke test, start with development. The installation reference includes the commands and prerequisites.
Contributing · Support · Changelog · Documentation
The original core source is MIT OR Apache-2.0. The isolated integrations/kicad-driver subtree is GPL-3.0-or-later, with its own notices. See licenses and notices and governance.