MCP client integration

Twin Browser + Cursor

Cursor is an AI-native code editor with a built-in agent that can call MCP tools. Once an MCP server is registered in Cursor’s settings, the agent can invoke its tools while you work — including driving a real browser.

Get an API key Read the docs

MCP client3 MCP tools: run · compile_skill · run_skillBearer key auth

How Twin plugs into Cursor

Add the Twin MCP server to Cursor and its agent gains the `run`, `compile_skill`, and `run_skill` tools. Ask Cursor to perform a web task — fetch data, fill a form, check a deployed page — and it calls Twin. The first run compiles a skill; the next time you ask for something similar, the semantic dispatch cache serves it without re-running the LLM, so iterating inside the editor stays cheap.

Twin is the browser execution layer your stack calls. The first run cold-compiles a skill; every similar request after that is matched from the cache and replayed deterministically, so your marginal cost per run trends toward zero.

app.example.com

Cursor → Twin

Receive goal from Cursordone
Compile DOM → token-efficient indexed statedone
Match the semantic dispatch cacherunning
Replay compiled skill — 0 LLM callsqueued

What you get through Cursor

Every integration is a thin wrapper over the same execution layer, so the cache, replay, and corpus benefits apply no matter how you call in.

Semantic dispatch cache

A re-phrased goal fuzzy-matches an already-compiled skill, so most calls never touch the LLM.

Deterministic replay

A compiled skill replays the exact action path with zero LLM calls — fast, repeatable, cheap.

Cross-tenant skill corpus

A skill compiled once can be safely reused across tenants, so the hit rate climbs as the network runs.

One Bearer key

Auth, usage-based billing, and an audit log run on every call — the same key works from every integration.

Wire it up

Drop Twin into Cursor

Copy, paste, and swap in your Bearer key. The first run compiles a skill; repeats hit the semantic dispatch cache and replay deterministically.

~/.cursor/mcp.jsonjson

{
  "mcpServers": {
    "twin-browser": {
      "url": "https://twin-browser.com/api/v1/mcp",
      "headers": { "Authorization": "Bearer tw_live_xxx" }
    }
  }
}

// In Cursor's chat:
//   "Use twin-browser to log into staging and confirm the new banner renders"

Base URL https://twin-browser.com/api/v1 · auth Authorization: Bearer tw_live_… · MCP tools run, compile_skill, run_skill.

Read the Cursor docs API reference

Get started

Connect Cursor in 4 steps

Install → configure your key → make the first call. The cache takes over from there.

1
Open MCP settings
In Cursor, go to Settings → MCP and add a new server.
2
Paste the Twin config
Use the Twin MCP URL and your Bearer key in the headers.
3
Enable the server
Toggle it on; Cursor lists run, compile_skill, and run_skill.
4
Ask the agent
Prompt Cursor to do a web task — it calls run under the hood.

Why this stays cheap at scale

Most browser infrastructure re-runs the LLM on every execution, so cost climbs with usage. Twin compiles a task once via skill compilation, matches re-phrased requests to it, and replays without the model — so repeated workflows stop scaling with your token bill.

FAQ

Cursor on Twin — common questions

Do I need a plugin to use Twin in Cursor?

No. Twin is a standard MCP server, so Cursor’s native MCP support is all you need — add the server config and the tools appear.

Can Cursor reuse a skill I compiled elsewhere?

Yes. Skills are stored against your tenant, so a skill compiled from the REST API or another MCP client is available to Cursor’s agent too.

Go deeper

REST API reference MCP server Docs Semantic dispatch cache Deterministic replay Credential vault Compare browser tools

MCP (Model Context Protocol)

Protocol

MCP is an open protocol that lets an LLM application discover and call external tools over a standard interface. An MCP client (Cursor, Claude Desktop, Claude Code, Cline) connects to an MCP server, lists its tools, and invokes them on the model’s behalf — no bespoke glue per app.

Claude Code

MCP client

Claude Code is Anthropic’s agentic coding tool that runs in the terminal and supports MCP servers. Registered MCP tools become available to the agent so it can take real actions — including browser automation — as part of a coding task.

REST API

API

Twin’s REST API is the universal integration path: a small set of HTTPS endpoints under `/api/v1/*` authenticated with a Bearer key. Any language that can make an HTTP request can drive the browser execution layer — no SDK required.

Wire up Cursor in minutes

Free to start. Usage-based credits from $29/mo, with LLM cost metered and passed through at 1×.

Get an API key See pricing