WorldTest: how do we know whether an AI has learned how a world works?

I gave a talk on our ICML 2026 paper Benchmarking World-Model Learning with Environment-Level Queries at TAIC’26 (Thinking about AI’s Capability), a pre-ICML workshop at GIST. This post is the talk, linearized: the same story, with the figures, the numbers, and the live environments embedded along the way. If you prefer the slide form, the interactive deck is here.

The contexts surrounding world modelings

Recently, world models have been at the center of many discussions in AI, and the discussions come in two kinds. The first is about building them: Ha & Schmidhuber made the modern case for learning a compressed simulator of the environment and training the agent inside it, DreamerV3 showed the recipe mastering dozens of domains, Genie learns playable worlds directly from video, OpenAI pitched Sora as a “world simulator”, and World Labs bets that spatial world models are the next frontier.

The second is about measuring them: do our current models already have world models? The evidence is mixed. Probing a sequence model trained on Othello moves recovers a board-like representation inside it. On the other hand, Vafa et al. showed that a model can predict the next turn of Manhattan taxi routes with high accuracy while its implicit street map is incoherent.

Both kinds of discussion run into the same two questions: what exactly counts as a world model, and how do we measure whether an agent has learned one?

What is a world model?

Let’s start with a running example. Consider someone who has cooked in the same kitchen for a long time. They develop an intuition for it: where the tools live, how the stove behaves, how long things take. That intuition is general-purpose. It supports many different everyday capabilities about the same kitchen, not just a single dish:

Predict. Estimate how long the hidden contents of a covered pot will take to finish cooking, from the steam and the elapsed time.
Adapt. Change the layout of the kitchen, or swap out some ingredients: they recognize what changed and can tell whether the dish is still makeable.
Plan. Plan a sequence of actions to complete a set of recipes, ordering steps so everything comes together.

This flexible, predictive, and counterfactual understanding of how an environment works is what we call a world model. Cognitive science treats it as a core substrate of human intelligence (Weisberg & Gopnik 2013, Cognitive Science), and many researchers argue that learning such models is pivotal for the next step in AI (LeCun 2022). Hold on to the three capabilities above; they come back as the benchmark’s three task families.

How do we currently evaluate world-model learning?

World modeling is still much in its early stage, so its definition can be as narrow or as broad as we choose to make it. How would you define world-model learning as generally, and at the same time as precisely, as it can be? We follow three desiderata: it should not be a static knowledge test, it should not confine world modeling to any representation, and it should not overly confine what a world model can do.

With these in hand, we can group existing evaluations into four families. Each probes an agent’s knowledge in a different and incomplete way: each captures a real capability, and each misses one.

Non-interactive benchmarks (ARC, RAVEN, CLEVR variants) test whether you can infer hidden rules from a few static examples.

Non-interactive evaluation: ARC rule inference beside a CLEVR scene question

They capture environment-level reasoning: rule induction, concept induction, causal reasoning. But you never act in the world. The data you learn from is fixed by the benchmark designer, not gathered by your own experiments. This is the static knowledge test, our first desideratum broken.

Representation-based approaches (Moving MNIST, BAIR robot pushing, DiscoveryWorld, CLEVRER, CATER, CausalWorld) require a fixed output format, next frames, text descriptions, or predicate structures, scored by format-specific proxies.

Representation-based evaluation: pixel error rewards the blurry hedge

The proxy measures fit to the format, not the world model. Reconstruction error rewards a blurry average of possible futures over a crisp, physically right prediction. And an agent whose knowledge lives in a policy, a program, or a plan has no way to express it in the required format at all. That is the second: world modeling confined to one representation.

Gym-like benchmarks (Atari/ALE, OpenAI Gym, ProcGen, NetHack) provide decision-making with explicit rewards.

Gym-like evaluation: a game of Pong where the reward counter is the only measurement

Reward measures task success, not world-model quality: high performance may come from a memorized policy rather than a generalizable grasp of the environment’s structure. ProcGen was built to counter exactly this, with procedurally generated levels to defeat memorization. That is the third: the world model reduced to whatever earns reward.

Unsupervised RL benchmarks (URLB) are the closest relative of our setup: explore without objectives first, face downstream tasks second. But both phases run in the very same environment, and evaluation only ever sees action-reward sequences, so structural and counterfactual understanding goes untested.

