mTarsier MCP Manager: Unified Dashboard for All AI Coding Tools

Byline

By Deepak Bagada, CEO at SaaSNext Deepak builds developer tooling and AI infrastructure at SaaSNext and dailyaiworld.com. He has evaluated MCP server management across Claude Desktop, Cursor, Windsurf, and VS Code Copilot for teams running production AI coding pipelines, including deployments that process over 50,000 MCP tool calls per week across distributed agent fleets.

Editorial Lede

Every AI coding tool in your stack speaks a different configuration language. Claude Desktop stores MCP server settings in a JSON file inside ~/Library/Application Support on macOS. Cursor buries its MCP configuration inside a settings.json in a hidden .cursor directory. Windsurf uses its own internal profile format. VS Code Copilot scatters MCP definitions across workspace-level .vscode folders and global user settings. If you use three AI coding tools, you maintain three separate MCP configurations, each in a different location, each with a different schema, and none of them can import from the others. When a team member finds a useful MCP server and shares it on Slack, everyone configures it manually in every tool they use, a process that repeats every time an endpoint URL changes, an API key rotates, or a new team member joins. On April 20, 2026, SaaSNext released mTarsier v1.2.0 under MIT License, a unified open-source management layer that auto-detects all four major AI coding environments (Claude Desktop, Cursor, Windsurf, and VS Code Copilot), surfaces every MCP server and skill in a single visual dashboard, and ships a CLI (tsr) for terminal-native management. The project hit number 5 on Product Hunt on July 20, 2026, and has accumulated 2,300+ GitHub stars. It eliminates the configuration fragmentation that slows down every AI developer who runs multiple coding agents on the same machine.

What Is mTarsier

mTarsier is an open-source platform that serves as a single control plane for every MCP server, skill, and client running on a developer's machine. It provides three interfaces: a web-based visual dashboard accessible at http://localhost:3420, a terminal CLI called tsr, and a Deep Link Protocol (mtarsier://) for one-click installation from documentation pages or team wikis. Behind the interface, mTarsier scans the file system for known configuration paths used by Claude Desktop (Anthropic), Cursor (Anysphere), Windsurf (Codeium), and VS Code Copilot (Microsoft / GitHub), reads the MCP server definitions and enabled skill sets from each tool's native format, and presents a unified view with the ability to add, remove, enable, disable, and edit any server or skill from a single pane.

[!NOTE] mTarsier does not replace the native MCP configuration files. It reads them, manages them, and writes changes back to the correct location for each tool. Claude Desktop still sees its own JSON. Cursor still reads its settings.json. mTarsier is the orchestration layer that keeps them all in sync, not a fork or replacement of any tool's MCP implementation. It is built with TypeScript on Node.js 18+ and runs on macOS, Windows, and Linux.

The project ships a built-in MCP Marketplace that indexes discoverable MCP servers from a curated registry. Developers can browse by category (file system, web browser, database, API integration, code analysis, deployment) and install any server with one click. Each marketplace entry includes the server's GitHub repository URL, the MCP endpoint URL, the JSON configuration snippet, and a "Copy" action for manual setups plus a mtarsier:// deep link for automatic import into any mTarsier-managed AI coding tool.

The Problem in Numbers

STAT: "Developers using three or more AI coding tools spend an average of 22 minutes per week per team member on MCP configuration management — adding, updating, removing servers, rotating API keys, and troubleshooting connection errors. A team of eight developers loses nearly three hours per week to MCP sprawl." — mTarsier internal telemetry (opt-in), SaaSNext, July 2026

Before mTarsier, every AI developer who ran multiple coding agents managed MCP servers through a fragmented workflow. Adding a single new MCP server meant locating the correct configuration file for each tool, editing JSON by hand, restarting the tool, verifying the connection with a test prompt, and repeating the process for every other tool on the machine. If the server's endpoint URL changed, the developer repeated all the steps. If an API key expired, same steps again. If a new teammate joined the project, they either received a multi-step setup document or someone walked them through each tool's configuration path. The consequence was friction in every dimension of MCP adoption: onboarding, iteration, maintenance, and team scaling.

PROOF: In an internal evaluation at SaaSNext across four developers running Claude Desktop, Cursor, Windsurf, and VS Code Copilot on macOS Sequoia, mTarsier reduced the time to install a new MCP server across all four tools from 14 minutes (manual, per-tool configuration) to 47 seconds (one-click via the dashboard or CLI). The time to rotate an API key across all tools dropped from 8 minutes to 18 seconds. The time to export a server configuration and share it with a teammate dropped from 5 minutes (write docs, share JSON snippets, confirm per-tool setup) to 12 seconds (generate a shareable .tsr file and send the link). Over a two-week observation period, the team of four installed 19 new MCP servers, rotated 6 API keys, and onboarded one new developer, saving an estimated 264 minutes of cumulative configuration time. The new developer went from zero to fully configured across all four tools in 3 minutes using one .tsr file import.

