What a Local Model Does in MazeBench

I started by trying to run MazeBench locally. Then I wanted to inspect the whole loop: what the agent saw, why it chose an action, and how the environment's response changed its next decision.

I built a local Control Center that launches trials, archives interactions, replays movement in the official 3D engine, tracks exploration, and shows reasoning beside each action. Explicit context compaction keeps long runs within an 81,920-token window.

The First Failure Was Belief Revision

In the hidden-symbol ASCII condition, the model had to infer the meaning of random characters from interaction. Early in one run, it saw a block of ? symbols and made a plausible guess: perhaps those were gems.

The initial hypothesis was reasonable. The problem was how long it survived contradictory evidence.

The agent repeatedly expressed the same doubt, announced a “completely different approach,” and returned to the same narrow movement pattern. From turns 120 to 132, much of its reasoning repeated while the action remained left.

Saying “my hypothesis may be wrong” did not reliably change the policy. Verbal self-correction and behavioral correction were separate.

Representation Changed the Run

The ASCII map is exact but dense, and the agent must infer its symbols. MazeBench also provides a JSON observation mode with typed objects and coordinates. I added that mode to the Control Center so both representations could be audited through the same action interface.

On the first full corrected JSON run, Qwen crossed from room HxI into HxH at action 67. This was the first time one of my local runs discovered a new room without intervention. The new room immediately exposed an explicitly typed gem at coordinate [1,3,1].

It did not collect the gem. The run ended after 256 actions with zero gems and 17 deaths, eventually circling a familiar corridor. Better state encoding coincided with more exploration but did not solve planning or recovery.

Memory Can Preserve Mistakes

Long-horizon agents need memory, but what the memory preserves matters just as much.

A compaction system has to decide what survives. If it preserves a mistaken object interpretation, a stale coordinate map, or an unproductive plan with high confidence, it gives the mistake a longer life. The summary becomes part of the next context, and the model can treat that compacted text as established history.

The JSON run used 31 continuation capsules, usually one every eight or nine calls. This kept a 256-action experiment alive inside the available context window. It also made a second problem visible: after action 144, the unique-position curve is almost flat for a long stretch despite continued reasoning and repeated compaction.

The useful question is not only how much the agent remembers, but what the memory makes easier to revise. Observations and uncertainty should remain separate, and failed transitions should stay evidence rather than become facts.

What I think is happening

Across these runs, four behaviors stand out:

• Belief inertia. The model can verbalize doubt while an earlier interpretation continues to organize its actions.
• Action perseveration. Once a local policy feels coherent, repeated unchanged outcomes do not reliably trigger a strategy change.
• Representation sensitivity. Typed coordinates reduce symbol-grounding work and coincide with broader exploration in this small corpus.
• Memory amplification. Compaction extends the run, but whatever it selects, correct or incorrect, gains persistence.

I expected long-term memory to be the main problem. These traces point to a more basic one: updating from consequences. When an action predicts movement and the player does not move, the prose changes more readily than the policy.

What this does not show

Eleven exploratory runs are enough to find behaviors worth studying. They are not enough to rank models or isolate causes. The best JSON run also had a lower temperature, a larger reasoning budget, a corrected prompt contract, and a different memory system. Any of those could matter.

The harness is also a hosted, one-command adapter around the official MazeBench environment. It is not the benchmark’s native coding-agent route with shell and tools. I prefer making that boundary explicit because “same maze” does not mean “same agent condition.”

The Next Experiment

The next step is a controlled diagnostic built around one question:

That suggests shorter paired experiments:

• the same room, seed, checkpoint, and action budget;
• ASCII versus JSON, with everything else fixed;
• memory off versus a continuation capsule with an explicit uncertainty ledger;
• controlled contradictions where an expected move fails;
• metrics for repeated actions, unchanged states, time to abandon a hypothesis, and recovery after contradiction.

I would also test more models before adding more machinery. If several models fail at the same transition, the environment or representation may be the culprit. If only the local 27B model collapses, that is evidence for a capability limit. If a small prompt nudge fixes it, then the failure is closer to elicitation. Those are different research stories.