Power your agent
The publisher's own command. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code has no install link for a local command. Copy the command below and run it in a terminal.
TABRUNNER_BRIDGE_PORT=<value> claude mcp add app.tabrunner-tabrunner -- npx -y tabrunner-mcp@0.17.5Run in a terminal.
{ "mcpServers": { "app.tabrunner-tabrunner": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "TABRUNNER_BRIDGE_PORT": "<value>" } } }}claude_desktop_config.json
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchFrom the publisher
Named for what it does: it runs your tabs. You give the goal, it does the running in your browser, with your authority, while you watch.
Most browser agents run in a sandboxed, logged-out browser. TabRunner runs in yours, so it can act on the sites you're actually logged into. And it's provider-agnostic by construction: no vendor lock-in, no relay, no account with us. Your API key (or the subscription you sign in with) goes straight from the extension to your provider.
Give browser tasks to TabRunner, an agent in your own Chrome that uses your logins.
Bring your own provider: 15 presets (Anthropic, OpenAI, Kimi, Z.ai, Qwen, DeepSeek, Gemini, OpenRouter, Groq, Mistral, xAI, Ollama; Anthropic, OpenAI and Kimi each sign in with a subscription) plus any custom endpoint speaking the OpenAI or Anthropic wire format.
Real trusted input: clicks and keystrokes go through the Chrome DevTools Protocol, so they are genuine trusted events, not synthetic JS dispatches that sites can ignore.
Sees the page, not the HTML: the model works from a compact semantic tree
([ref=e12] button "Submit"): small prompts, stable refs, and sanitized, capped results.
Passwords, one-time codes and card numbers never leave the page.
Page-internals tools: when keystrokes won't land, the agent acts directly in the page
(fill, evaluate); read-only network and console rings let it see a failing request or a
script error itself.
Guardrails that hold: you approve the plan before anything happens, and consequential actions (paying, sending, deleting) come back for confirmation. Automatic retry with backoff on transient provider errors, a step budget, truncation detection, and a Stop button that actually stops.
Live run status: current action, elapsed time, and token spend while the agent works, Claude Code-style.
Reasoning effort control: optional per-provider effort (none → max), mapped to each
wire format; omitted entirely when you want provider defaults.
Auto model resolution: leave the model on Auto and TabRunner runs the newest model the endpoint lists, showing you which one that is; pin a model and effort per task from the panel header.
Remembers across runs: your standing instructions (AGENTS.md) and the agent's own notes
(MEMORY.md) load into every run; a ## site: section loads only when a task starts on that
site. Editable on the options page, off with one toggle.
Skills: saved instructions the agent loads when a
task matches: /skill new distills a conversation you just steered into one, /skill <name>
runs one on demand, and skills tied to a site surface only there. Import one from a URL,
GitHub owner/repo, or pasted markdown (SKILL.md-compatible); export as markdown to share.
Runs on a timer: "every weekday at 9am, summarize my inbox", "at 3pm, check the delivery". Ask for it in the panel and approving the plan is the consent; the run fires later in a tab of its own and notifies you when it lands. The agent can pace itself the same way: schedule a follow-up, keep checking, cancel when the goal is met. Review and cancel them in Settings.
Two-way MCP: Claude Code, Claude Desktop, or any Model Context Protocol client can hand
TabRunner a task and follow it to the answer, using the same browser and the same logins,
labelled in your history with which client did it. The client says what it wants done and
TabRunner's model does the driving, or the client drives directly when the job is small and exact.
TabRunner dials out too: connect remote MCP servers and their tools join every run behind the
plan gate (/mcp reports what's connected), and run events can POST to your own webhook. See
docs/mcp.md. In Claude Code, the plugin sets it up in one line:
claude plugin install tabrunner --marketplace tabrunner/tabrunner
Speaks your language, matches your theme: English, Português (Brasil), and Español; light, dark, or follow the OS.
Your data stays local: provider configs and history live in chrome.storage. There is no
TabRunner server. See PRIVACY.md for the full picture, and
TERMS.md for the terms of use.
bun install
bun run build
Then chrome://extensions → Developer mode → Load unpacked → select
dist/chrome-mv3. Click the TabRunner toolbar icon to open the side panel, add a provider
(options page), and describe a task.
Works on Chrome, Brave, Edge, Arc, Opera, and Vivaldi. Chromium-only by design: Firefox has no
chrome.debugger equivalent (Bugzilla 1316741),
which trusted input depends on.
side panel (React) ──Port──▶ background service worker ──▶ provider API (SSE stream)
│
├─▶ snapshot: accessibility tree via chrome.scripting
└─▶ actions: trusted input via chrome.debugger (CDP)
navigate, click, type, scroll, snapshot,
screenshot, done) execute against the real tab.done or you hit Stop.
One task runs at a time; the next submissions wait in a serial queue.An open Port keeps the MV3 service worker alive while the panel is open; with the panel closed (after a background submit it closes itself) a periodic alarm holds it through long silences. Durable state is written to storage as it changes, and tasks keep working with the panel closed. Stop them from the Tasks band or by closing the driven tab.
bun run dev # watch mode with hot reload
bun run test # vitest
bun run lint # eslint
bun run compile # tsc --noEmit (extension + daemon)
bun run deadcode # knip
bun run icons # regenerate extension icons + OG card from src/shared/logo.ts
bun run bridge # run the MCP daemon by hand
bun run bridge:check # end-to-end check of the MCP bridge, no Chrome needed
Domain-first layout under src/modules/ (agent, browser, providers, conversation), UI primitives
in src/components/ (Base UI + Tailwind 4). See AGENTS.md for the full architecture
and conventions.
Next up: domain policy (tell it where it may never go), skill waypoints (a skill that
remembers the page's anchors, not just prose), and file upload. A Firefox version stays blocked because chrome.debugger has no
equivalent there, so it's a rewrite of the driver rather than a port.
Full reasoning, open questions and what we've ruled out: docs/roadmap.md.
MIT © Gus
© 2026 MCP Directory.
Give browser tasks to TabRunner, an agent in your own Chrome that uses your logins.
{ "mcpServers": { "app.tabrunner-tabrunner": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "TABRUNNER_BRIDGE_PORT": "<value>" } } }}Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
The publisher lists these environment variables: TABRUNNER_BRIDGE_PORT.
TabRunner runs locally over stdio.
Last checked 2026-11-14. Give browser tasks to TabRunner, an agent in your own Chrome that uses your logins.