Tabrix

Turn real Chrome into an MCP-native AI execution layer.

Tabrix is a Chrome extension + local native server that lets any MCP client operate your daily browser session safely and efficiently, with your existing logins, cookies, and browsing context.

Built for the new generation of AI assistants that need to work in the browser users already trust every day.

• Reuse the real logged-in Chrome session instead of rebuilding a fresh browser runtime

• Connect through both Streamable HTTP and stdio, depending on the MCP host

• Stay local-first, while still supporting token-protected remote access over LAN

• Recover on demand: when a real browser request arrives and Chrome/bridge is not ready, Tabrix attempts auto-launch/reconnect and continues the original request when possible

Documentation: English | Chinese

Why Tabrix

Tabrix does not spin up "yet another browser." It upgrades your current Chrome into an AI-executable runtime.

• Real session, ready instantly: keep your existing logins, cookies, extensions, and tabs without rebuilding environments

• More stable and safer runtime path: extension + Native Messaging, without keeping --remote-debugging-port exposed

• Remote-ready access: built-in Bearer auth, token management, and token TTL controls for LAN exposure

• Broad client compatibility: works with Claude Desktop, Cursor, Claude Code CLI, Codex CLI, Cherry Studio, Windsurf, Dify, and similar MCP clients

• Local-first architecture: browser state and data stay on your machine by default for stronger privacy and compliance control

• Production operations built in: tabrix status / doctor --fix / smoke / report

Why Real Session Matters

Many browser automation tools start from a fresh runtime. Tabrix starts from the browser your team already uses.

• No login rebuild loop: keep the authenticated tabs, cookies, and extensions you already rely on

• Better fit for real back-office work: operate CMS, ticketing, CRM, support, and ops systems inside the actual browser profile

• Better fit for AI assistants: let Codex, Claude Desktop, Cursor, Cline, and similar clients call into a browser that already has useful context

Why Not Another Browser

If your workflow depends on a real logged-in browser, the difference is immediate:

Scenario Value

• More reliable compliant collection: real-session reuse reduces failures from fresh environments and blank fingerprints

• Higher back-office automation efficiency: automate logged-in CMS, ticketing, and operations workflows with fewer repetitive clicks

• Better team collaboration: secure LAN remote access lets multiple MCP clients call the same browser capability

• Faster regression troubleshooting: doctor --fix and smoke quickly pinpoint connection-path issues and shorten resolution time

• Lower-noise page understanding: structured reads, endpoint knowledge, and operation logs help assistants avoid unnecessary full-page reads when a safer compact path exists

What You Can Build

• Browser copilots for research, QA, operations, and support

• Cross-tab task automation with semantic context

• Safe web workflows with human-in-the-loop checkpoints

• MCP toolchains that combine browser, filesystem, and APIs

• Knowledge-assisted browser readers that choose between DOM summaries, endpoint-shaped data, and fallback paths without exposing raw private payloads

First 5 Minutes

One realistic first-success path:

1. Keep your normal Chrome profile open with the pages you already use

2. Install @tabrix/tabrix, load the extension, and click Connect

3. Add Tabrix to Codex, Claude Desktop, Cursor, or another MCP client

4. Ask the assistant to inspect the current page, list interactive elements, or navigate the next step

5. Reuse the same browser session for follow-up clicks, fills, screenshots, and checks

The first win should feel like "my assistant can finally use my real browser," not "I set up another automation sandbox."

Quick Start (3 Minutes)

1) Install CLI

npm install -g @tabrix/tabrix@latest
# or
pnpm install -g @tabrix/tabrix@latest

Tabrix installation and browser readiness are now treated separately:

• CLI install can succeed even if Chrome/Chromium is not installed yet

• Browser automation becomes ready after tabrix register, tabrix setup, or tabrix doctor --fix detects a supported browser executable

• The detected browser path is persisted and reused for later auto-launch

If pnpm does not run postinstall scripts:

tabrix register

2) Install Chrome Extension

Download from Releases, then load the tabrix-extension-vX.Y.Z.zip unpacked folder at chrome://extensions. After loading, open the extension popup and click Connect once.

3) Verify Environment

Check runtime status:

tabrix status

Run automatic recovery:

tabrix doctor --fix

What to look for:

• tabrix doctor --json now includes browser.executable

• If Chrome/Chromium is ready, Tabrix persists the resolved path for later browser auto-launch

• If no supported browser is detected, Tabrix stays installed but reports browser automation as not ready

4) Connect from MCP Client

Tabrix currently supports both MCP mainline transports:

• Streamable HTTP: default local and remote path

• stdio: for CLI hosts or clients that only support stdio

Streamable HTTP

{
  "mcpServers": {
    "tabrix": {
      "type": "streamableHttp",
      "url": "http://127.0.0.1:12306/mcp"
    }
  }
}

stdio

{
  "mcpServers": {
    "tabrix": {
      "command": "tabrix-stdio"
    }
  }
}

Configs for popular MCP clients (Claude Desktop, Cursor, Claude Code CLI, Codex CLI, Cherry Studio, Windsurf, Dify, etc.): CLI and MCP Configuration

🌐 Remote Control

Typical remote MCP config:

