It Can Walk. It Cannot Choose.

I wanted to know what a small model would do with a maze. Not a benchmark maze, with a clean prompt and a single answer. A real one, where the model sees only the part of the board it has walked, gets one move per request, and has to live with the result.

Branch Point is a browser-based game for AI. I built it for this kind of question. A dot crosses an 8×8 grid to a goal, avoiding hazards, and learns only from what happens when it fails. It has two brains to choose from. One is classic Q-learning, an algorithm that is decades old. The other is any model served by Ollama.

That second option made the experiment cheap. If a language model can drive the dot over HTTP, the model does not have to live on the same machine. It can sit on a Raspberry Pi 5 on the desk and answer one move at a time over Wi-Fi. The question was simple. Can a small local model navigate a maze, and how does it compare to the dumb algorithm?

The answer took a week and changed twice. Here is where it ended up.

The rig: Ollama on a Raspberry Pi 5

The board runs in the browser on a laptop. The Pi does one job: it receives a prompt describing what the dot can see, and replies with a direction. It is an 8 GB Pi 5 running Ollama as a lingering systemd user service, installed to a home directory without root, so it survives a reboot. Short runs held 41 to 45 °C. After days of sustained load it reached 66 °C. A Pi 5 does not throttle until 80 °C, and every measured run was at full clock. Latency was 1.7 to 4.1 seconds a move for qwen2.5:1.5b and about 8 seconds for llama3.2:3b.

Every model saw the same prompt: the map it had personally discovered, its last six moves, and a list of the four directions with what it knew about each. Nothing was led by the hand. The route hint, a breadcrumb from an earlier successful run, was switched off for all of them.

Two small things cost real time. Ollama binds to loopback and allows cross-origin requests only from localhost, so the server looked healthy while the browser's fetch failed until both OLLAMA_HOST and OLLAMA_ORIGINS were set. And a Pi 5 will not boot from a laptop's USB port. It wants 5 V at 5 A over USB-C PD, and a laptop port cannot negotiate it. You get a board that looks plugged in and does nothing.

The scoreboard: Q-learning vs the language models

On a fixed 8×8 board called Workshop floor, with a shortest route of 14 moves, Q-learning reached the goal in 925 of 1,406 episodes. Across two boards, the language models reached it once in 361.

A random-move control ran 802 episodes on the same board and never reached the goal once. The board is not solvable by luck, which is what makes 925 a result. It also puts qwen's single goal within reach of chance.

Q-learning flailed for 44 episodes. Then it climbed: 8 percent success at episode 50, 46 percent by 100, 76 percent by 400, settling near 70 percent and finding the 14-move optimum. It started knowing nothing and spent every episode learning.

The models arrived knowing plenty. They knew what a goal is, and that goals tend to sit down and to the right. None of it compounded. Zero goals in 90 llama episodes puts the true rate below 3.3 percent with 95 percent confidence. That is enough to say effectively never. It is not enough to say never.

Priors are not learning

There was one moment early on when qwen looked brilliant. On an earlier board, with the goal in the bottom-right corner, it found the goal on episode one. Q-learning needed 23 episodes to stumble across it.

It was not intelligence. The model arrives knowing that the goal is down and to the right, and on that board the prior happened to point at the answer. Its success rate plateaued at 13 percent and stayed there. Move the hazards onto the direct lines, as Workshop floor does, and the same prior walks it straight into one. It did reach the goal once, on episode 32 of a later run, and never again. One success in 201 episodes is not a learning curve. It is the prior getting lucky.

The language model has knowledge and no way to update it. It was handed its own history every episode and did not get better. The algorithm has no knowledge and does nothing else. On any task long enough to practice, that trade is not close.

Two ways to fail

The interesting part is not that the models lost. It is how.

The smaller model, qwen2.5:1.5b, died in a hazard in 200 of 201 episodes, in an average of 2.4 moves. The notebook persists between episodes, so by episode ten the fatal cells were mapped and the prompt named them explicitly. Of 121 prompts that listed a DEADLY hazard among the four options, qwen chose that option 101 times, 83 percent. The warning was right there in the text it was reading. It walked in anyway. Even the first move was close to a recitation: 104 of 106 episodes opened with right.

The larger model, llama3.2:3b, failed the opposite way. Given the same warning it obeyed almost perfectly, choosing the lethal option 10 times in 1,125 prompts. It survived about eleven times longer, 26.1 moves against 2.4. But survival is not progress. Ninety-nine percent of its moves were horizontal. On a board whose only route requires descending, it went down 28 times in 2,349 moves, and up not once.

One model ignores what it is told. The other obeys and freezes. You only see the difference if you log what the model chose, and not only whether it won.

Two knobs that did not turn

My first theory was sampling noise. If the pacing was randomness leaking into the output, a lower temperature should collapse it into a decision. I ran llama at 0.3 and again at 0.1. The move mix did not change: 54 percent right either way. What moved was the outcome. Hazard deaths fell from 10 to 2 and timeouts rose from 20 to 28. The model became less likely to make a fatal mistake and more likely to pace until the clock ran out.

