When a coding agent like Claude Code or Cursor works on a bug, it spends dozens of steps reading files, editing code, and running tests. From the outside, it looks like the agent is "thinking" about the program. But is it actually building an internal mental model of the code — or just pattern-matching its way from one edit to the next? This paper cracks open the black box and finds a surprisingly rich answer.

The authors trained a very simple statistical tool (a logistic regression probe) on the internal activations — the "residual streams" — of the language model powering a coding agent. Think of the residual stream as the neural network's working scratchpad: a big vector of numbers that flows through the model as it processes tokens. The probe's job was to look at this scratchpad and predict things about the code the agent was editing.

Here's what they found the model quietly keeps track of, without ever being told to:

• Whether the current code parses — the model "knows" if it's syntactically valid.
• Whether the test suite currently passes — before even running the tests.
• Whether the next edit will reduce the number of failing tests — a form of latent forecasting.

That last finding is the eye-opener. The model isn't just reacting to feedback like compiler errors; it's internally representing something like "if I do this, things will get better." The paper calls this a latent programming horizon — a hidden look-ahead about where the program is going.

Why does this matter beyond curiosity? Two practical reasons:

• Debugging agents themselves. If we can probe what an agent "believes" about the code, we can catch it heading down a bad path early — before it burns 20 more steps making things worse.
• Cheaper feedback loops. Running a test suite after every edit is slow. If the model already internally predicts test outcomes, we could sometimes trust that signal and skip actual execution — or use it to prioritize which edits are worth validating.

The bigger picture: coding agents are often described as "just" LLMs bolted to tools. This paper is evidence that when you put a model inside an agentic loop, it develops implicit representations of program state that mirror how a human programmer holds the code in their head. That has implications for how we evaluate, interpret, and eventually control these systems.