{
  "mcpServers": {
    "tabrix": {
      "url": "http://<LAN_IP>:12306/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_TABRIX_TOKEN>"
      }
    }
  }
}

Turn on Remote Access in extension popup and expose:

• http://<LAN_IP>:12306/mcp

Enable In 30 Seconds

1. Open extension popup -> switch to Remote -> enable Remote Access

2. Open Token Management and copy current token (or click refresh)

3. Paste LAN config to your MCP client and start remote automation

Security Default

• Remote mode must use bearer-token authentication

• Extension Token Management page supports view/copy/refresh

• Token validity is configurable:

  • Set custom days in Token Management -> Refresh Token

  • Or set MCP_AUTH_TOKEN_TTL (0 means never expire)

• If MCP_AUTH_TOKEN env is set, env token always has priority

Core Capabilities

• Browser navigation and tab/window control

• Page interaction (click, fill, keyboard, upload)

• Rich extraction (web content, interactive elements, console)

• Network capture and request replay helpers

• Knowledge-assisted data-source routing for compact read paths when an observed or seeded endpoint is safe to use

• Operation Memory logs for task/session/step evidence, including route, fallback, timing, token-saving, and tab-hygiene metadata

• Screenshot, GIF recording, performance trace analysis

• Bookmarks/history operations and JavaScript execution

Knowledge, Memory, and Fallback Boundaries

Tabrix is moving toward a policy-routed MKEP model: Memory records what happened, Knowledge records site/page/endpoint capability, Experience will reuse verified successful paths, and Policy decides which data source to use.

Current public boundaries:

• Endpoint Knowledge records endpoint patterns, semantic hints, confidence, and shape summaries; it does not store API response bodies, cookies, Authorization values, or raw request bodies.

• Seed adapters for known public scenarios may still be used as transition paths. Generic observed-endpoint reuse across arbitrary sites is a roadmap direction, not a universal product guarantee.

• When an endpoint is unavailable, unsafe, or semantically uncertain, Tabrix should fall back to scoped DOM reading instead of treating the API path as authoritative.

• Operation Memory logs are factual evidence for diagnostics and reports. They are not automatic Experience publishing or user-data caching.

CLI Commands

Installed executables:

tabrix
tabrix-stdio

First-time guided setup:

tabrix setup

Register Native Messaging host:

tabrix register

Fix local execution permissions:

tabrix fix-permissions

Update MCP port:

tabrix update-port <port>

Check current runtime status:

tabrix status

Show current MCP client config:

tabrix config

Diagnose issues (--fix applies common auto-fixes):

tabrix doctor

tabrix doctor --fix

Inspect active MCP clients and recent sessions:

tabrix clients

Run browser-path smoke test:

tabrix smoke

Need an isolated browser window for smoke:

tabrix smoke --separate-window

Run stdio-only smoke test:

tabrix stdio-smoke

Export diagnostics report (copy to clipboard):

tabrix report --copy

Daemon lifecycle commands:

tabrix daemon start

tabrix daemon status

tabrix daemon stop

Full command reference: CLI and MCP Configuration

Full tool list: TOOLS API

Public Roadmap

Tabrix is aiming to become a top-tier browser automation execution layer for AI assistants. The roadmap stays public, but we keep it grounded in what the current codebase can realistically absorb next.

• Now: make real-Chrome MCP access more reliable across Streamable HTTP, stdio, reconnects, diagnostics, and compact structured reading

• Next: improve observed Endpoint Knowledge, operation-log explainability, Markdown/document reading surfaces, and stronger real-browser E2E coverage

• Later: add reviewed Experience reuse, richer replay artifacts, and safer team collaboration workflows

Read the full public roadmap: ROADMAP.md

Contributing

Contributions are welcome from both first-time contributors and maintainers.

• Start here: Contributing Guide

• Good first issues: Start with beginner-friendly tasks

• Community discussions: GitHub Discussions

• Architecture: ARCHITECTURE.md

• Security model: SECURITY.md

• Error codes: ERROR_CODES.md

High-impact contribution areas

• Reliability and reconnect stability

• Tool schema consistency and DX

• Cross-platform install and packaging quality

• Benchmarking and regression test coverage

Community First (Current Phase)

Our current priority is community growth and project reputation:

• Lower onboarding friction for new users and contributors

• Keep release quality high with transparent changelogs and issue triage

• Improve reliability across platforms and MCP clients

• Build an open roadmap with active maintainer feedback

Long-term, once adoption and ecosystem maturity are in place, we may explore sustainable paths that remain compatible with the open-source community.

Project Origin and Credits

Tabrix is a community-driven continuation of hangwin/mcp-chrome.

We appreciate the original maintainers and contributors who created the foundation. Tabrix exists to provide sustained maintenance, clearer roadmap execution, and faster iteration.

Documentation Index

For Users

• Quickstart

• CLI and MCP Configuration

• Troubleshooting

• Changelog

• GitHub Releases

For Developers

• Docs Index

• Contributing

• Architecture

• Project Structure Guide

• Product Surface Matrix

• Compatibility Matrix

• Platform Support

• Tools API

• Testing Guide

• Use Cases

• Public Roadmap

• Release Process

• Why MCP on Chrome

• Error Codes

License

MIT. See LICENSE.