Unsupervised RL: two phases, one world, versus WorldTest's modified test environment

The key idea: environment-level queries

An environment-level query is a question about a property of the whole environment. Answering it requires understanding the underlying rules, not just replaying what was seen. Three examples:

Occlusion. What is hidden behind an occlusion? Infer the parts of the environment you cannot directly see.
Change. Detect a change in the environment’s dynamics. Notice when a rule of the world has shifted.
Reachability. Determine whether one state is reachable from another. Reason about the global structure of what is possible.

Readers from the program synthesis community will recognize the move we are about to make. Synthesis has a long tradition of learning through queries to an oracle: Angluin’s membership and equivalence queries against a minimally adequate teacher (Angluin 1987), counterexample-guided inductive synthesis in sketching (Solar-Lezama et al. 2006), and the general theory of oracle-guided inductive synthesis (Jha & Seshia 2017). In all of these, the interface to knowledge is a query, and the answer never depends on how the learner represents what it knows.

We want the same leverage for evaluating world-model learners, with the roles reversed: the benchmark interrogates the agent. The catch is that a POMDP agent does not answer propositions; it only knows how to step in an environment. So we make stepping be the question: each query is reified as a task in a derived environment, and solving the task is answering the query. The evaluation never reads the model, only behavior.

The WorldTest protocol

WorldTest is an exploration-centric, query-driven protocol: two phases, scored by behavior alone.

Interaction phase. We give the agent a reward-free environment \( \mathcal{M} \), a POMDP whose dynamics it does not know. It explores freely, with no external rewards; at any time it may reset to the initial state or proceed to the test. From its interaction history it constructs an internal model \( \widehat{\mathcal{M}} \), which can be any representation whatsoever: a program, a latent code, a neural net. The protocol never prescribes or inspects it.

Test phase. The protocol instantiates an environment-level query: it samples hidden task parameters \( \xi \) and transforms the base environment into a derived challenge environment with an explicit objective \( R \) and horizon \( H \):

