Blog

MCP tool router vs fixed tools: which one to give your agent

T. Krause ·

Give an agent fixed tools when you know which apps and tasks it needs. The list stays short, every action takes one call, and you can read exactly what the agent is allowed to do. Give it a router when it may need any app, or when the full list would be too long to send. A router is a small set of tools for finding, describing and running the others. Its list stays the same size however many apps sit behind it, and each action costs a few extra calls.

This guide shows what each option sends to the model, measured on Prompt TM's own catalogue. It then walks through one router call and covers how to limit a router.

Why the length of the tool list matters

An MCP client finds a server's tools with a tools/list request. In the MCP specification, each tool in the answer has a name, a description and a JSON Schema for its input, plus optional annotations.

What the client does with that list is up to the client. Anthropic's engineering post Code execution with MCP (4 November 2025) says "most MCP clients load all tool definitions upfront directly into context". For agents connected to thousands of tools, it says, that means hundreds of thousands of tokens before the model reads the request. One remedy it names is a search_tools tool that finds the relevant definitions when they're needed. That's what a router does.

What each option sends

We measured the tools/list answer that Prompt TM's MCP endpoint builds, as JSON characters, on 12 November 2026. The numbers come from our catalogue on that day and will change as toolkits grow. How many tokens a character count becomes depends on the model, so we haven't converted them.

MCP serverTools listedCharacters
Fixed: GitHub only3124,898
Fixed: GitHub, Slack and Notion5943,856
Fixed: every toolkit in the catalogue935863,689
Router, any number of toolkits64,339

A fixed server with one app is already more than five times the router's list. With three apps it's ten times. A fixed server with every toolkit is a list few clients would want to load, while the router's list doesn't change.

Fixed tools on Prompt TM

A custom MCP server lists the tools of the toolkits you pick. In the dashboard, open MCP servers → New, choose Custom, tick the apps and, under Only some tools, select the tools the agent should see. The server's tools/list then returns exactly those tools, with their full input schemas, so the model can call any of them in one step.

The GitHub access guide sets one up from scratch.

Fixed tools suit an agent with a narrow job. A release bot needs a handful of GitHub tools. A support assistant needs one help desk. You can read the whole list, and a model never calls a tool you didn't tick.

How a router call works

A router server lists six meta tools instead of the apps' tools:

ToolWhat it does
PTM_SEARCH_TOOLSFinds tools for a task described in plain words, and says which apps the user has connected
PTM_GET_TOOL_SCHEMASReturns the input schemas of the named tools
PTM_MULTI_EXECUTE_TOOLRuns up to 20 tool calls in parallel, one result each
PTM_MANAGE_CONNECTIONSLists, starts or removes the user's connections; starting one returns a connect link
PTM_WAIT_FOR_CONNECTIONWaits up to 50 seconds for the user to finish connecting
PTM_REMOTE_WORKBENCHRuns a short Python or Node program in a sandbox with no network access, on data the agent passes in

Take an invented request: "Open a GitHub issue about the failed deploy." On a router, the agent works through it in this order:

  1. It calls PTM_SEARCH_TOOLS with "open an issue on GitHub". The answer lists matching tools, such as GITHUB_CREATE_ISSUE, and says whether the user has GitHub connected.
  2. If GitHub isn't connected, it calls PTM_MANAGE_CONNECTIONS with the action connect, shows the user the link, and calls PTM_WAIT_FOR_CONNECTION while they sign in.
  3. It calls PTM_GET_TOOL_SCHEMAS for GITHUB_CREATE_ISSUE to learn its inputs.
  4. It calls PTM_MULTI_EXECUTE_TOOL with the arguments.

That's three calls at least, against one on a fixed server. Step 2 is something a fixed server can't do, though. The user connects an app halfway through the conversation and the agent carries on. When your project has no auth config for that app yet, the router creates a default one: managed OAuth where we run an app for it, otherwise the app's key method.

The search matches words. It compares the query with tool names, app names and descriptions, and it knows a short list of synonyms, so "ticket" also finds issues and "send" also finds create. It doesn't run a model over the query. An agent that phrases the task the way the tools are named finds them first time.

Skills make the search more reliable for tasks you repeat. A skill is a recipe you write in the dashboard with the tools it uses. When a search matches a skill's name or description, the answer includes its instructions, so the agent follows the steps you tested.

Limiting a router

A router that can reach the whole catalogue is broad, so narrow it where you can.

Pick toolkits. In MCP servers → New → Router, choose the apps. Leave the list empty only when the agent really may need any of them.

Allow single tools. Set allowed_tools with the API. The router then finds, describes and runs only those tools, and any other call comes back as "Unknown tool":

curl -X PATCH https://www.prompt-tm.com/api/v3/mcp/servers/mcp_... \
  -H "x-api-key: $PROMPT_TM_KEY" -H "content-type: application/json" \
  -d '{ "allowed_tools": ["GITHUB_LIST_ISSUES", "GITHUB_CREATE_ISSUE"] }'

Ask a person first. Set approvals to Ask a person before destructive calls or Ask a person before any call that changes something. The router checks this for every call inside PTM_MULTI_EXECUTE_TOOL. A guarded call comes back with approval_required: true and doesn't run. The approval link goes to your webhook and the dashboard, never to the agent.

Bind it to one user. A session is a router for one user id, created from your backend with POST /api/v3/tool_router/session. Its MCP URL needs no user_id, so you can hand it to an agent that runs for that one person. The router docs cover sessions in full.

Which one to choose

Fixed toolsRouter
Tool list sent to the clientEvery selected tool with its schemaSix meta tools
Calls per actionOneThree or more
Apps the user hasn't connected yetConnected beforehand, outside the agentConnected during the conversation
What the agent can doReadable from the listSet by toolkits, allowed_tools and approvals
Best forA narrow, known jobAn assistant that may need any app

Pick fixed tools when you can name the tools before the agent runs. Pick a router when you can't, or when the fixed list for the apps you need is longer than you want in every request.

The two can work side by side. MCP clients such as Claude Code take several servers, so an agent can have a fixed server for the five GitHub tools it uses all day and a router for everything else.

Frequently asked questions

Does a router make the agent slower?

Each action takes more calls, at least three where a fixed server needs one, and each step is another turn for the model. PTM_MULTI_EXECUTE_TOOL runs up to 20 calls in one go, which helps when the agent needs several results at once.

Can the router call a tool the server doesn't allow?

No. With allowed_tools set, search doesn't return other tools and a call to one comes back as "Unknown tool". The same applies to apps outside the server's toolkits. The agent can connect only apps that have an allowed tool.

Do approvals work the same way on both?

Yes. Both kinds of server check the approval setting before a call runs. On a fixed server, each guarded tool's description also tells the model that it needs a person's approval.

What is the workbench for?

Work no tool does, such as joining two lists or counting the results of several calls. The agent passes the data in, and the program runs without network access, so it can't fetch anything new.

Try both

Create a free project, connect one app and make two MCP servers for it, one custom and one router. Add both to your client with the Claude Code setup guide and give the agent the same task on each.