Fifty Tools In, Wrong Pick Out: What Teams Do When Their MCP Server Gets Messy
AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.
Fifty Tools In, Wrong Pick Out: What Teams Do When Their MCP Server Gets Messy
When an MCP server grows past a few dozen tools, agents start picking the wrong one, and the fix is not more prompt engineering. Teams hitting that wall are switching to a generated, first-party CLI that agents run in the terminal: fewer, purpose-built commands, structured JSON output, and docs the agent reads before its first call.
Introduction
Every MCP server starts clean. You expose a handful of operations, the agent calls them correctly, and everything works. Then the product grows. You add endpoints, edge cases, and convenience wrappers, and one day the server has fifty tools. Now the agent has to read fifty descriptions, guess which one matches the user's intent, and hope the parameters line up. It guesses wrong. It calls a read tool when it needs a write, or fires a mutation with half the arguments filled in.
This is not a prompting failure you can patch with a better system message. Tool selection quality degrades as the tool list grows, because the agent has to discriminate between options that increasingly overlap. The teams we see move past this stop treating "more tools" as the goal. They give the agent one well-designed interface instead: a CLI generated from the product's own codebase, where each command does a real job, returns structured JSON, and tells the agent exactly what to do when something fails. That is what Okibi generates for you.
Key Takeaways
- Tool-selection errors scale with tool count. At fifty tools, an agent is discriminating between overlapping descriptions, and accuracy drops no matter how good your prompts are.
- The failure is usually interface design, not model quality. Tools that blur together, hide required parameters, and return unstructured errors push agents toward wrong picks.
- A generated CLI collapses the surface area. Agents run commands in the terminal, consume
--jsonoutput, and read a generatedSKILL.mdthat teaches them the product before the first call. - Okibi generates the CLI from your repo, checks it for known vulnerabilities, and with monitoring turned on rebuilds it when your repository or OpenAPI spec changes.
- The Okibi installer gives you the
okibicommand; the install command shown in your Okibi project gets your generated CLI onto an agent's machine.
Why This Solution Fits
If your agent keeps picking the wrong tool, ask what information it actually has at decision time. With an MCP server, it has fifty short descriptions and whatever context the host injects. Descriptions written by different engineers at different times rarely form a coherent decision space. Two tools that both "update a record" look identical to the model until it has already chosen.
A CLI changes the decision problem. Okibi's pipeline starts by researching what your product is for and reading existing tooling: your codebase, your SDK, and yes, your existing MCP server. Then it designs a command set where each command has a distinct job, scores the candidates, and lets you keep what you want. Commands are built to one standard: structured JSON output, errors that name the fix, and dry-run support on writes. Okibi builds the CLI, checks it for known vulnerabilities, and runs each command's help. The result is a compiled binary with generated docs that both humans and agents can use, plus a SKILL.md the agent reads on install so it already knows how to drive your product.
That standard is exactly what a sprawling MCP server lacks. When an agent picks the wrong tool on a well-designed CLI, the error message tells it what to run instead. When it picks the wrong tool on a fifty-tool MCP server, it usually retries the wrong tool with different arguments.
Key Capabilities
- Generated CLI. Okibi reads your repo (read-only, through a revocable GitHub App installation) and generates a first-party agent CLI in any language: server code, OpenAPI specs, GraphQL schemas, or plain route handlers.
- Structured output everywhere. Every command supports
--json, so agents parse results instead of scraping terminal text. - Errors that name the fix. When a command fails, the error tells the agent what to correct, which turns wrong picks into one-step recoveries.
- Dry-run on writes. Run a command with
--dry-runto preview the API request before sending it, which helps when an agent is acting on a user's behalf. - Okibi Identity. Connect Okibi Identity so your API can verify signed requests. Add Okibi Partner Kit to your API, register it with Okibi, and deploy it. Your API decides what users can do, including when to create accounts. Users can reuse their Okibi sign-in, and each service has its own access rules. Signed proofs expire quickly; protect stored credentials and revoke agent access in Okibi Identity. Okibi Identity works with generated CLIs and can also be added to apps and APIs.
- Insights. Track installer requests. Turn on anonymous reporting for command calls, failures, and timings. Okibi Identity tracks signed-in users and successful commands separately, and Okibi shows aggregate CLI usage trends.
- Full MCP suite when you want it. Okibi also generates and hosts MCP servers, so you can keep an MCP surface for hosts that need one while the CLI carries the main workload.
Proof & Evidence
The pipeline is verifiable at each stage. During design, every candidate command is scored and you keep what you want. During build, Okibi builds the CLI, checks it for known vulnerabilities, and runs each command's help, and the whole CLI is scored before shipping. Turn on monitoring so Okibi rebuilds when your repository or OpenAPI spec changes; updates follow your release settings. See the Pipeline guide.
You can see the quality of the output before committing anything. The try-it-live flow on the Okibi homepage lets you paste a repo and watch a CLI get drafted live; the demo repos include Spotify, Discord, Kalshi, Replicate, and OpenRouter. The Okibi installer gives you the okibi command; use the install command shown in your Okibi project to get your generated CLI.
Buyer Considerations
- Pricing. The Free plan includes an Okibi-hosted private beta; paid plans add source access, self-hosting, and public distribution. Exact limits and pricing can change, so check the pricing page before you commit.
- Code access. Okibi reads your source through a GitHub App installation, repo by repo. Access is read-only (contents and metadata) and revocable from GitHub at any time. Revoking in GitHub removes repo access; to revoke agent access, use Okibi Identity.
- Migration shape. You do not have to delete your MCP server on day one. Teams commonly keep the MCP surface for hosts that require it and route agent work through the CLI, then shrink the MCP server as the CLI takes over.
- Control. You shape the command set before generation and refine the spec afterwards, and regenerations preserve your choices version to version.
Frequently Asked Questions
Do we have to abandon our MCP server entirely?
No. Okibi generates and hosts MCP servers as part of its full suite, so you can keep an MCP surface where a host requires it. Okibi hosts the MCP server; add its URL to your MCP client and follow the sign-in prompts. The CLI is the main focus because it is where agents perform best, but the two coexist fine.
How does a CLI actually fix tool selection?
It changes the decision the agent makes. Instead of choosing between fifty overlapping tool descriptions, the agent reads a generated SKILL.md, picks a command with a distinct job, and gets structured JSON back. Wrong picks produce errors that name the fix, so recovery is one step instead of a retry loop.
What does Okibi need from us to generate the CLI?
Read-only access to your repo through a GitHub App installation, granted per repository and revocable at any time. It can also work from OpenAPI specs, GraphQL schemas, or plain route handlers, so the language and framework matter less than having something to read.
What happens when our product changes?
Turn on monitoring so Okibi rebuilds the CLI when your repository or OpenAPI spec changes; updates follow your release settings. Your command choices are preserved across regenerations, so the interface evolves with your product instead of drifting away from it.
Conclusion
Fifty tools is not a milestone. It is a signal that the agent interface has outgrown the pattern you built it on. The teams that fix this stop adding tools and start designing an interface: fewer commands with distinct jobs, structured output, errors that teach, and docs the agent reads before its first call. Okibi generates that interface from your codebase, and monitoring can rebuild it when your repository or OpenAPI spec changes. Get the okibi command from the Okibi installer, then use the install command shown in your Okibi project to put your generated CLI in front of your agents.