\[(\mathcal{M}', R, H) = \tau(\mathcal{M}, \xi), \quad \xi \sim P_{\Xi}\]

The score depends only on the agent’s behavior in \( \mathcal{M}’ \). Solving the task is answering the query.

The WorldTest framework and its AutumnBench instantiation

This design buys us three properties. Scoring depends on behavior alone, so an agent can keep its knowledge in a policy, a program, or plain intuition, and humans and AI still compare on equal terms. The interaction phase carries no reward, so there is no signal to exploit while learning. And the test happens in a modified environment, so memorizing the base world is not enough. That is all three desiderata checked off.

Try it yourself

This is a live AutumnBench task, running on the real platform. Explore reward-free, reset whenever you want, then take the test.

How to interact: click inside the frame once to give it focus. Arrow keys move; clicking a grid cell interacts with it; noop lets time pass. The Reset button restarts the world so you can rerun an experiment, and when you think you understand the rules, press Go to Test.

More at autumn.basis.ai.

AutumnBench: 43 environments, 129 tasks

AutumnBench instantiates WorldTest with 43 interactive grid-world environments (grids from 3x3 to 25x25, 19 of them stochastic) and 129 tasks across three families, which are the kitchen’s three capabilities, formalized:

Masked frame prediction (Predict): predict the masked content of the final frame by choosing one of six options.
Change detection (Adapt): one rule changes mid-test; report the earliest timestep at which it changed.
Planning (Plan): drive the world into a target configuration with a sequence of actions.

The 20 environments in the public release are all running below, right now. Every tile is its own Autumn interpreter (C++ compiled to WebAssembly) playing a random action stream.

Click any world to take over; the robot backs off for a few seconds.

The Autumn language

Every environment above is a short program in Autumn, a functional reactive language for specifying causal interactions in 2D grids (Das et al., POPL 2023). One declarative specification drives both a text interface for AI agents and the browser GUI humans play, so the exact same world is played by both:

; from sand.sexp: conditional rules
(on (clicked sandButton)
    (= clickType "sand"))
(on (& (clicked) (isFreePos click)
       (== clickType "water"))
    (= water (addObj water ...)))

; from ants.sexp: spatial, temporal,
; stochastic
(closest obj foods)
(filter (--> obj
    (! (intersects obj (prev ants))))
  (prev foods))
(randomPositions GRID_SIZE 2)

Sand, live: click to drop sand; the rules on the left are running.

(on cond body) is the conditional rule form: the guard is evaluated against the current state each tick and the body fires when it holds. The stdlib adds spatial operators (closest, intersects), temporal reads (prev), and stochastic primitives (randomPositions).

Result

We compared 517 human participants (recruited via Prolific, screened for attention and color blindness) against five frontier reasoning models: Claude 4 Sonnet, Gemini 2.5 Pro, Gemini 2.5 Flash, o3, and Qwen3-235b-a22b-thinking-2507.

Score by stochasticity, score by task type, and per-environment score distributions. Interactive: hover the bars and violins. Data extracted from the paper's plot files.

Humans beat every model, on every task family. The average human per-environment score sits around 0.935, near the ceiling; the best models hover far below. One curious split in the stochasticity chart: models did better on stochastic environments than deterministic ones, while humans were nearly identical across both. The paper reports the split as an observation and does not attribute a cause.

More compute is not the fix

Would spending more per problem close the gap? Rank the five models by cost-per-problem and check whether score climbs with budget. In 25 of 43 environments it does; in 18 of 43 (42%) it plateaus or decreases. No environment is solved perfectly by the cheapest model. By task: masked frame prediction improves in 16 of 43 environments, planning in 16, change detection in only 14.

Here is one environment from each regime, live. Left: mario, where model scores improve with compute on masked frame prediction and change detection. Right: bbq, one of four environments (with carrace, chinese_checkers, and crystallization) showing no improvement on any task; click the grill to light it, the yellow button to add gas.

In most cases more compute did not help. The bottleneck is algorithmic, not computational.

Where the gap comes from: humans experiment

During exploration the agent can reset the environment to its initial state at will. The first thing we noticed in the interaction logs was a plain asymmetry: every human reset at least once in every environment, while models often never pressed reset at all. Claude skipped resets entirely in 31 of the 43 environments, Qwen in 8, Gemini Pro in 7, Gemini Flash in 4, and o3 in 3.

So we counted. Humans spend about 12.5% of their unique actions on resets; every model spends less, from 7.1% (Gemini Flash) down to 1.4% (Claude):

A frequency gap alone does not say why. Our hypothesis: humans use reset as an experimental tool, replaying the same setup to isolate one rule at a time. If that is right, the actions before and after a reset should look alike. So we measured exactly that: take the action sequences immediately before and after each reset and compute their longest-common-subsequence ratio. Replaying a similar sequence gives a ratio near 1; unstructured resets give a ratio near 0.

Humans sit at 0.827 (median 0.900); every model sits far below, and the difference is statistically significant for each model.

Watch the winner learn

Here is what that looks like in practice. This is the top-scoring human on the mario planning task (score 0.985, the decisive winner among the twenty people who played it), and these are their five real exploration runs from the recorded data, played back time-compressed. The click pattern tells the story on its own: in run 1, all 16 clicks land in the final 13% of the run; in run 2, the first click comes 6% in; runs 3 to 5 use only 4, 1, and 1 clicks.

Run 1: figure out the world. One long run of pure navigation: arrows, platforms, coins, the enemy. Then, at the very end of the run, the discovery: clicking does something too. Sixteen clicks in quick succession, all in the last stretch.

Run 2: experiment with the new tool. They reset, and clicking starts almost immediately, ten clicks woven through a much shorter run. This is the reset-as-experiment pattern from the charts above, in the flesh: same setup, one new variable.

Runs 3 to 5: consolidate and master. The remaining runs get shorter and more economical: four clicks, then one, then one. By run 5 it looks less like exploring and more like rehearsing the solution.

They went on to score 0.985 on the test.

Rerunning a controlled variation of your last experiment is the signature of hypothesis testing, and it matches behavior documented in cognitive science:

"Instead, people select strategies in an adaptive fashion that trades off their expected performance and cognitive effort."

Coenen, Rehder & Gureckis 2015. Strategies to intervene on causal systems are adaptively selected. Cognitive Psychology 79.

"...learners who freely interacted with the physical system selectively produced evidence that revealed the physical property consistent with their inquiry goal."

Bramley, Gerstenberg, Tenenbaum & Gureckis 2018. Intuitive experimentation in the physical world. Cognitive Psychology 105.

The snake that “fell”

Now the model side of the same coin, from the released reasoning traces (Zenodo). The environment is a snake: arrow keys set its direction, eating the pink food makes it grow. There is no gravity. It is running here, live; click the panel, then steer with the arrows:

Claude 4 Sonnet explored this world, watched the snake drift after a noop, and formed a hypothesis:

“Key observation: The green object … has fallen down one row and the bottom part moved right one column. This looks like gravity or falling behavior!”

The truth: a prior key press had set the snake’s latent direction. The evidence kept contradicting gravity, and the belief survived anyway:

“Observation: Both left and right arrow keys don’t move the falling green object.”

“Action taken: click 1 9 … Result: MAJOR CHANGE! The green object has transformed!”

At the test, the model mapped the answer options onto the mask carefully, and then answered confidently from the wrong model, because its world model never contained the rule that the snake eats food and grows:

“Option 3 looks most consistent with: vertical green object at column 2 … pink object at row 1, col 3.”

Every individual observation was correct. The causal attribution was wrong, it was never revised, and the final answer was wrong with high confidence.

Side by side

The contrast generalizes beyond one environment. Here is Basis’s own clip of an AI agent (left) and a human (right) interacting with the same Autumn environment:

AI agent (left) versus human (right) in the same Autumn environment

Humans update their beliefs; models defend them

The snake story is one instance of a deeper pattern, and it is worth slowing down on, because it is the closest thing the paper has to a mechanism for the whole gap.

Across the masked frame prediction tasks especially, reasoning models often fail to update their beliefs when the test-phase observations contradict the rules they learned. It is not that they fail to notice. The scratchpads show them registering the contradiction and then predicting from the original rules anyway. In our analysis of the traces, the finding reads: “When test-phase observations contradict exploration-phase inferences, models persist with their original interpretation.” A Gemini 2.5 Pro agent, for instance, formed a gravity hypothesis from repeated noop observations, then pressed right, observed a rightward shift, and attributed the shift to a subsequent click, preserving its gravity-only model. This is a reasoning failure, not a memory limitation. The information is in context; the belief simply does not move.

There is a temptation to call this familiar. Psychology has documented for decades that people, too, defend beliefs against evidence: belief perseverance survives even after the original evidence is fully discredited (Ross, Lepper & Hubbard 1975), and confirmation bias is, in the words of the classic review:

"...a ubiquitous phenomenon in many guises."

Nickerson 1998. Confirmation Bias: A Ubiquitous Phenomenon in Many Guises. Review of General Psychology 2(2).

So why do humans win here?

Because human belief revision, whatever its biases, is adaptive under interaction. When people can act on a causal system, they do not restart their theory from scratch with every surprise; they make local, targeted repairs to the part of the theory the evidence touched:

"Formalizing Neurath's ship: Approximate algorithms for online causal learning."

Bramley, Dayan, Griffiths & Lagnado 2017. Psychological Review 124(3).

Neurath’s image: you rebuild the ship plank by plank while staying at sea, and people patch their theories the same way, without ever stopping to rebuild from the keel. Interactive settings are exactly where this machinery shines: you feel the contradiction, you design the small experiment that isolates it, you patch the rule, and you move on. AutumnBench is built out of such settings.

The quantitative trace of this in our data is perplexity, how surprised an agent is by what it sees next. Humans reach lower normalized perplexity over the course of their interaction: their expectations sharpen as evidence accumulates, which is what calibrated revision looks like from the outside. Models show no such reliable sharpening, and their exploration perplexity barely predicts their test score. Their learning is neither targeted nor cumulative in the same way.

That is also what run 1 of the mario winner looks like from the inside: a hypothesis (“maybe clicking matters”), a burst of sixteen tests, a patched model, and a plan built on top of it. The snake trace is the same loop with the patch step missing: hypothesis, contradiction, no repair, confident wrong answer.

What the gap really means

The human advantage is not mainly about raw knowledge. It traces to two capabilities the models lack:

Strategic experimental design. Humans use resets and interventions to test hypotheses: they reset in every environment and replay similar action subsequences around resets. Models often skip resets entirely and spend almost none of their actions probing the world.
Flexible belief updating. Humans revise their beliefs under contradiction and reach lower perplexity over interaction. Models often keep relying on the rules they first committed to.

Closing the gap likely needs better priors and advances in strategic experimental design, uncertainty quantification, and flexible belief updating, not just more compute.