Fused
BlogRSS
← All posts
Share

A Tale of 2 Tools MCP server With Infinite Capability

Most MCP servers register one tool per API endpoint, and the agent pays for every one of them before it does anything. A Fused MCP server always shows two: search_docs to find what it can do, and execute to do it.

Connect an agent to a typical MCP server for a big API and look at its tool list. There's one tool for every endpoint: create issue, get issue, update issue, list transitions, add comment, and on through a few hundred more. Connect a second service and the list doubles.

Every one of those tools has a name, a description and an input schema, and the client loads all of them into the model's context before the agent has done anything. The model then has to pick the right one from a long list of near neighbours. More tools means more tokens spent on definitions, more chances to pick getIssues when you meant searchIssues, and less room left for the task itself.

A Fused MCP server takes a different approach. However many services or operations it can reach, the agent sees two tools: search_docs and execute.

One tool to find, one tool to act

search_docs is how the agent finds out what it can do. It searches only the services on this server, and returns guidance for the task plus the exact input each matching capability needs. It works like a skill the agent loads when it needs it, instead of a manual it has to carry the whole time.

execute is how the agent does it. It runs an approved service operation or an attached Unified App. Engine checks the call is allowed, attaches the right credential, and sends the agent the result.

Ask an agent with access to Stripe to find a customer's latest invoice, and the exchange looks like this:

sequenceDiagram
  accTitle: An agent using search_docs then execute
  accDescr: The agent asks search_docs how to find an invoice and gets back the matching operation and its inputs. It then calls execute with those inputs. Engine checks access, adds the credential, calls Stripe and returns the result.
  participant A as Agent
  participant F as Fused MCP server
  participant S as Stripe
  A->>F: search_docs "find a customer's latest invoice"
  F-->>A: Matching operation and its inputs
  A->>F: execute with those inputs
  F->>S: Call with the stored credential
  S-->>F: Invoice
  F-->>A: Result

The agent never sees the Stripe key, the definitions for the rest of Stripe's API, or any service the server doesn't include.

What the agent gets from this

Less to load. The tool list is two entries long whether the server reaches one service or ten. Guidance arrives only for the task in hand, so most of the context window is left for the conversation and the work.

Better choices. The agent doesn't have to tell apart a few hundred tool names. It describes what it's trying to do, and search_docs returns the few capabilities that fit, with the parameters spelled out.

The same pattern everywhere. Every Fused MCP server works the same way. An agent, or a prompt you've written for one, doesn't need to learn a new tool vocabulary for each service you add.

What you get from this

You can grow a server without changing it for the agent. Adding a service or an operation adds to what search_docs can find. It doesn't add tools, so clients don't need reconfiguring and agent instructions don't go out of date.

1. Start small

Create a server with only the operations the job needs:

fused-cli init support-agent --mcp \
  --description 'Update support issues and notify the owning team in Slack.' \
  --service 'jira=issueUpdate;slack=chatPostMessage'

The agent sees search_docs and execute. Between them they can reach two operations.

2. Add a service

Later the agent needs to look up which channel to post in:

fused-cli extend support-agent --service 'slack=conversationsList'

The server moves to a new version. The agent still sees the same two tools. search_docs can now find a third operation.

3. Hand over a process

For work with a fixed order, attach a Unified App. search_docs returns the app and its inputs, and execute runs it. The agent decides when to run it; your reviewed code decides the steps.

The description stays readable. A server's description says what it helps an agent do, in a sentence or three, and it's what the client shows when it connects. Operation IDs stay out of it, because the agent finds them through search_docs. See Deploy an MCP server.

Scope works the same way. The server sets the most an agent could ever reach. A token can narrow that to an exact list of operations, and anything outside the list doesn't come up in search_docs at all. If the agent tries to call it anyway, execute is refused before anything reaches the provider. Letting an agent act as you walks through that setup.

Every call leaves a record. Each execute records the operation, the credential context, how long the provider took and what came back. When you want to know what an agent did, you read the record instead of asking the agent.

Where execute runs

execute doesn't run on your agent's machine or in the provider's. It runs in Engine, in an environment with no filesystem and no open network access. Provider calls go out only through Engine, which adds credentials as each call leaves and never hands them back.

That's also why one execute call can do a little more than one request. It can make a few calls in a row and shape the result, such as listing open issues and returning only the ones assigned to you, so the agent gets back what it asked for rather than every field of every response. Each call inside it is still checked against the server's scope.

When the same sequence keeps coming up, move it into a Unified App. Then it's reviewed code with one name, and your applications can call it as well as your agents.

The trade-offs

Two tools isn't free, and it's worth knowing what you give up.

  • Per-tool approval prompts become coarse. Some clients ask you to approve each tool. With two tools, approving execute covers everything the server allows. Keep that in mind when you choose what goes on a server, and use a token's allow list to narrow a session that runs unattended.
  • The agent has to look before it acts. Models generally do this without being told. If yours guesses inputs instead, add a line to its instructions: search first, then execute what search returns.

Try it

  1. Deploy an MCP server with one or two operations.
  2. Connect your MCP client to its stable URL. It should list search_docs and execute.
  3. Ask the agent for something the server can do, and watch it search first and then act.
Share
Save
IN THE MARGINS

Join the conversation.

A good story is the beginning of a conversation. Leave a thoughtful note.