When does forcing agent reasoning into code become a leaky abstraction?

This question reads as: code is a powerful medium for agent reasoning, but where does the seam show — where does the model's real cognitive work refuse to fit inside the program? The corpus makes the case for code first, then quietly maps its edges. The strongest version of the pro-code argument is that code is uniquely good because it's executable, inspectable, and stateful all at once — the same artifact lets an agent reason, act, and verify in one loop, which prose can't do Can code serve as the operational substrate for agent reasoning?. That's the abstraction: treat reasoning as a program, and you get checking for free.

The leak starts where the answer can't actually be run. Some of the most useful agent work is verification of things that are expensive or impossible to execute — judging whether two code patches are equivalent, for instance. Here researchers found that semi-formal reasoning templates hit 93% accuracy *without* execution, precisely because forcing real execution was the wrong tool for that task class Can structured reasoning replace code execution for RL rewards?. When you insist the reasoning be 'code that runs,' you either can't express the judgment at all, or you pay execution cost the task didn't need. The abstraction leaks the moment the reasoning is about code rather than reducible to running it.

The second leak is memory and state. A lot of agent intelligence is reconstructive — traversing a memory graph, pruning paths as evidence accumulates, interleaving reasoning with retrieval rather than fetching a fixed result and computing over it Can agents reconstruct memory on demand instead of retrieving it?. That control flow is adaptive and evidence-driven; pinning it into a static program flattens exactly the part that made it work. The broader finding is that reliability comes from *externalizing* cognitive burdens — memory, skills, protocols — into a harness layer, not from cramming everything into the model's output or a single executable trace Where does agent reliability actually come from?. Code is one externalization among several; treat it as the only one and you've named the abstraction that leaks.

There's also a who's-running-it leak. The code-centric loop assumes a model strong enough to author and faithfully follow its own program — but the capacity to *benefit* from harness structure follows an inverted-U: weak models never invoke the scaffolding, strong models over-literally follow it, and only mid-tier models hit the sweet spot Do stronger models always evolve harnesses better?. And much real agent work is repetitive, well-defined subtasks that small language models handle fine Can small language models handle most agent tasks? — for those, an elaborate code-reasoning substrate is overhead, not insight.

So the honest answer: forcing reasoning into code leaks when the reasoning is evaluative rather than executable, when it's reconstructive memory work whose control flow is the point, when the real reliability gains live in other parts of the harness, and when the model on either end can't actually author or follow the program faithfully. Code earns its keep as a substrate for action and verification you can run; it starts hiding the work the instant the work isn't a program. If you want the opposing pole — the case that code genuinely *is* the right operational substrate — start at Can code serve as the operational substrate for agent reasoning? and read it against Can structured reasoning replace code execution for RL rewards?.