The first version of most MCP servers is a wrapper. Someone takes the API, picks the endpoints that look useful, and exposes each one as a tool. It's quick, it demos well, and it quietly hands a design problem to the model.
I've been close to a read-only connector for an accounting product where the plan was to take that first set of tools and consolidate it into five or six built around outcomes. This post is about why that was worth doing, and what it changes downstream: how the model chooses, what the user consents to, how you gate and audit, and what you can test.
Your API's shape is not your user's shape
An API is organised around your data model and your org chart. There's an endpoint for invoices, another for customers, another for payment terms, another for the financial year. That's a perfectly good structure for a developer who knows what they want.
A person asking a question doesn't think that way. They ask "who owes me money?" or "how did we do last quarter?" Answering either one from a pile of endpoint-shaped tools means the model has to work out which tools are relevant, call them in the right order, pass the output of one into the next, and stitch the result together. All of that is planning, and as I argued in the last post, planning is a layer you can get wrong independently of the tools themselves. Every extra tool is more description text in the model's context and one more thing it can confuse with its neighbours.
So the first question isn't "which endpoints should we expose?" It's "which questions do people actually ask, and what is the smallest number of tools that can answer them well?"
Look for the "call this first" smell
Here's the cleanest signal I know that a tool set needs consolidating: a tool description that says "call X first."
Take an accounting example. Someone asks about "last quarter". To answer it, the model needs the business's financial year dates, because a quarter means something different depending on when the year starts. In a wrapper-style design, that's a separate tool. The description of the reporting tool tells the model to call the dates tool first, take the output, and pass it in as parameters. Two calls, one dependency, and one more chance for the model to skip a step or get the dates wrong.
A tool that has to be preceded by another tool should usually have absorbed it. The reporting tool should accept a period in the user's own vocabulary, such as "last quarter" or "this financial year", and resolve the dates itself. The model asks one question and gets one answer. You've moved the complexity out of the model's head and into code you can test.
Here's roughly what an outcome-shaped tool looks like. It's a hypothetical example, but the pattern is the point:
{
"name": "money_owed_to_you",
"description": "Who owes the business money right now, and how overdue it is. Use for questions about unpaid customer invoices, outstanding balances and overdue amounts. Returns balances as at today in the business's currency, grouped by customer, oldest overdue first. Does not return bank balances or payments already received. For invoices raised in a period, use invoice_activity instead.",
"inputSchema": {
"type": "object",
"properties": {
"overdue_only": { "type": "boolean", "default": false },
"limit": { "type": "integer", "default": 10 }
}
}
}
Notice what isn't there. No customer ids to look up first. No pagination cursor for the model to manage. No raw API fields it has to interpret. The tool takes a few parameters in plain terms and returns a shaped answer.
The description is the product
With an MCP connector inside someone else's assistant, you usually don't control the host's prompt. Your tool descriptions are the main place your product's knowledge gets in. In the sub-agent post I argued that capability works best when it sits in the model's context at the moment it's needed. For a connector, the description is how you do that.
That changes how I think about writing them. A good description says what questions the tool answers, what it returns (including units, currency and the "as at" date), and, just as importantly, what it does not do. That last part is easy to skip and it matters. A tool that returns receivables but gets asked about the bank balance will happily return something that looks like an answer. A sentence saying "does not return bank balances" is cheaper than a wrong number in front of a customer.
It's also worth pointing neighbours at each other, as in the example above. When two tools are close, say which one to use for what. Ambiguity between tools is where selection errors come from.
Scopes are the public face of your tools
Consolidation pays off in a place most people don't think about until review: the consent screen.
When someone connects your server to an assistant, they're shown what it will be able to do, and that text is driven by the scopes your connector requests. A scope called reports.read is a machine string that means nothing to the person deciding whether to click Allow. Informed consent needs the label to name the real data, in words the person would use: "View what your customers owe you", not an identifier.
When tools are endpoint-shaped, the mapping to scopes is messy. You end up with either one scope per tool, which is noisy, or one vague scope that hides everything. When tools are outcome-shaped, the mapping is natural: a small number of tools, each reading a recognisable body of data, each with a scope a human can understand.
One honest caveat. Scopes at the connector layer are a presentation and enforcement layer. The upstream credential behind them may still be much broader, and nobody should assume the underlying API is enforcing the same distinctions. That's normal. It just needs to be clear internally, so the consent screen isn't read as a guarantee the API doesn't make.
Narrow is easier to gate and audit
This is the part that connects to the human-in-the-loop post.
A narrow tool with one clear job is a much better unit for control than a general one. You can say precisely what it reads and what it can change. You can attach a gate to it that makes sense: this read needs nothing, this write needs a preview and an approval. And when you look at your logs later, the entries mean something. "money_owed_to_you called with overdue_only true" is a sentence a reviewer can understand. "generic_query called with a long string" is not.
Audit is mostly the ability to answer "what happened, and who allowed it?" after the fact. Five tools with clear purposes make that question tractable. Thirty overlapping ones make it a project.
The same logic extends to write actions later. If the read tools are already shaped around outcomes, adding a write tool that does one thing with one gate is a natural next step. If the surface is a thicket of endpoint wrappers, every new write multiplies the thicket.
Test the tools you're going to ship, not the ones you have
A practical consequence that's easy to get backwards: consolidate before you invest in tool-level evals.
If you're going to change tool names, descriptions and parameters, then evals written against the current set test a design you're about to throw away. It's more efficient to settle the target tools first and build the evaluation against those. Tool-use metrics from open-source frameworks, such as checking whether the right tool was selected with the right arguments, only mean something against tools that are stable enough to measure.
There's another constraint specific to connectors. When your server is used from someone else's assistant, you generally don't get their logs. You can't replay real user conversations. So you need your own harness, a golden set of questions drawn from the top things people ask, and your own telemetry on the server side. Designing tools that are easy to instrument is part of the job, not an afterthought.
What I'd still get wrong
I don't think consolidation is free, and I'd be wary of anyone who says it is.
Outcome-shaped tools move complexity out of the model and into your server. That's the point, but it means you now own the logic that resolves "last quarter" and shapes the result, and that code can be wrong in ways a thin wrapper can't. You've traded a model-planning risk for a code-correctness risk, and the second is at least testable.
There's also a real question about where to stop merging. Go too far and you get a handful of coarse tools that return a lot, hide detail the user wanted, and are hard to cache. Go too far the other way and you're back to a wrapper. I don't have a clean rule for the right number. Five or six felt about right for one product's read surface, and I'd treat that as a starting hypothesis rather than a law.
And outcome-shaped tools age. Users will ask questions nobody planned for, and a tool built around today's top questions will need reshaping as the mix changes. That's a reason to keep the set small enough that reshaping is cheap.