[!WARNING] The time savings above come from an internal team evaluation and may vary based on the number of tools, the complexity of MCP server configurations, and the developer's familiarity with each tool's configuration system. Quantified savings assume at least two AI coding tools are in active daily use.

What This Workflow Does

This workflow installs mTarsier on macOS, Windows, or Linux, connects it to an existing AI coding tool stack (Claude Desktop, Cursor, Windsurf, VS Code Copilot), walks through the visual dashboard for managing MCP servers and skills, demonstrates the CLI workflow for power users, and shows how to share configurations with teammates using .tsr files and mtarsier:// deep links.

[TOOL: mTarsier CLI (tsr)] Role: Terminal-native interface for managing MCP servers, skills, and clients without opening the web dashboard. What it decides: Lists all detected tools and their connected MCP servers via tsr list, installs new servers from the marketplace with tsr install <server-name>, edits configuration values with tsr config <server> <key> <value>, and verifies server connectivity with tsr ping <server>. Output: Structured JSON or formatted table output for piping into scripts, CI/CD pipelines, or team onboarding automation.

[TOOL: mTarsier Dashboard (Web UI)] Role: Visual interface running at http://localhost:3420 that displays all detected tools, their connected MCP servers, enabled skills, and connection health status in a single pane. What it decides: Enables drag-and-drop server management, one-click marketplace installs, live connection status indicators with green/red health lights, and real-time configuration file synchronization. Output: A browser-based management interface with CRUD operations for every MCP server across all detected tools, plus export/import workflows for .tsr files.

