# Tabrix > MCP-native Chrome automation layer for AI assistants. Open source, community-driven, and production-focused - **Type:** MCP server - **Install:** `agentstack add mcp-guodaxia103-tabrix` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [guodaxia103](https://agentstack.voostack.com/s/guodaxia103) - **Installs:** 0 - **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [guodaxia103](https://github.com/guodaxia103) - **Source:** https://github.com/guodaxia103/tabrix ## Install ```sh agentstack add mcp-guodaxia103-tabrix ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Tabrix [](https://github.com/guodaxia103/tabrix/releases) [](https://www.npmjs.com/package/@tabrix/tabrix) [](https://www.npmjs.com/package/@tabrix/tabrix) [](https://opensource.org/licenses/MIT) [](https://www.typescriptlang.org/) 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](README.md) | [Chinese](README_zh.md) --- ## 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: | Fresh browser runtime | Tabrix | | ------------------------------------------------- | --------------------------------------------------------------------- | | Rebuild login and cookies again | Reuse the browser session you already have | | Start from blank tabs and blank context | Start from real tabs, extensions, and live operator context | | Often optimized for isolated automation runs | Optimized for AI assistants working with a user's daily browser | | Browser control alone is not enough for ops trust | Add `status`, `doctor`, `smoke`, and recovery around the control path | ### 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 ```bash 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: ```bash tabrix register ``` ### 2) Install Chrome Extension Download from [Releases](https://github.com/guodaxia103/tabrix/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: ```bash tabrix status ``` Run automatic recovery: ```bash 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 ```json { "mcpServers": { "tabrix": { "type": "streamableHttp", "url": "http://127.0.0.1:12306/mcp" } } } ``` #### stdio ```json { "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](docs/CLI_AND_MCP.md) ## 🌐 Remote Control Typical remote MCP config: ```json { "mcpServers": { "tabrix": { "url": "http://:12306/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Turn on `Remote Access` in extension popup and expose: - `http://: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: ```bash tabrix tabrix-stdio ``` First-time guided setup: ```bash tabrix setup ``` Register Native Messaging host: ```bash tabrix register ``` Fix local execution permissions: ```bash tabrix fix-permissions ``` Update MCP port: ```bash tabrix update-port ``` Check current runtime status: ```bash tabrix status ``` Show current MCP client config: ```bash tabrix config ``` Diagnose issues (`--fix` applies common auto-fixes): ```bash tabrix doctor ``` ```bash tabrix doctor --fix ``` Inspect active MCP clients and recent sessions: ```bash tabrix clients ``` Run browser-path smoke test: ```bash tabrix smoke ``` Need an isolated browser window for smoke: ```bash tabrix smoke --separate-window ``` Run stdio-only smoke test: ```bash tabrix stdio-smoke ``` Export diagnostics report (copy to clipboard): ```bash tabrix report --copy ``` Daemon lifecycle commands: ```bash tabrix daemon start ``` ```bash tabrix daemon status ``` ```bash tabrix daemon stop ``` Full command reference: [CLI and MCP Configuration](docs/CLI_AND_MCP.md) Full tool list: [TOOLS API](docs/TOOLS.md) ## 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](docs/ROADMAP.md) ## Contributing Contributions are welcome from both first-time contributors and maintainers. - Start here: [Contributing Guide](CONTRIBUTING.md) - Good first issues: [Start with beginner-friendly tasks](https://github.com/guodaxia103/tabrix/issues?q=is%3Aissue%20is%3Aopen%20label%3A%22good%20first%20issue%22) - Community discussions: [GitHub Discussions](https://github.com/guodaxia103/tabrix/discussions) - Architecture: [ARCHITECTURE.md](docs/ARCHITECTURE.md) - Security model: [SECURITY.md](SECURITY.md) - Error codes: [ERROR_CODES.md](docs/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`](https://github.com/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](docs/QUICKSTART.md) - [CLI and MCP Configuration](docs/CLI_AND_MCP.md) - [Troubleshooting](docs/TROUBLESHOOTING.md) - [Changelog](CHANGELOG.md) - [GitHub Releases](https://github.com/guodaxia103/tabrix/releases) ### For Developers - [Docs Index](docs/README.md) - [Contributing](CONTRIBUTING.md) - [Architecture](docs/ARCHITECTURE.md) - [Project Structure Guide](docs/PROJECT_STRUCTURE.md) - [Product Surface Matrix](docs/PRODUCT_SURFACE_MATRIX.md) - [Compatibility Matrix](docs/COMPATIBILITY_MATRIX.md) - [Platform Support](docs/PLATFORM_SUPPORT.md) - [Tools API](docs/TOOLS.md) - [Testing Guide](docs/TESTING.md) - [Use Cases](docs/USE_CASES.md) - [Public Roadmap](docs/ROADMAP.md) - [Release Process](docs/RELEASE_PROCESS.md) - [Why MCP on Chrome](docs/WHY_MCP_CHROME.md) - [Error Codes](docs/ERROR_CODES.md) ## License MIT. See [LICENSE](LICENSE). ## Source & license This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [guodaxia103](https://github.com/guodaxia103) - **Source:** [guodaxia103/tabrix](https://github.com/guodaxia103/tabrix) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/mcp-guodaxia103-tabrix - Seller: https://agentstack.voostack.com/s/guodaxia103 - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.