MCP

Run a browser agent over MCP

Expose Twin Browser to Cursor, Claude Desktop, Claude Code, and Cline through the Model Context Protocol — three tools (run, compile_skill, run_skill) and your editor can drive a real browser.

The Model Context Protocol (MCP) is how editors and desktop agents discover and call external tools. Twin ships an MCP server, so any MCP client — Cursor, Claude Desktop, Claude Code, Cline — can give its agent a browser without any glue code. This guide covers connecting the server and using its three tools.

What is the Twin MCP server?

It is a standards-compliant MCP server that exposes three tools — run (execute a goal), compile_skill (compile a reusable skill), and run_skill (replay a compiled skill by id). An MCP client lists these tools to its model automatically, so the agent can decide to use a browser the same way it decides to read a file.

How do I connect it?

Add the Twin MCP server to your client's MCP config with your Bearer key. The example below is the canonical JSON shape used by Cursor, Claude Desktop, Claude Code, and Cline.

MCP server configjson
{
  "mcpServers": {
    "twin-browser": {
      "url": "https://twin-browser.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_TWIN_API_KEY" }
    }
  }
}

What can the agent do once it is connected?

The model can now call the three tools by name. A typical session: call run to accomplish a goal, then compile_skill to make it reusable, then run_skill on later sessions to replay it deterministically.

  • run — "go to this URL and accomplish this goal", returns structured output.
  • compile_skill — turn a successful run into a parameterized, reusable skill.
  • run_skill — replay a compiled skill by id with zero LLM planning calls.

How does cost stay flat in an editor workflow?

The same compile-once economics apply. The first time you ask your editor agent to do a web task it compiles a skill; the next time, run_skill (or a dispatch match) replays it with no planning call. So an agent you use dozens of times a day does not bill you the planner every time.

What about authorization and secrets?

Every MCP call carries your Bearer key, and the target URL is the authorization signal — auth, billing, and audit logging run on every call. Logins come from the credential vault by reference, never from the editor or the model context, and the backend enforces default-deny RLS per tenant.

Keep going

The mechanics behind this guide: the semantic dispatch cache, deterministic replay, and skill compilation. Plug Twin into MCP, LangChain, or the REST API, or see it applied to AI agents and RPA replacement. Weighing options? See how Twin compares.

Which MCP clients are supported?
Any standards-compliant MCP client, including Cursor, Claude Desktop, Claude Code, and Cline. The server exposes the same three tools to all of them.
What are the three MCP tools?
run executes a goal in a browser, compile_skill turns a successful run into a reusable parameterized skill, and run_skill replays a compiled skill by id with no LLM planning call.
Do MCP runs use the semantic cache?
Yes. run can resolve to a cached skill, and run_skill is a deterministic replay, so repeated editor tasks avoid the planner cost just like REST calls do.

Run your first skill

Compile a task once, then replay it deterministically with zero LLM calls. Start free.