Every path to one execution layer.

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

Twin’s REST API is the universal integration path: 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, and none is published.

Python is where most agent code lives — LangChain, LlamaIndex, CrewAI, AutoGen, Pydantic AI and the OpenAI and Anthropic SDKs are all Python-first. Anything you can express as a function call, an agent can be given as a tool.

Node is the other half of the agent ecosystem — the Vercel AI SDK, LangChain.js, and the OpenAI and Anthropic TypeScript SDKs all run here, and it is where most production API routes and background workers live.

LangChain is a Python and JavaScript framework for building LLM applications. Its agent loop lets a model pick a tool, observe the result, and decide the next action — which makes browser access a natural tool to add.

LangGraph is LangChain’s low-level orchestration library: you build an explicit state graph of nodes and edges, compile it, and invoke it. Nodes are plain functions over the graph state, so a node does not have to involve a model at all.

LlamaIndex is a data framework for LLM applications — indexing, retrieval and agents over your own content. Its agents call tools, and `FunctionTool.from_defaults` turns any Python function into one, taking the name and description from the function and its docstring.

CrewAI is a Python framework for multi-agent “crews” — role-playing agents that collaborate on tasks. Tools are shared across the crew, and `@tool` from `crewai.tools` turns a function into one, using the docstring as the description the agents read.

AutoGen is Microsoft’s framework for multi-agent LLM applications — conversable agents that call registered functions and coordinate to complete a task. A function registered with an agent becomes a tool the model can invoke mid-conversation.

The OpenAI Agents SDK is a lightweight Python framework for agentic applications — agents, handoffs, guardrails and sessions. Alongside function tools it can connect to MCP servers, including ones it launches itself as a local subprocess over stdio.

Pydantic AI is an agent framework from the Pydantic team, built around typed inputs and validated outputs. Tools are registered on an agent with decorators — `@agent.tool_plain` for a tool that needs no run context, `@agent.tool` for one that does.

Haystack is deepset’s open-source framework for LLM pipelines and agents. Its `Tool` class wraps any Python callable with a name, a description and a JSON-schema `parameters` object, and there is a `@tool` decorator that generates the schema from your function signature.

The Vercel AI SDK is a TypeScript toolkit for building AI applications — a unified interface across model providers, streaming, structured output and tool calling. A tool is defined with the `tool()` helper: a description, an `inputSchema`, and an `execute` function.

OpenAI’s API supports function (tool) calling: you describe a function as a JSON schema, the model decides when to call it, and your code executes it and returns the result. This is the standard way to give a GPT-class model an external capability.

Claude’s Messages API supports tool use: you pass a `tools` array where each tool has a `name`, a `description` and an `input_schema`. When Claude decides to use one, the response comes back with `stop_reason: "tool_use"`, you execute it, and you return a `tool_result` block in the next message.

Claude Desktop is Anthropic’s desktop app for Claude, and it can launch local MCP servers listed in `claude_desktop_config.json`. Registered tools become available to Claude in the conversation.

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

Cursor is an AI-native code editor with a built-in agent that can call MCP tools. Servers are registered in `.cursor/mcp.json` for a project or `~/.cursor/mcp.json` globally, and their tools become available to the agent while you work.

Windsurf is Codeium’s AI-native editor, whose Cascade agent supports MCP servers. Servers are registered in `~/.codeium/windsurf/mcp_config.json` in the same `mcpServers` shape most clients use.

VS Code’s Copilot agent mode supports MCP servers, configured in `.vscode/mcp.json` for a workspace or in your user profile. Note the shape difference: VS Code uses a top-level `servers` key where most other clients use `mcpServers`.

n8n is a source-available workflow automation tool you can self-host or run in their cloud. Workflows are graphs of nodes, and the HTTP Request node calls any REST API — which is all a Twin integration needs.

Make (formerly Integromat) is a visual automation platform where scenarios are built from modules on a canvas. Its HTTP module makes an arbitrary request, so any REST API becomes a step in a scenario.

Zapier is the largest no-code integration platform: a Zap triggers on an event in one app and runs actions in others. When no built-in action fits, Webhooks by Zapier makes a raw HTTP request to any API.

Playwright is a browser automation library that drives Chromium, Firefox and WebKit with explicit, imperative commands — click this selector, fill that field, assert this text. It is precise and fast, and every selector is hand-written and brittle to page changes.