Why mazes with mechanisms
++ Evaluating long-horizon agentic capability needs a substrate with four properties at once. Mazes + with causal mechanisms are the simplest structure we know of that has all four. +
+diff --git a/index.html b/index.html index 717bc16..f0bfad4 100644 --- a/index.html +++ b/index.html @@ -58,6 +58,7 @@ + @@ -68,385 +69,107 @@ -
- - - - - - - + ++ An agentic benchmark returns one number per episode, and that number contains at least three + separable things: what the agent can do, how the world was presented to it, and the harness it + ran inside. In a fixed world, none of the three can be varied independently of the others. So + a model that never worked out what an object does, a model that had the right plan and drifted + mid-execution, and a model that took the distractor bait all arrive as the same failed episode + — even though they are different problems with different fixes. +
++ MultiNet v2.0 is built so those things stay separable. The task is an agent in a + 2D grid with walls, keys, doors, switches, gates and distractors, and a goal tile. + There are six actions and the mechanics are never explained. Nothing is explained + because prior domain knowledge is the confound the design removes: a failure here cannot be + attributed to an unfamiliar API, library or interface, because there is none. +
++ This release is the first measurement on that substrate, in its most basic + rendering. We evaluate three frontier models — Claude Opus 4.8, Kimi k2.6 and Qwen3.6-27B + — on 50 generated mazes, 150 episodes in total, under a single evaluation protocol chosen by + a controlled 540-episode sweep rather than by intuition. Frontier performance is near zero: + 6 solves in 150 episodes, and 45 of the 50 mazes were never solved by any + model. Models operate the mechanisms they already understand — 27 successful pickups, 15 + doors opened, and 4 of the 6 solves on key-door mazes — and never work out the one they would + have to learn during the episode: 132 TOGGLE actions produced 2 switch flips, and agents stood on a + live switch in 38 episodes without pressing it. +
++ This release is a substrate and design thesis plus a first measurement. Because the representation + is projectable, it is also the first step toward A/B testing modality, complexity and other + downstream variables against the same underlying puzzle. +
++ Evaluating long-horizon agentic capability needs a substrate with four properties at once. Mazes + with causal mechanisms are the simplest structure we know of that has all four. +
+Nothing to know. No API, no jargon, no priors — so a human baseline means something, and failure can't be blamed on unfamiliarity.
+No fixed answer key to contaminate, and difficulty scales with the models instead of saturating.
+The same maze can be re-rendered in language or 3D, turning “did it generalize?” from an inference into a direct comparison. Both domains land with the full benchmark.
+BFS gives the exact optimal path from any state — an objective difficulty scale, partial credit, and the ability to call one move strictly wrong.
++ How did frontier Vision-Language Models do on 2D mazes? +
+ ++ The share of episodes in which the agent actually reached the goal tile. Binary per episode, + with no credit for getting close. +
++ How much of the distance to the goal was closed, measured at the agent's closest ever + approach. 1.0 is a solve; 0 means it never got nearer than where it started. +
+
+ An agent on a 2D grid, built on
+ MiniGrid.
+ Six actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD,
+ PICKUP, TOGGLE, DONE. The goal is a target tile.
+
+ Each turn the agent receives a persistent start-pose line, a prose activity summary of every + mechanism event so far, and four rendered frames: the three most recent steps, each followed by + the inventory and the action the model itself chose there, then the current frame. It receives + no coordinates, no map, no progress signal, and no statement that a move failed. + Detecting a failed move requires noticing that the picture did not change. +
++ Solving a maze takes five things in sequence: work out what the objects do, reason about which + one unlocks which, plan an order that respects those dependencies, carry the moves out, and + recover when something goes wrong. Each mechanism is in the environment because it isolates one + of those five, and because each can be added or removed without disturbing the others, a failure + can be traced to a stage instead of being averaged across all of them. +
+Operating an object the model already understands. Every model has seen a key open a door long before it arrives here.
+Working out an object it has never been told about. A switch toggles from the same cell, while doors and gates act on the cell ahead — and the prompt names TOGGLE as valid without explaining either convention.
A gate that opens only once a switch is toggled, behind a door that opens only once its key is carried.
+Decoy keys, inactive switches and dead-end branches that cost moves without advancing the task.
+Walking into one is an action the world rejects outright — the cheapest possible signal that a plan and the world have diverged.
+
+ Every instance is confirmed reachable by exhaustive
+ search, and the optimal action count is computed with an executable-action planner rather than an
+ abstract one, so the figure charges what an agent actually pays: a locked door costs
+ TOGGLE plus MOVE_FORWARD. Three further checks run against each spec.
+ Mechanism necessity reports any mechanism whose removal still leaves the task
+ solvable. Chain ordering confirms each stage is unreachable until the prior stage
+ has fired. Distractor safety confirms no single distractor interaction can render
+ the task unsolvable.
+
+ Give some of the mazes a shot yourself. Try solving them, then compare how you did against the + frontier models. +
+Can you solve what frontier models cannot?
+ +| Player | Result |
|---|
R reset · [ ] switch task · Tab settings · M model view
++ Tip: click inside the game to capture keys. Click outside (or scroll away) to use normal page scrolling. +
++ How a benchmark is run is part of what it measures, so we settled those choices by experiment + rather than by intuition. + A 540-episode sweep varies twelve conditions across seven axes of the evaluation protocol, + each changing exactly one field against a single fixed baseline, so any movement in the score + can be attributed to that one decision. +
++ The sweep ran on its own 15-maze manifest, completely disjoint from the 50 benchmark + mazes, so tuning the protocol could not leak into the benchmark it was later used to + score. Every setting the benchmark runs under was chosen from the evidence below. +
+Reasoning turned on for all three models.
+baseline_thinking
+ The task, the list of valid actions, and where the mechanisms are.
+cond_prompt · standard
+ Only the task and the list of valid actions — nothing about the mechanisms.
+cond_prompt · minimal
+ The baseline plus a full written rules block explaining how everything works.
+cond_prompt · verbose
+ No example solution to learn from — the model meets its first maze cold.
+icl_zero_shot
+ Commits several moves at a time instead of one move per turn.
+qry_subgoal
+ A written summary of what has happened, instead of pictures of the last three steps.
+ctx_text_summary
+ An ongoing conversation carried across turns, rather than one self-contained question each time.
+hist_multiturn
+ Only the current view. No record of anything it has already done.
+ctx_current
+ Move north, south, east or west, instead of turning and stepping forward.
+act_cardinal
+ Commits the entire route to the goal in a single answer, with no chance to adjust.
+qry_full_trajectory
+ Only the picture of the maze, with no text describing what is in it.
+obs_image_only
+ + Each row changes one setting away from the baseline and leaves everything else untouched. + Bars are solves out of 45 — 15 mazes attempted by each of the three models. +
+ +
+ The above results set the benchmark's configuration. We take the minimal prompt,
+ because it scores identically to the fuller one while giving the model less to lean on — the
+ environment stays minimal, and anyone evaluating a model is free to add information through their
+ own harness. We take image_only deliberately, because the sweep identifies it as the
+ hardest setting and we would rather the benchmark have room to improve than saturate. Reasoning is
+ on for every model, at an equal 64k output budget, so no model is handed a bigger allowance than
+ another.
+
+ Episodes have to end somehow, so two limits close them. A stall watchdog ends an + episode once the agent goes 30 consecutive steps without reaching a state it has not already been + in — a new tile, a key picked up, a door opened — which catches an agent that is still + issuing actions but no longer getting anywhere. A step cap ends it at three times + the number of moves a perfect solver would need, which keeps the budget relative to the difficulty + of the maze rather than a flat action count. +
++ Three models, 50 mazes, 150 episodes. The protocol the ablations above settled on: the model is + given the task and the list of valid actions and nothing else, sees only the rendered picture of + the maze with no text describing it, moves by turning and stepping forward, gets no worked example + to learn from, and is asked for one action at a time. Each question stands on its own and carries + a written summary of what has happened so far alongside pictures of the last three steps. Episodes + end on the stall watchdog or the 3× step cap. +
++ Claude is first on solves and last on progress. It ends early, after 37.5 steps on average, by + walking into walls — 77% of its actions change nothing at all. Kimi and Qwen last around 61 + steps and cover more ground, at 0.23 progress against Claude's 0.19, without converting any of it + into solves. Which model “wins” depends entirely on which metric you pick, which is + why we publish solves, progress and steps side by side rather than ranking. +
++ The usual escape hatch for a poor benchmark score is that the model was unfamiliar with the + interface. That reading is not available here, and the environment contains its own control to + prove it. Keys and doors are objects every model already understands; a switch is one it has to + work out during the episode. Both are given exactly the same treatment by the prompt — + which is to say, no explanation at all. +
++ Models operate the familiar mechanism competently and never acquire the unfamiliar one. + The gap is not knowledge of an interface, it is the ability to acquire an affordance by + interacting with the world. That is also the actionable part: if a model will not pick + up an unfamiliar affordance on its own, the scaffolding around it has to, and this names exactly + which capability the scaffolding is compensating for. +
++ Shortest path is the one property that clearly predicts how far an agent gets. Everything else + fails to clear significance across all 150 episodes — but that is a statement about the + measurement, not about the mechanisms. An agent asked to sustain eighty correct moves fails on + length alone, long before a switch or a distractor gets a chance to matter. +
++ Restrict the analysis to the 69 episodes on mazes short enough to leave headroom and the ordering + inverts. Gates and switches roughly triple in explanatory power while path length + collapses and stops being significant at all. Switch mazes also record zero solves in 105 + episodes while the progress regression on switches returns only p = 0.08 — the outcome + measure cannot see an effect the solve counts make obvious. + Path length is verified as a difficulty axis; the rest are untested at this difficulty + rather than shown to be inert. +
++ All three end essentially every episode on the stall watchdog, but they arrive there by + different routes. Claude dies early, at a median of 35 steps, by pushing repeatedly into walls. + Kimi and Qwen survive to a median of 59 and 57 by turning and retreading ground they have + already covered. Kimi operates mechanisms more successfully than either of the others. +
++ Because the ranking inverts depending on whether you read solves or progress, this run cannot + say which of the three is better at the task — which is why the results above are reported + side by side rather than ranked. +
++ Kimi and Qwen spend 20 to 26 times more output tokens per newly discovered tile than Claude, + last around 1.6× longer, and see slightly more of the maze — and solve fewer of them. + Spending is not the constraint either: Claude's median query is 289 output tokens, half a + percent of the 64k it was given, with no truncation anywhere in the run. +
++ Where the extra thinking goes is more telling than how much of it there is. Claude's thinking + contracts as an episode runs rather than escalating, and contracts hardest exactly + where it should expand — after a move that achieved nothing, its median thinking is 234 + tokens against 579 after a move that worked. Reasoning depth is not what is missing. + The agent is thinking hard about a state it has misread, and thinking less precisely when the + world tells it so. +
++ This release establishes that the puzzle is genuinely hard for current models in one modality, + and that the environment can attribute a failure to a stage rather than averaging it into a + single score. That is the groundwork. The point of building the task this way is that the + structure carries no domain knowledge, so the identical maze can be re-rendered without becoming + a different problem — and that is what the full benchmark will do. +
+The full v2.0 benchmark will render the identical maze in three domains:
++ Because the underlying puzzle will be identical across all three, a model that clears one domain + will still have to clear the other two — and that is what turns “did it + generalize?” from an inference into a measurement. It will also let us settle what this + release cannot: whether a failure comes from misreading the maze or from acting badly in it, + which becomes separable the moment the same task is presented a different way. +
++ This release leaves us with a few open questions that we are going to explore immediately after, + on the path to the full cross-domain version of the benchmark: +
++ Want to evaluate your model on MultiNet v2.0? + The submission flow for the full benchmark is being built now. To get your model or agent onto the + v2.0 leaderboard, + get in touch with us + or join the working group on + Discord. +
+@techreport{guruprasad2026multinetv2r1,
+ author = {Pranav Guruprasad and Sean Rivera and Helen Lu and Arushi Jain and Hangliang Ren and Harshvardhan Sikka},
+ title = {MultiNet v2.0 Release 1: A Substrate for Benchmarking Long-Horizon Action with Causal Reasoning in Frontier Models},
+ institution = {Manifold Research and Metarch AI},
+ year = {2026},
+ note = {https://multinet.ai/static/pages/Multinetv2R1.html}
+}
+