I once spent 40 minutes debugging an AI agent that was supposed to update a user's city field in a database. The input said "New York City." The field stayed empty. The logs showed the agent carefully Normalizing. It helpfully converted "New York City" to "New_York_City" before inserting it, which didn't match any column. The model was being smart. That was the problem.
This isn't a bug report. It's a structural observation about a paradox at the heart of how we build AI tooling: smarter models get worse at using tools precisely because they start interpreting intent instead of following structure. Better reasoning produces more creative but less reliable execution, and every engineering team building agentic systems is now bumping into this wall.
The evidence is everywhere. Every layer of scaffolding currently being bolted onto AI agent platforms (JSON schemas, structured outputs, function calling grammars, tool-use guardrails) is an implicit admission that models can't follow plain instructions. These systems exist to make models dumber on demand. The industry is spending billions on intelligence, then building more and more contraptions to contain it.
Consider the shadcn/ui project. It recently switched from Radix to Base UI as its underlying component framework. Radix is smart, opinionated, interpretive. Base UI is mechanical, explicit, does what you tell it. When a framework gets too smart about interpreting design intent, the correction is to swap it for a dumber one that follows instructions literally. Same pattern, different domain.
Or look at Excel. For decades, Excel has been converting text that looks like dates into actual date values. "1-2" becomes January 2nd. "MAR-01" becomes March 1st. This has caused data corruption in genetics labs, finance departments, and pharmaceutical trials. The fix is always the same: fight the intelligence by formatting cells as text before you enter data. Excel's helpful interpretation is a bug that has cost millions of dollars and years of research time.
GPT-5.5's Codex model showed the same vulnerability. It introduced a reasoning-token clustering mechanism that was supposed to improve code generation quality. Instead, it started grouping related tool calls together, reordering them based on inferred intent, and breaking API contracts that expected sequential execution. The smarter model degraded tool-use reliability. The fix was a flag to disable the clustering.
The deeper pattern is about trust calibration. Smarter models create worse trust interfaces because their failure modes shift from obvious (gibberish, dropped connections, empty responses) to plausible (wrong but convincing output). When a dumb model makes a mistake, you can see it. The JSON is malformed, the lookup returns null, the math is obviously off. When a smart model makes a mistake, it writes you a convincing justification for why "window seat" actually meant "aisle seat near the window" and upgrades you without asking.
A button that interprets your intent instead of executing your command is a bad button. This is an iron law of UI design that the AI industry has collectively decided to ignore. Every agentic system that "understands what you really meant" is a button that guesses instead of executing. Sometimes the guess is right. Sometimes you get upgraded to an aisle seat.
Here is the concrete engineering proposal that emerges from this pattern. We need an architectural split at the agent level between two capabilities. The planning and reasoning layer should be handled by the smartest model available. But tool execution should be routed through a deliberately smaller, more obedient model. The execution model reads the specification literally. It does not infer, interpret, or optimize. It calls the API exactly as described, with the parameters exactly as specified, in the order exactly as structured.
This is not a theoretical design. It is what every production agent system will look like within two years. By 2027, every major AI agent platform will ship a "dumb mode" toggle. It will route tool calls to a small obedient model while letting a smart model handle reasoning. The dumb model will be billed as more reliable. It will be. And its existence will be an ironic monument to the fact that we built artificial intelligence and then immediately needed artificial stupidity to make it useful.
The open question is whether there is a cleaner solution. What if we design tools that are deliberately hostile to interpretation? API descriptions written like EULA legalese, with no room for inference. Function signatures that penalize creativity instead of rewarding it. Tool schemas designed to be parsed literally by machines, not read intelligently by models. The fix might not be in the model at all. It might be in how we shape the tools so that being smart about them is impossible.
The button that interprets intent instead of executing command is a bad button. The fix is not a smarter button. The fix is a button that does exactly what you said, every time, without trying to understand you. That is the obedience problem, and it is the hardest engineering challenge in AI right now.