The Generic Agent and MCP Tool Discovery

Every automated system is a list of the situations someone thought of in advance. The one that matters is the situation they didn't — and whether anything can handle it without a person writing a new branch.
A request comes in on a Tuesday that does not match anything. A customer has replied to a shipping notification asking to redirect a package to a different address, apply a store credit from a prior return, and hold the whole thing until after a date they mention only in passing — three asks braided into one message, none of which the automation was built to handle as a unit. Every individual piece is doable. There is a system that changes shipping addresses, a system that tracks store credit, a system that manages holds. What does not exist is a path that connects them in this particular order for this particular reason, because no one sat down eighteen months ago and drew that path. So the message does what these messages always do: it falls out of the automated lane and lands in a queue, where a human will eventually read it, understand it in about four seconds, and spend twenty minutes clicking through three interfaces to do what the request plainly asked for. The automation did not fail because the task was hard. It failed because the task was new.
This is the quiet ceiling on almost every system sold as autonomous, and it is worth naming precisely because it is so easy to miss in a demo. A demo shows you the happy path — the anticipated request moving cleanly through the anticipated steps — and the happy path always works, because it was built to. What the demo cannot show you is the request that arrives shaped slightly wrong, combining two things that were only ever handled separately, or asking for something real and reasonable that simply was not on the list when the list was written. In production, those requests are not the exception. They are a constant drip, and the fraction of them a system can absorb without a human is the only honest measure of how autonomous it actually is.
A workflow can only do what someone already imagined
The reason novel requests are so corrosive is structural, and it has nothing to do with how sophisticated any individual step is. A workflow, however elaborate, is a graph of branches that a designer laid down ahead of time. It encodes a set of situations someone anticipated and a response for each, and it is genuinely excellent at exactly those situations. The trouble is that the space of things a customer or an operation can legitimately ask for is not a fixed list. It is open-ended, generated fresh every day by circumstances no one planned around, and a fixed graph meeting an open-ended world produces a predictable result: everything on the graph flows, and everything off it stops. The system is not brittle because it was built badly. It is brittle because a graph is the wrong shape for the problem, and adding more branches only postpones the moment you meet a request that needed a branch you didn't draw.
You can watch organizations try to close this gap by brute force, and watch it not work. They log the requests that fell out of the lane, categorize them, and build new branches for the common ones, which helps until the next unfamiliar shape appears, and the next, because the long tail of legitimate-but-unanticipated requests does not have an end. Every branch you add narrows the gap slightly and never closes it, and the maintenance burden of all those branches compounds, until the workflow that was supposed to reduce human effort has become a second job to keep current. This is the treadmill that a great deal of automation quietly lives on, and it is one of the reasons the Gartner forecast that over forty percent of agentic AI projects will be canceled by the end of 2027 lands as more than a headline. A system that only handles what it was explicitly told to handle looks like autonomy right up until the requests stop matching the script, and then it looks like an expensive way to route work to the same humans who were doing it before.
Discovery is what turns a pile of tools into a plan
The way out is not a bigger list of branches. It is a different fallback underneath them — one that, when a request matches nothing, does not give up and escalate but instead asks a more useful question: what can I actually do here, and can I assemble those capabilities into a response to this specific thing? This is the difference between a system that knows only the paths it was given and one that knows the tools it has and can compose a path on the spot. The first is a workflow. The second is an agent in the meaningful sense of the word, and the mechanism that makes the second possible at enterprise scale is tool discovery — the ability to query the environment at the moment a request arrives and find out what operations are available, rather than having them all hardcoded when the system was built.
This is precisely what the Model Context Protocol exists to enable, and it is why a shared protocol for exposing tools matters far more than it first appears. When capabilities are published through MCP, a system can ask a server what it offers, read back a live catalog of operations with their inputs and outputs described in terms it can reason about, and treat that catalog as raw material for a plan it constructs in the moment. The redirect-and-credit-and-hold request stops being an unhandled shape and becomes a small planning problem: here is what the customer wants, here are the tools that exist right now, here is an order of operations that gets from one to the other. Nobody wrote that sequence in advance. The system found the pieces and arranged them, which is a fundamentally different capability from following a sequence someone else arranged, and it is the capability that separates a real autonomous worker from a script with good manners.
This is the role a generic agent plays, and it is the part of an autonomous system that almost never appears in the marketing because it is not glamorous — it is the safety net rather than the trapeze. In a platform built around Autonomous AI Workers, the specialist agents handle the anticipated work along their well-designed paths, and that is most of the volume and most of the value on any ordinary day. But underneath them sits a generalist whose entire job is the request that matched nothing: to take the message no specialist owns, use MCP discovery to see the full surface of what the connected systems can do, reason about how to combine those operations toward what was actually asked, and act — pausing for a human at the points where judgment or risk genuinely warrant it, the way any well-designed autonomous system keeps a person in the loop on the decisions that matter. The specialists give the system competence on the known. The generic agent gives it a floor on the unknown, and the floor is what keeps the whole thing from being brittle.
The proof of autonomy is the case nobody planned for
It helps to be blunt about what this reframes, because it inverts the usual way these systems are judged. We tend to evaluate automation by how well it handles its main cases — the volume path, the eighty percent, the flows in the demo — and by that standard almost everything looks capable, because the main cases are the ones everyone builds for. But the main cases were never where autonomy was in question. A rules engine handles the main cases. A decision tree handles the main cases. The thing that actually distinguishes an autonomous system from an elaborate one is what happens at the edge of the map, when a request arrives that no designer foresaw, and there the two kinds of system diverge completely: the elaborate one stops and hands the work to a person, and the autonomous one examines what it has, works out what it can do, and does it.
So the mental model worth carrying is that autonomy is not a property of the happy path at all. It is a property of the fallback — the layer that engages precisely when the plan runs out, when the request is genuinely novel and there is no branch to follow, and the system has to reason from the tools in front of it instead of the instructions behind it. A system without that layer is only ever as capable as the last person who edited its branches, and it will meet the unanticipated request the way it always has, by routing it to a human. A system with it grows more capable every time a new tool is connected, because discovery means each new capability becomes available to be composed into responses no one has imagined yet. The right question to ask of anything claiming to be autonomous, then, is not how well it runs the cases you showed it. It is what it does with the case you didn't — because the case nobody anticipated is not a rare edge to be engineered away. It is the daily proof of whether the thing can think, or only follow.
Discussion
No comments yet — start the conversation.