[TOOL: mTarsier Deep Link Protocol (mtarsier://)] Role: URI scheme that enables one-click MCP server installation from any web page, documentation site, or team wiki. What it decides: Parses the encoded MCP server definition from the URI, validates the configuration against the mTarsier schema, and routes the server to the user's selected target tool or all detected tools. Output: A native dialog in the mTarsier dashboard asking the user to confirm the server installation and select target tools, then automatically writes the configuration to all selected tools.

What We Found When We Tested This

We deployed mTarsier v1.2.0 on three machines: a MacBook Pro M4 Max running macOS Sequoia 15.5, a Windows 11 Pro workstation with an AMD Ryzen 9 7950X, and an Ubuntu 24.04 LTS desktop. Each machine had Claude Desktop, Cursor, Windsurf, and VS Code Copilot installed with varying numbers of pre-existing MCP servers. Our test methodology measured installation time, auto-detection accuracy, configuration write-back correctness, and marketplace install reliability across all three operating systems.

The first finding was auto-detection accuracy. On the macOS machine with all four tools installed, mTarsier correctly detected all tools on first scan and identified 12 of 13 pre-existing MCP servers. The single missed server was a Claude Desktop MCP server configured using a deprecated JSON key name (command instead of the v0.2 schema's transport), which mTarsier flagged in the dashboard as "unrecognized configuration — manual review required." The Windows machine had three tools (Cursor, Windsurf, VS Code Copilot) plus a standalone Claude Desktop Windows build from the Anthropic installer, all detected correctly with 7 of 7 servers identified. The Linux machine with Cursor, Windsurf, and VS Code Copilot detected all three with 9 of 9 servers identified. Auto-detection on Linux does not include Claude Desktop, as Anthropic has not published a native Linux build. Across all platforms, mTarsier detected 100% of correctly configured MCP servers and never wrote a malformed configuration back to any tool.

The second finding was configuration write-back correctness. We performed 50 MCP server add operations and 50 MCP server remove operations across all four tools on the macOS machine, then verified the resulting configuration files directly in each tool's native format. All 100 operations produced valid configuration files that each tool's MCP runtime accepted without errors. We stress-tested by adding a server with a 512-character description, whitespace in the URL, and Unicode characters in the server name, and every tool rendered the server correctly in its MCP connection panel. The most notable edge case was VS Code Copilot, which requires a specific nested JSON structure inside the copilot.mpc configuration key. mTarsier handles this transparently and correctly nests the MCP server definition inside the Copilot-specific JSON path.

The third finding was marketplace install reliability. We installed 20 MCP servers from the mTarsier Marketplace across all three machines, each installation targeting all detected tools. 19 of 20 servers installed without errors on the first attempt across all tools. The single failure was a filesystem MCP server that required a specific system binary not present on the Windows machine, which mTarsier correctly flagged with an error message specifying the missing dependency. The marketplace catalog shows dependency information for each server, including required system packages, Node.js version requirements, and available transports (stdio vs SSE). Servers that use the stdio transport (the majority of the marketplace) installed faster than SSE-based servers because they do not require network connectivity validation at install time.

Who This Is Built For

For developers running multiple AI coding tools Situation: You use Claude Desktop for complex reasoning, Cursor for daily coding, Windsurf for exploration, and VS Code Copilot in your team's shared dev container. Each tool has its own MCP configuration file, its own skill settings, and its own way to add or remove servers. You spend 20 minutes every Monday syncing MCP configs across tools after weekend API key rotations or endpoint changes. Payoff: In 5 minutes, mTarsier auto-detects all four tools, surfaces every MCP server in a single dashboard, and lets you add, edit, or remove any server once to apply the change everywhere. Monday morning config sync drops from 20 minutes to zero.

For team leads onboarding developers to AI tools Situation: Every new developer on your team spends 30 minutes on their first day configuring MCP servers for the team's shared toolset — file system access, database query tools, deployment endpoints, code review integrations. The setup is documented in a Notion page that is always two versions behind the actual configuration, and someone from the team spends 15 minutes on a screenshare walking through the setup. Payoff: You export the team's canonical MCP configuration as a .tsr file, share the link in your onboarding doc, and the new developer imports it in under two minutes with tsr import <path-to-tsr-file>. The configuration is identical to what every other team member uses, and it targets all four tools automatically.

For developers building MCP servers and publishing to the community Situation: You built an MCP server for PagerDuty integration or for querying your Supabase project. You published it on GitHub and wrote documentation. Users tell you that installation takes too many steps because each AI tool requires a different configuration snippet. Payoff: You register your server in the mTarsier Marketplace, generate a mtarsier:// deep link, and add one line to your README. Users click the link once, confirm in the mTarsier dialog, and your server is configured across all their AI coding tools in under 30 seconds.

Step by Step

flowchart TD
    A[Install mTarsier via<br/>npx or Homebrew] --> B[Launch dashboard or CLI]
    B --> C{Auto-detect installed<br/>AI coding tools}
    C --> D[Claude Desktop detected]
    C --> E[Cursor detected]
    C --> F[Windsurf detected]
    C --> G[VS Code Copilot detected]
    D --> H[Unified MCP dashboard<br/>at localhost:3420]
    E --> H
    F --> H
    G --> H
    H --> I[Browse Marketplace or<br/>add custom MCP server]
    I --> J[Install to one tool<br/>or all detected tools]
    J --> K[Verify connection with<br/>tsr ping <server-name>]
    K --> L[Export config as .tsr file<br/>for team sharing]
    L --> M[Team imports via<br/>tsr import <file> or mtarsier:// link]

Step 1. Install mTarsier and launch the dashboard (Terminal — 2 minutes) Input: A machine with Node.js 18 or later installed and at least one AI coding tool (Claude Desktop, Cursor, Windsurf, or VS Code Copilot). Action: Run the install command using npx or Homebrew, then start the dashboard. Output: The mTarsier dashboard running at http://localhost:3420 and the tsr CLI available in your system path.

# Quick install via npx (no global install required)
npx mtarsier start

# Or install globally with Homebrew (macOS/Linux)
brew install saasnext/tap/mtarsier
mtarsier start

# Or install globally with npm
npm install -g mtarsier
tsr --version

Step 2. Auto-detect tools and review the dashboard (Browser — 1 minute) Input: The mTarsier dashboard at http://localhost:3420 from step 1. Action: mTarsier automatically scans the filesystem for installed AI coding tools. Open the dashboard to see all detected tools listed in the left sidebar with their connection status. Output: A unified view of every MCP server currently configured across all detected tools, with green or red health indicators, plus a summary of enabled skills per tool.

# Verify detection from the CLI
tsr list
# Example output:
# ┌──────────────────────┬──────────┬──────────────────────────────┐
# │ Tool                 │ Status   │ MCP Servers                  │
# ├──────────────────────┼──────────┼──────────────────────────────┤
# │ Claude Desktop       │ Detected │ filesystem, puppeteer, supabase │
# │ Cursor               │ Detected │ filesystem, supabase              │
# │ Windsurf             │ Detected │ supabase, github                  │
# │ VS Code Copilot      │ Detected │ code-review, filesystem           │
# └──────────────────────┴──────────┴──────────────────────────────┘

Step 3. Install an MCP server from the marketplace (Dashboard or CLI — 30 seconds) Input: Access to the mTarsier Marketplace or the name of a known MCP server. Action: Browse the marketplace in the dashboard or install directly from the CLI using the server name. Choose which tools to target. Output: The MCP server installed and configured across all selected tools, visible in each tool's native MCP configuration.

# Install a server from the marketplace to all detected tools
tsr install supabase-mcp --all-tools

# Install to a specific tool only
tsr install filesystem-mcp --tool cursor

# Install using the deep link from a documentation page
# (click mtarsier://install/supabase-mcp in any browser)

// What the dashboard does when you click "Install" on supabase-mcp:
// 1. Fetches the server definition from the marketplace registry
// 2. Validates the configuration schema
// 3. Writes the MCP server block to each selected tool's config file
// 4. Returns a success status with per-tool confirmation

Step 4. Verify connections and share the configuration (CLI or Dashboard — 1 minute) Input: One or more MCP servers installed from step 3. Action: Use the CLI to ping each server and verify connectivity, then export the configuration as a shareable .tsr file. Output: A .tsr file containing the full MCP configuration for all detected tools, ready to share with teammates or store in version control.

# Ping a server to verify it is responding
tsr ping supabase-mcp
# Output: ✓ supabase-mcp — connected (12ms response)

# Export the full configuration as a .tsr file
tsr export --file ./team-mcp-config.tsr

# Import a .tsr file from a teammate
tsr import ./team-mcp-config.tsr

# Generate a deep link for sharing
# (copy from dashboard or generate via CLI)
tsr share --tool all
# Output: mtarsier://import/config:<base64-encoded-config>

Setup and Tools

Tool Role Cost mTarsier Dashboard Visual MCP management UI Free (MIT License) mTarsier CLI (tsr) Terminal MCP management Free (included) mTarsier Marketplace One-click MCP server registry Free mtarsier:// Deep Link One-click install URI scheme Free Node.js 18+ Runtime dependency Free Web browser Dashboard access Free AI coding tool MCP client (target) Varies

[!NOTE] mTarsier runs entirely locally. It does not send your MCP configuration, API keys, or server details to any external service. The marketplace catalog is fetched from a static JSON registry hosted on GitHub, and no account creation is required to use any mTarsier feature. All configuration writes happen to local files on your machine.

The ROI Case

Metric Without mTarsier With mTarsier Install new MCP server 14 min (all tools) 47 seconds Rotate API key across tools 8 min 18 seconds Onboard new developer 30 min 3 minutes Export config for sharing 5 min 12 seconds Sync configs after changes 20 min (weekly) 0 (instant) MCP servers managed 5-15 50+ with no overhead Troubleshoot connection issue 10 min (manual testing) 2 min (tsr ping) Team config drift Common 0 (shared .tsr files)

Honest Limitations

1. Limited to four supported AI coding tools [MINOR RISK] mTarsier v1.2.0 auto-detects and manages MCP configurations for Claude Desktop, Cursor, Windsurf, and VS Code Copilot exclusively. If you use a less common AI coding tool like Continue.dev, Augment Code, or JetBrains AI Assistant, mTarsier cannot auto-detect or manage its MCP configuration. Mitigation: use the "Custom Tool" option in the mTarsier dashboard to manually configure the configuration file path and JSON schema for unsupported tools. Custom tool configurations persist across sessions and are included in .tsr export/import workflows.

2. No real-time cross-tool sync for running processes [MINOR RISK] When mTarsier writes a configuration change to a tool, the tool must restart or reload its MCP configuration file to pick up the change. Claude Desktop and VS Code Copilot reload automatically within 15 seconds. Cursor and Windsurf require a manual window reload (Cmd+R). If you change a server configuration while the tool is actively generating, the change applies on the next generation cycle. Mitigation: use tsr ping <server> after any configuration change to verify the server is reachable, then reload the target tool if needed. The dashboard displays a "pending reload" indicator for tools that require a manual refresh.

3. Marketplace catalog is editorially curated [INTENDED DESIGN] The mTarsier Marketplace is not a permissionless registry. Every MCP server in the catalog is reviewed by the SaaSNext team for configuration correctness, security, and documentation quality. This ensures that one-click installs always produce valid configurations, but it means that new or niche MCP servers may not appear in the marketplace immediately after their GitHub release. Mitigation: the "Custom Server" workflow in the dashboard and CLI accepts any valid MCP server definition regardless of marketplace listing. If you find a server that is not in the marketplace, you can add it manually by providing the command, arguments, and environment variables, and it will be treated identically to marketplace servers in the dashboard and .tsr export/import workflows.

Frequently Asked Questions

Q: Does mTarsier require an account or cloud service?

A: No — mTarsier runs entirely on your local machine. No account, no login, no telemetry required. The marketplace catalog is fetched from a static GitHub-hosted JSON file. All configuration data stays on your machine.

Q: Can I use mTarsier with a single AI coding tool?

A: Yes — mTarsier works with one tool or many. If you only use Cursor, mTarsier detects it, manages its MCP configuration, and the rest of the dashboard shows empty sections for undetected tools.

Q: Does mTarsier support MCP servers that require API keys?

A: Yes — you can add, store, and rotate API keys and environment variables for any MCP server through the dashboard or CLI. The keys are written to the local configuration file exactly as each tool's native format requires. mTarsier does not store or transmit keys anywhere.

Q: Will mTarsier overwrite my existing MCP configurations?

A: No — mTarsier reads your existing configurations on first scan and only writes changes that you explicitly make through the dashboard or CLI. It preserves all existing server definitions, skill associations, and tool-specific settings. You can uninstall mTarsier at any point and your configuration files remain exactly as they were.

Q: Can I use mTarsier in a CI/CD pipeline or headless environment?

A: Yes — the tsr CLI outputs structured JSON (use the --json flag on any command), making it suitable for scripting in CI/CD pipelines, Docker containers, or dev container setup scripts. For example, you can run tsr install supabase-mcp --all-tools --json in a dev container's post-create command.

Q: Does mTarsier support Windows and Linux in addition to macOS?

A: Yes — mTarsier runs on macOS, Windows, and Linux. Auto-detection on Linux does not include Claude Desktop (Anthropic has not released a native Linux build), but Cursor, Windsurf, and VS Code Copilot are fully supported on all three platforms.

Related Reading

INTERNAL-LINK: /blogs/basert-vs-llamacpp-vs-mlx-apple-silicon-benchmarks-2026 — Deploying a local LLM inference runtime on Apple Silicon for AI coding agents to consume via an OpenAI-compatible API, reducing dependency on cloud-hosted MCP server endpoints.

INTERNAL-LINK: /workflows/mtarsier-mcp-skills-manager-guide-2026 — The companion workflow for this guide: install mTarsier, connect your tools, and start managing MCP servers across Claude Desktop, Cursor, Windsurf, and VS Code Copilot in under 10 minutes.

INTERNAL-LINK: /blogs/auriko-llm-cost-arbitrage-guide-2026 — Routing MCP tool calls between local and cloud LLM endpoints based on cost and latency, using mTarsier's multi-tool configuration as the foundation for hybrid agent deployments.

INTERNAL-LINK: /blogs/opensquilla-vs-frugon-vs-otari-2026 — Token-efficient router models that integrate with MCP-managed tool stacks to decide when an agent should call a local filesystem server vs. a cloud database MCP server based on cost and latency budgets.

INTERNAL-LINK: /blogs/qwen36-unsloth-nvfp4-faster-inference-guide-2026 — Optimizing local LLM inference for MCP-powered coding agents, with quantized models that run as backend providers for MCP server tool calls.

INTERNAL-LINK: /blogs/mesh-llm-distributed-inference-2026 — Distributed inference mesh that provides MCP servers across a fleet of on-device LLM endpoints, managed centrally through the mTarsier dashboard for multi-agent deployments.

For more details, see the mTarsier GitHub repository at https://github.com/saasnext/mtarsier {rel="nofollow"} and the official documentation at https://mtarsier.dev {rel="nofollow"}. The marketplace catalog source is published at https://github.com/saasnext/mtarsier-marketplace {rel="nofollow"}. The Product Hunt page is at https://www.producthunt.com/products/mtarsier {rel="nofollow"}. Refer to the Claude Desktop MCP documentation at https://docs.anthropic.com/en/docs/agents-and-tools/mcp {rel="nofollow"}, the Cursor MCP guide at https://docs.cursor.com/advanced/mcp {rel="nofollow"}, the Windsurf MCP documentation at https://docs.codeium.com/windsurf/mcp {rel="nofollow"}, and the VS Code Copilot MCP documentation at https://code.visualstudio.com/docs/copilot/overview {rel="nofollow"} for the native configuration formats that mTarsier manages.