What goes wrong when a cheap coordinator sends the job to the wrong agent?

The wrong agent does real work in its own lane, and the coordinator marks the job done. You do not get a clean error that says the route was bad. You get a file edit, a draft, or a paragraph that sounds finished, while the thing you actually asked about is untouched. The mislabel is the small mistake. The damage is whatever tools that specialist was allowed to use, plus a status that now says success.

A cheap coordinator fails this way because its only signal is “a specialist returned.” It cannot tell a successful edit of the wrong artifact from a fix. If that specialist can write, send, or spend, the route is not a labeling error you can laugh off. It is an action you have to undo.

The staging link that got a code change

The request was “the staging link is wrong.” I knew, because I had just watched the deploy, that the workflow had shipped with the production host in an environment variable. The cheap coordinator did not have a deploy specialist. It had a Files agent that could edit the repo. Files was the closest name to “fix,” so Files got the job.

The Files agent did what it is good at. It searched for the hostname, found a fallback string in the frontend, and changed that string to a staging host it invented from the word “staging” plus the production domain. The edit applied. The tool returned success. The agent’s last message said the link was updated. The coordinator stored that message as the result and did not call anyone else.

What I had afterward: a committed-looking diff that would point the UI at a host that did not exist, and the environment variable still wrong, so the real staging URL was unchanged. Two bugs, one of which the agent had created because it was employed to act. If I had let that agent open the pull request, the wrong fix would have been the thing a reviewer saw, described in a summary that did not mention DNS or the workflow file it never opened.

That is the shape. The wrong specialist is not idle. It uses the tools it has on the nouns it can find. Those nouns are nearby. They are not the fault.

Success is the dangerous return value

A failed tool call is easier to live with. The runtime says the path was missing, the coordinator might try again, and you at least have an error in the log. The bad routes I remember were the ones where the tool worked.

Mail is the ugly version. A request like “check whether Sam already has the notes” can be routed to a mail-draft agent because the name Sam appeared, if your roster’s mail sentence is loose. The agent does not check a thread you did not give it access to. It writes a draft that asks Sam whether he has the notes, because producing a draft is how that agent succeeds. The coordinator sees a draft id and a polite sentence. The job “check” has become “send a question,” sitting one approval away from going out. Nobody logged a routing error. The artifact is a message you did not ask for.

Calendar does a quieter version. “Move Thursday’s review notes into the project folder” lands on a calendar agent that can only read events. It cannot move a file, so it returns a summary of Thursday’s review meeting and calls that the notes. The coordinator accepts the summary. The file never moves. You read the summary later and think the folder was handled, because the prose includes the meeting title and a confident “done.”

I treat any specialist success on a route I did not expect as suspicious, not as saved work. The tool did something real. That is the problem.

When the specialist has no tool for the job

Sometimes the wrong agent cannot act, and that feels safer until you read the reply. A docs agent asked to fix a deploy will not edit the workflow. It will quote a paragraph from the install page that mentions environments, then state that staging should use the flag in that paragraph. The quote may be real. The flag may be for a different product version. The coordinator, which only checks that text came back, will present the quote as the resolution.

This is a hallucinated completion wearing a real citation. The page exists. The mapping from that page to your broken link does not. A cheap coordinator has no second step that asks “did this specialist’s tool list include the artifact in the request?” If the answer is no, the text reply should not be allowed to close the job. I have lost more time to cited nonsense than to crashes, because the citation makes me trust the first read.

The rule I use: if the specialist did not call a tool, it did not finish a job that needed the world to change or to be read. A summary is not a result. The coordinator has to be too dumb to promote a summary into “done,” which means the done flag cannot be the specialist’s own last sentence.

The retry that picks the same agent again

When the tool does fail, the next failure is the loop. The Files agent errors because the hostname is not in the repo. The error text contains “staging” and “link.” The cheap coordinator classifies the error with the same habit that classified the request, and sends it back to Files. I have watched three identical searches. Each one returned no matches. Each one counted as the coordinator “trying.”

Nothing in that loop consults a different specialist, because the coordinator’s features are keywords, and the error is made of the same keywords. A retry budget without a rule that the next attempt must be a different specialist, or a human, is just latency. It also fills the log with confident searches that look like investigation.

I cap this hard. One attempt per specialist per request. A second attempt requires a person, or a different name than the first. The cheap model does not get to “learn” from the error. It already showed what it does with those words.

What the original request becomes

The request itself gets edited, and that is easy to miss if you only store the specialist’s answer. “The staging link is wrong” goes out as a file task: “update the staging URL in the frontend.” The coordinator rewrites it so the specialist has a clear job. The rewrite is the loss. You can no longer see, in the specialist’s prompt, that the user did not name a file. The diff looks responsive. It is responsive to a sentence the user did not write.

Compound requests lose a clause. “Put the notes in the folder and tell Sam” becomes “put the notes in the folder” because the first verb matched Files and the format only held one name. Sam is not in the result. A week later you remember you meant to tell him, and the system’s log says the task completed. The completion is accurate for the rewritten task and false for yours.

I keep the original sentence in the record next to the route, and I do not let the coordinator replace it. The specialist can receive a narrowed instruction only if the original is still attached and a person, or a later check, can see what was cut. A cheap model will cut. Your log has to show the cut.

What I changed after the staging edit

Files no longer receives a job unless the request names a path, a symbol, or a repo. “The link is wrong” does not match that, so the coordinator must return none. I would rather triage it myself than let a write-capable agent search for a hostname.

Specialists that can write, draft, or create calendar events are not eligible for low-confidence routes. If the coordinator’s reason does not quote a phrase that appears in both the request and that specialist’s roster sentence, the job stops. Quoting “link” is not enough. The roster sentence for Files does not talk about links. The overlap has to be the artifact, not a verb like fix or check.

Closing the job is a separate step from the specialist returning. I do not set done because edit_file succeeded. I set done when the artifact named in the original sentence was the artifact the tool touched, or when a person says so. For the staging case, the tool touched a frontend fallback. The sentence never named that file. The job stays open, and the diff sits in a branch I did not ask anyone to merge.

I also stopped letting the coordinator rewrite the task into the specialist’s language before the specialist sees it. The specialist gets the original sentence plus the route name. If it cannot act without a rewrite, it returns “cannot,” and that return is not success. This makes the Files agent less helpful on ambiguous lines. Helpful was the failure mode.

The thing to measure

Do not measure the coordinator on whether it always picks someone. Measure it on whether the specialist’s tool touched the artifact the user named, and on how often a success return left the original problem in place. A cheap router that sometimes says none is working. A cheap router that always dispatches, into agents that can edit or draft, will eventually ship a fix for a sentence it rewrote.

When the wrong agent runs, assume the tools ran. Read the diff or the draft before you read the summary. The summary was written by the agent that was proud of the wrong lane, and accepted by a coordinator that only knows how to hear “done.”