← BLOG
· Arc0 team

Too many MCP servers? Replace a dozen with one endpoint

Why many MCP servers cost context and tool accuracy, how to measure it in Claude Code, Cursor and VS Code, and five fixes, from pruning to one endpoint.

You added one more MCP server, and now the agent reaches for the wrong tool. Or VS Code refuses the request outright. Too many MCP servers cost you twice: once in context, once in the model's choice of tool.

Each server adds tools to the list the model picks from. Your client may already keep most definitions out of context until they're needed, but the list of names still grows. Measure first, then prune, scope and check that your client defers tools. What's left can go behind one endpoint the agent searches.

Arc0 publishes this blog, and it's the worked example in fix 5. One endpoint doesn't cover local tools like the filesystem or a browser; more on those at the end.

Why a dozen MCP servers slow your agent down

MCP, the Model Context Protocol, is how an assistant like Claude Code or Cursor talks to outside apps. Each server offers tools, and each tool comes with a definition: a name, a description, and a schema for its arguments. A client that loads them all upfront sends every definition with every request, and Anthropic wrote in November 2025 that most MCP clients did exactly that.

Anthropic's own example, five servers for GitHub, Slack, Sentry, Grafana and Splunk, comes to 58 tools and about 55K tokens before the conversation starts. That figure, from its November 2025 post on advanced tool use, describes a client that loads everything.

That's the first cost, context. The second is choice, and it's the one that sticks around. Anthropic's docs say Claude's ability to pick the right tool degrades once you pass 30 to 50 available tools. Its engineering team names the usual failures as the wrong tool and the wrong parameters, with near-identical names like notification-send-user and notification-send-channel as the classic trap.

GitHub found the same in VS Code. Its Copilot team wrote in November 2025 that giving an agent too many tools can make it slower rather than smarter, and in offline tests the full built-in toolset lowered resolution rates by 2 to 5 points. Its answer was a core set of 13 tools.

The accuracy cost outlives the token cost, because a leaner context doesn't make the choice easier when several of your servers each ship a tool called search. You ask for last week's design notes, and the agent confidently searches your issue tracker instead.

Diagram contrasting a dozen MCP servers that each add their own similarly named tools to the list the model picks from, with one endpoint where the agent calls search_actions and gets back a short list of authorized actions

The limits clients put on tools

Some clients cap the tool count outright, and what you hit depends on the client. As of November 2026, VS Code documents a hard cap, Cursor documents none, and Claude Code leaves it to your context window.

ClientDocumented limitWhat you'll notice
VS Code (Copilot chat)128 tools enabled per chat requestThe error "Cannot have more than 128 tools per request"
CursorNo cap in current docs; 40 in 2025 forum reportsA user reported 80+ enabled tools with no warning in March 2026
Claude CodeNo fixed per-server capYour context window is the practical limit

VS Code's error comes with two ways out: deselect tools or whole servers in the tools picker, or turn on virtual tools with github.copilot.chat.virtualTools.threshold. For Cursor, we found no staff statement of a current number, so don't plan around one.

A hard cap is the friendliest form of this problem. At least it tells you.

Measure it in your client first

Before you delete anything, find out what your servers actually put in front of the model. Each client shows it differently, and one doesn't show tokens at all.

In Claude Code:

  1. Run /context for a live breakdown of your context window by category, with suggestions for what to trim.
  2. Look for MCP tools labelled (deferred) or (loaded on-demand). Those labels mean tool search is on and the full definitions aren't sitting in context.
  3. Run /mcp to see each connected server with its tool count beside it.
  4. Run /usage to see your token usage.

In VS Code, open the tools picker (Configure Tools) to see which tools are enabled for chat. In Cursor, we found no documented view of tool tokens, so use the server list in Customize as your count.

Count tools per server before you count tokens. If one server carries most of the list, that's your first candidate. It's often the one you installed for a single task last spring and haven't opened since.

Five fixes, cheapest first

Each rung takes a little more effort than the one before, so stop climbing when your list is short enough. The third may already be done for you.

1. Remove servers you don't use

The cheapest fix is the delete key, or its gentler cousin, the toggle.

  • Claude Code: run /mcp and disable the servers you don't use. Claude Code's cost guide also says to prefer a CLI such as gh, aws, gcloud or sentry-cli when one exists for the job.
  • Cursor: toggle servers off in Customize. In Cursor's words, "Disabled servers won't load or appear in chat."
  • VS Code: deselect single tools or whole MCP servers in the tools picker.

A server you never call still puts its names in front of the model, and the model doesn't know you've forgotten about it.

2. Scope servers per project

Most servers only make sense in some of your work, so install them where that work lives. Claude Code has three scopes:

  • Local, the default: this project only, private to you, stored in ~/.claude.json.
  • Project: written to .mcp.json and shared with your team through version control.
  • User: available in all your projects, also stored in ~/.claude.json.

Cursor splits it the same way: .cursor/mcp.json inside a project, ~/.cursor/mcp.json for everything.

The database server belongs to the repo that has the database. Your blog repo doesn't need those tools, and you'd rather it didn't have them.

3. Let the client load tools on demand

The biggest token fix may already be on. Clients now hold back full definitions and load them when the agent needs a tool, which is called tool search or deferred loading. Check it before you rebuild your setup.

