Best MCP Servers for Meta Muse Code in 2026

Meta shipped its first coding agent, Muse Code, in beta on August 5, 2026, and confirmed MCP support from day one — despite some launch-week coverage claiming otherwise. Seven weeks later, none of the four vendors this series compares has published a dedicated Muse Code integration guide. So this post is built differently from the rest of the series: instead of comparing four vendors' own published guides for a client, it adapts each vendor's own real, already-documented MCP server into Muse Code's schema, sourced directly from Meta's config format. We'll flag this for an update the moment an official vendor guide ships.

Muse Code's MCP config

Muse Code reads its MCP configuration from ~/.config/muse/settings.json. The file must declare "schema_version": 1 at the top level — omit it and every muse command fails at startup with a malformed settings file error.

Server entries live under mcp_servers, in one of two transports:

• stdio (local): { "transport": "stdio", "command": "...", "args": [...], "env": {...} } — Muse Code launches it as a child process.
• streamable_http (remote): { "transport": "streamable_http", "url": "...", "headers": {...} } — a hosted endpoint, nothing to run locally.

Both accept enabled and mode: mode defaults to "required", which aborts the whole muse run if that server is unreachable; set it to "optional" if you'd rather the agent continue (with a warning) when the connection is down.

A minimal remote entry, straight from Meta's documented shape:

{
  "schema_version": 1,
  "mcp_servers": {
    "example": {
      "transport": "streamable_http",
      "url": "https://mcp.example.com/mcp"
    }
  }
}

What to evaluate, in Muse Code specifically

• MCP tools are not sandboxed. Muse Code's shell-command sandbox (Seatbelt/bubblewrap, on by default) has nothing to do with what a connected MCP server can do — that traffic runs as an ordinary child process or a direct network connection outside the sandbox entirely. Whatever guardrails you want on a vendor's tool calls have to live on that vendor's side of the connection.
• Sub-agents inherit every connection. Muse Code fans a big job out to up to 16 parallel child agents by default, each in its own git worktree for file isolation — but MCP connections are session-level, so every child holds the same external access the parent session holds.
• stdio versus streamable_http: a stdio entry starts a local process per session; a streamable_http entry is one URL and nothing running locally, which matters more in a sandboxed, approval-heavy harness than in most other clients in this series.
• Generic crawl (any URL → markdown) versus structured platform data (named sites → JSON). A large-repo coding session tends to want both: read a spec page, then look up a fact on a known site.
• No vendor has published Muse-Code-specific guidance yet — check each vendor's docs directly before relying on the adapted config below, since Muse Code is a few weeks old and details are still shifting.

The contenders

Firecrawl MCP: the same hosted endpoint it documents elsewhere

Firecrawl doesn't yet publish a Muse Code quickstart, but its hosted MCP server is the same URL across every client it does document (OpenCode, Codex CLI, Cursor): https://mcp.firecrawl.dev/v2/mcp. Adapted into Muse Code's streamable_http shape:

{
  "schema_version": 1,
  "mcp_servers": {
    "firecrawl": {
      "transport": "streamable_http",
      "url": "https://mcp.firecrawl.dev/v2/mcp",
      "mode": "optional"
    }
  }
}

Keyless access exposes search, scrape, and parse (rate-limited, shared with your public IP); an API key or OAuth sign-in unlocks the broader tool set including crawl. Choose it for arbitrary-URL reading with no setup, and note the "mode": "optional" above — it keeps a muse session running if the shared keyless endpoint is temporarily rate-limited, rather than aborting the whole run.

Bright Data: a local process, same install as everywhere else

Bright Data publishes @brightdata/mcp as a standard npm package, documented for OpenCode, Warp, VS Code, and others via the same npx @brightdata/mcp command and API_TOKEN/PRO_MODE environment variables. Adapted into Muse Code's stdio shape:

{
  "schema_version": 1,
  "mcp_servers": {
    "brightdata": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@brightdata/mcp"],
      "env": {
        "API_TOKEN": "<YOUR_BRIGHT_DATA_API_KEY>",
        "PRO_MODE": "true"
      }
    }
  }
}

Without PRO_MODE, only two tools are exposed for free (scrape_as_markdown, search_engine); dozens of named targets — LinkedIn, Amazon, Yahoo Finance, TikTok, and more — plus proxy and browser-automation infrastructure only show up once PRO_MODE is set to "true", at Pro-mode pricing. Remember the sandbox gap above: this process runs outside Muse Code's shell sandbox regardless of transport. Choose it when the target is a hard, named site and anti-bot reliability at scale is the actual constraint.

Zyte: not an option for any client yet, Muse Code included

Zyte's two products — the Claude Code plugin and the GitHub-Copilot-specific Web Scraping Copilot VS Code extension — are each locked to one client and don't expose a generic MCP server at all. There's nothing to adapt into Muse Code's schema. This is the same gap as every other post in this series, not something specific to Muse Code's newness.

Crawlora: the same remote entry as every other client

Crawlora's MCP server is streamable_http-shaped everywhere it connects, so the Muse Code entry is a straight port of the same URL and header used for OpenCode, Warp, and the rest of this series:

{
  "schema_version": 1,
  "mcp_servers": {
    "crawlora": {
      "transport": "streamable_http",
      "url": "https://mcp.crawlora.net/mcp",
      "headers": { "Authorization": "Bearer YOUR_CRAWLORA_API_KEY" }
    }
  }
}

No local process, no sandbox interaction to reason about. The current catalog covers 2,021 MCP tools across 236 platform groups — search, maps, e-commerce, social, finance, travel, jobs, media, app stores, and reviews — returning normalized JSON, billed only on success, 2,000 free credits a month, no card. Choose it when Muse Code needs a record from a named platform (a price, a ranking, a listing, a filing) rather than a page to read.

How to choose, by job

• Want to read a spec into context before you've created any account at all? Firecrawl MCP's keyless default, with "mode": "optional" so a rate limit doesn't abort the whole run.
• Chasing data off a genuinely hard, named site, at real volume? Turn on Bright Data's PRO_MODE and live with the local process it requires.
• Need a normalized JSON record — a price, a ranking, a filing — from a named platform, and nothing running locally? Crawlora MCP fits that shape.
• Looking for a vendor's own tested Muse Code setup rather than an adapted one? None exists as of this writing — recheck each vendor's docs before locking this into CI.
• Planning a session where a sub-agent might fan out mid-run? It inherits every MCP connection the parent holds, unsandboxed, so scope credentials narrowly before a big multi-agent job.

Add structured web data to Muse Code

2,021 tools across 236 platform groups, one API key, billed only on success. 2,000 free credits a month, no card.

Set up Crawlora MCPBrowse the API catalog

Sources

Related reading

• Best MCP Servers for OpenCode in 2026 · Best MCP Servers for OpenAI Codex in 2026 — the same comparison, two more terminal-first clients.
• Best MCP Servers for Warp in 2026 — another terminal agent, same four vendors.
• Crawlora vs Firecrawl · Crawlora vs Bright Data · Crawlora vs Zyte.
• Give your AI agent live web data with MCP — how MCP works and how to connect in three minutes.