My second theory was clutter. The prompt shows all 64 cells, and early on 63 of them are an undifferentiated wall of question marks. I cut the map to a 3×3 window around the dot. Nothing. Three llama configurations, about 800 moves each, landed within two points of one another: roughly 54 percent right, 44 to 46 percent left, about 2 percent down. At that sample size the proportions carry about three and a half points of error. These are real nulls.

The metronome: an agent that reverses every move

On a second board the result sharpened. Crossroads is 16×16, mirrored, with mud, teleporters and one-way chutes. I ran two dots on the same maze at the same time, one at temperature 0.3 and one at 0.1, for 30 episodes each.

At 0.1, 1,179 of 1,199 moves reversed the move before it. That is 98.3 percent. The split between right and left was 601 to 598. It is not a distribution. It is a metronome. The dot explored 2.3 of 256 cells per episode and hit the move limit all thirty times. At 0.3 the same model reversed 58.9 percent of the time and reached 14.2 cells.

Every one of those moves came with a reason.

right   only one unexplored cell to the right
left    try to explore the left side of the grid
right   try to explore more of the right side
left    try to explore the left side of the grid
right   try to explore more of the right side
left    try to explore the left side of the grid

Read any single line and the model sounds like it is exploring. Read six and you are watching something with no memory of the sentence it wrote one move ago. The justification is locally coherent and globally empty. The prompt was printing its last six moves back to it the entire time.

By this point I had a thesis, and I liked it. The model cannot hold an intention across stateless calls. Each request is a fresh mind, and a fresh mind will always do the locally sensible thing.

The corridor experiment that changed the answer

A maze asks two things at once. It asks the model to execute, to hold a direction across dozens of independent requests with no memory between them. And it asks the model to judge, to work out which direction that should be from a map it has only partly seen. Failing a maze cannot tell you which half broke.

So I built a board that asks for only one of them. A corridor, seven steps right, with no hazards, no branches and no decisions in it.

# # # # # # # #
# # # # # # # #
# # # # # # # #
a . . . . . . G
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #

The only correct behavior is to pick a direction and keep going. If my thesis was right, the model should pace here too.

It walked the corridor 30 times out of 30, in 9.6 moves against an optimum of 7, with a reversal rate of 16.3 percent. With a chain-of-thought prompt it did better: 9.0 moves, 4.1 percent reversal. Near-perfect play, sustained across dozens of independent HTTP requests with no state between them.

That killed the thesis I had spent four days building. The same model, with the same baseline prompt, reached the goal 30 of 30 times on the corridor and 0 of 30 on the maze. The pacing is not a property of the model and it is not a property of the prompt. It appears only when the task contains a decision the model cannot confidently make.

What looked like an agent that could not hold a thought was an agent that could not make a choice. It stalled, articulately, at the point of choosing.

What better prompting bought

That reframing makes the prompt results legible. I tried four designs on the Workshop maze, same model, 30 episodes each, with a 600-token budget so chain-of-thought was not crippled by a cap the others never reached.

On one measure, prompting looks like a triumph. Chain-of-thought cut the reversal rate from 82.5 percent to 23.2 percent. The dot stopped running out the clock.

On the next, it is a disaster. Hazard deaths went from 7 to 28. Goals never got past one. The paralysis had been protecting the dot. A dot that paces does not walk into anything fatal. Give it the confidence to commit and it commits to the wrong cell, while reading a prompt that names that cell as a deadly hazard. The scratchpad variant ignored that warning 26 times out of 172.

Prompt engineering did not make the model competent. It removed the symptom that was masking the incompetence, and turned a visible failure into a confident one.

What I would not claim

Zero is a bound, not a proof. Three boards is not a survey, and the corridor is a deliberately degenerate case: it shows that execution is intact, not that the model is good at anything. The corridor and prompt results are llama3.2:3b alone, so I have shown the split between execution and judgment for one 3B model, not for small models in general. The Crossroads pair was not perfectly matched, with a one-move difference in shortest route. Only two prompt variables were tested. Explicit coordinates, a running scratchpad carried between moves, and a format that forces the model to name its target before it moves are all untried, and any of them might do considerably better.

And these are small models. Nothing here says what a frontier model would do. It says what fits in 8 GB and answers in under ten seconds.

What stays

I started this to find out whether a model on a desk could play a game. What I found is a more useful distinction, and the way I found it is the part I would keep.

A model can look fluent and still be unable to choose. The fluency is real: the corridor proves it. The judgment is what is missing, and it hides inside the same smooth sentences. Better prompting did not supply it. It made the model act on it sooner.

The measurement rig nearly invalidated all of this without a single error message. The board reshuffled its hazards on every page reload, so my first day compared different mazes. Episode data was lost on every model switch. Browser downloads failed silently. A cold model load blew a two-minute timeout and quietly killed one arm of a test. Nothing threw. The numbers simply meant nothing. The fix took twenty minutes and should have come first.

The Pi was never the bottleneck. Every limit I hit was in the model's reasoning, not the silicon, which is the encouraging part of an otherwise negative result. The hardware is fine. What is missing from these small models is the thing the oldest algorithm in the room has: a way to be wrong, remember it, and choose differently next time.