Claude Code defers MCP tools by default: at session start, only tool names and server instructions load. The ENABLE_TOOL_SEARCH setting controls it.

  • Unset or true: all MCP tools are deferred (the default).
  • auto: tools load upfront while their definitions stay under 10% of the context window.
  • auto:N: the same, with your own percentage from 0 to 100.
  • false: everything loads upfront.

It needs Opus 4, Sonnet 4, Haiku 4.5 or a later model; earlier models load all tools upfront, and tool search isn't supported on Microsoft Foundry deployments hosted on Azure. If your /context shows no (deferred) labels, tool search is off or not applying: check the ENABLE_TOOL_SEARCH setting, your model, and whether you're on a Foundry deployment hosted on Azure.

Cursor shipped its version, dynamic context discovery, in January 2026: tool descriptions are synced to a folder and the agent gets only the names until it needs more. In Cursor's A/B test it cut total agent tokens by 46.9%, counted only on runs that called an MCP tool, with high variance depending on how many MCP servers were set up.

VS Code has virtual tools, which group related tools under one entry the agent can expand, a bit like a directory. You turn them on with the github.copilot.chat.virtualTools.threshold setting.

If you build your own agent on Claude's API, the same feature is defer_loading: true with the tool search tool, and Anthropic recommends it once you have 10 or more tools or more than 10K tokens of definitions. In its November 2025 example, tool search took context use from about 77K tokens to about 8.7K, an 85% reduction.

The best fix is often the one your client already shipped while you were reading forum threads about the problem.

4. Code mode

Code mode goes a step further: instead of calling tools one by one, the agent writes code against them. Anthropic's version, code execution with MCP (November 2025), has the agent discover tools by exploring a filesystem of tool files and opening only the ones it needs. In Anthropic's example, that took a task from 150,000 tokens to 2,000.

Bar chart of two separate Anthropic examples that are not comparable with each other: tool search from about 77K to about 8.7K tokens, and code execution with MCP from 150,000 to 2,000 tokens, each labelled with publisher and date

Cloudflare made the same argument in its Code Mode post of September 2025: "LLMs are better at writing code to call MCP, than at calling MCP directly." In February 2026 it shipped an MCP server for its own API with two tools, search() and execute(), which cost roughly 1,000 tokens for an API with over 2,500 endpoints.

Code mode suits people who build their own agent or their own server. If you're configuring Cursor, you can skip this rung with a clear conscience.

5. Put your app servers behind one endpoint

Rungs 3 and 4 share one idea: the agent searches for the tool it needs instead of holding all of them. One endpoint applies that idea to your SaaS apps. You swap the separate app servers for one remote URL, the agent sees a few meta tools, and it searches for the actions it's allowed to use.

Arc0 is our example, and our product. You add one URL to your client:

https://api.arc0.ai/mcp

It's bound to you: interactive clients sign in with OAuth, and others send an API key in the x-api-key header. Behind it, your agent sees five meta tools: search_actions, manage_connections, arc0_help, execute_action and get_execution. When it needs to act, it calls search_actions and gets a short list of the actions it's authorized to use, instead of loading every tool from every app (Arc0 MCP). Five tools sit comfortably under any cap in the table above.

In Claude Code, which already defers tools, the gain is a shorter authorized list, one Arc0 sign-in and, on Build, one rule set, not tokens.

The list draws on 1,484 apps across 30 categories (the catalog), with every action graded read, write or destructive (scopes and actions). Three things come with it:

  • Rules: on the free Build plan, policies set Allow, Ask or Deny per scope and per agent, with app rules like stripe:write~ask (policies).
  • Credentials: calls run server-side, credentials never reach the agent or the model (security), and every call lands in an audit log.
  • Every client: the same URL in Claude, ChatGPT, Cursor, Claude Code, Codex, VS Code and any remote-MCP client.

The Personal plan is free too, and its control is per-assistant scopes: one MCP URL, a 7-day audit log, and token export.

A dozen servers is also a dozen logins and no shared rule, and that's the cost nobody measures. You meet it the day a token needs rotating and you're working out which server's config holds it. With one endpoint you sign in to Arc0 once from each client and authorize each app once. The credentials then sit server-side, under one set of rules on the free Build plan. Yes, Arc0 is one more account, but you can start with a free personal URL.

Where one endpoint doesn't help

A remote endpoint reaches apps over the network, and some tools aren't apps. Filesystem access, browser automation and a local database run on your machine. Arc0 is a remote endpoint, so it doesn't replace them. Its Custom apps bring private remote MCP servers in under the same permissions and audit log, which helps with servers you host, not with tools on your laptop.

For local tools, keep the local server or your client's built-in tool, and scope it to the project that needs it, as in fix 2. Where a CLI does the job, Claude Code's guidance is to use the CLI.

No remote service should be able to open the file on your laptop, and you'd worry if one could. The goal is a short list, not one server at any cost.

Measure, prune, scope, then consolidate

In order: measure in your client, remove what you don't use, scope the rest per project, check that on-demand loading is on, and then put the app servers that remain behind one endpoint. Keep local tools local.

Our pick for that last step is Arc0, for the reasons above, with the bias of a company writing about its own product. To try it, get a free personal MCP URL from Arc0 for individuals, connect one app you use every day, and add the URL with the setup guide for Claude, Cursor, or any other client.

Then open /mcp or your server list again and count what's left. Shorter is the whole point.

Get started

One plug. Every app. Any agent.

Your users connect their apps once, under your brand. Your agent, or Claude, ChatGPT and Cursor, acts through one MCP endpoint, with every action on the record.