Agents, world models and multi-agent systems
World models that survive intervention
A learned model earns the name “world model” only when the relations that should remain stable survive controlled change, while the consequences of the intervention change in the right direction.
TLDR
- Sequence prediction rewards resemblance to familiar futures; intervention tests whether the model knows what can be changed.
- An action-conditioned predictor can still fail when a sensor, mechanism, policy or environment parameter shifts.
- World-model quality should be reported as a survival profile, not compressed into one accuracy score.
- The proposed benchmark changes one causal property at a time and measures effect direction, invariant preservation, revision locality and planning regret.
- Use a model for consequential planning only inside the intervention classes it has survived, with abstention outside that envelope.
The amber light that moved a crate
Kestrel, a warehouse robot, can push a loaded crate to within two centimetres of a marked bay. Its learned simulator predicts the next ten camera frames, the arm trajectory and the final crate position. Validation error is low. Operators trust it enough to let the planner rehearse pushes inside the model before acting.
During training, the warehouse used amber ceiling lights whenever the floor was in high-friction safety mode. The correlation was perfect. The model therefore learned a useful shortcut: amber scenes implied short crate slides. Nobody noticed because every held-out sequence preserved the same maintenance routine.
Then the lighting system was replaced. Amber became the normal colour, while a newly coated floor produced much lower friction. Kestrel’s simulated futures still showed short slides. The planner selected a stronger push. The real crate crossed the bay and entered a pedestrian buffer.
The puzzle is not that the model made an error. Every finite model does. The puzzle is that it could be excellent at predicting recorded sequences while representing the wrong variable as the bearer of change. The amber light did not move the crate. It merely travelled with the thing that did.
What, then, would justify calling Kestrel’s internal simulator a model of the world rather than a model of the warehouse’s habits?
The theatre behind the trajectory
The modern use of “world model” covers several useful but different objects. A model may compress observations, predict a latent state, generate video, estimate reward, support search, or provide a simulator for control. The shared intuition is older than deep learning: an agent can act more intelligently if it can run an internal surrogate ahead of reality. Sutton’s Dyna joined learning from real interaction with planning through learned dynamics, while later systems such as PlaNet, World Models, MuZero and Dreamer showed how learned latent dynamics can support effective planning or policy learning in bounded domains (Sutton, 1991), (Ha and Schmidhuber, 2018), (Hafner et al., 2019), (Schrittwieser et al., 2020), (Hafner et al., 2023).
That achievement matters. It does not, however, settle what the model has captured. A trajectory contains many regularities. Some arise from mechanisms that would keep operating under change. Others arise from selection, policy, camera position, maintenance practice or coincidence. A learner rewarded for next-step accuracy can use any of them.
A theatre presents the same scene one hundred nights. An actor pulls a blue rope; a door opens; a bell rings. The curtain is red whenever the stagehand has connected the rope to the door. A sequence learner predicts the scene perfectly.
Now change one property. Keep the curtain red, but connect the blue rope to the bell instead. What should the model predict after the pull? A pattern model may replay the familiar scene. A mechanism model should move the bell and leave the door closed. The intervention is valuable because it separates relations that observation had fused.
Two models can agree on every recorded night
Suppose the door state is D, the rope pull is A, the curtain colour is C, and the hidden coupling is L. During the recorded run, red curtains and connected latches always co-occur: C = L. The door opens when the rope is pulled and the latch is connected:
On the observed distribution, both models have zero error. Under do(C = 1, L = 0), they disagree. The mechanism model predicts a closed door. The shortcut model predicts an open one. No amount of ordinary train-test splitting can resolve this if every split preserves the same coupling.
Training contains the rows (curtain, latch, pull, door): (0,0,0,0), (0,0,1,0), (1,1,0,0), (1,1,1,1). Both candidate rules fit all four. Add one intervention row, (1,0,1,0), and the ambiguity disappears. The new row does not add much data. It adds a different kind of information.
This is the first principle of the paper: prediction tests fit to a distribution; intervention tests the organisation of possible distributions. A causal model does more than assign probabilities to what usually follows. It represents how those probabilities would change when a variable is set, a mechanism is replaced, or a policy selects states that passive observation rarely visits. Schölkopf and colleagues express the distinction as a move from one observational distribution to a family of interventional distributions (Schölkopf et al., 2021).
That does not mean every learned simulator must recover the one true causal graph of reality. The stronger claim is unnecessary and often unidentifiable. The operational requirement is narrower: the model must preserve the causal distinctions needed by the actions and decisions for which it will be used.
flowchart TD A["The amber light that moved a crate"] --> B["The theatre behind the trajectory"] B --> C["What must survive when the<br/>world changes"] C --> D["The intervention survival profile"] D -. "re-test" .-> A classDef first fill:#0a1424,stroke:#D95545,stroke-width:2px,color:#e6f3ff classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff class A first class B,C,D step
What must survive when the world changes
A world model need not reproduce every pixel, molecule or rule. MuZero is the clearest corrective to that demand. It learned an iterable representation that predicted reward, value and policy quantities useful for search, rather than reconstructing the complete game state. Its success shows that world-model adequacy is relative to a planning problem, not to exhaustive imitation of reality (Schrittwieser et al., 2020).
Yet task relevance does not excuse causal fragility. A model can be compact and still preserve the wrong distinctions. Conversely, a high-fidelity video predictor can spend capacity on textures while missing the variables that determine control. Lambert and colleagues documented a related objective mismatch: lower one-step dynamics error need not produce better control, because the errors that matter to a policy are not distributed like the average errors in a dataset (Lambert et al., 2020).
The right question is therefore not “Does the model contain the world?” It is: Which relations must remain valid for the intended interventions, and which changes must the model propagate?
A minimal anatomy
Consider a partially observed environment. The world occupies a latent state st. The agent chooses an action at. Uncontrolled influences such as gusts, wear and human movement enter as ut+1. A mechanism configuration m determines how the state changes. Sensors then produce observation ot, with their own noise vt.
A sequence predictor estimates what comes next under the data-generating routine it saw. An intervention changes that routine deliberately. There are at least four distinct changes:
| Change | Example | What should move | What should stay invariant |
|---|---|---|---|
| Action intervention | Push with 20 N instead of 10 N | Action descendants and resulting trajectory | Material properties, sensor calibration, unrelated objects |
| Observation intervention | Replace RGB camera with depth sensor | Observation mapping and uncertainty | Underlying physical dynamics |
| Mechanism intervention | Change friction, mass or actuator delay | The affected transition relation and its descendants | Untouched mechanisms |
| Policy intervention | Visit states avoided by the training controller | State occupancy and action distribution | Environment response at a given state and action |
A robot learns to balance a pole from colour video. Replace the camera with a sensor that reports pole angle and angular velocity directly. The physical system is unchanged. Would the learned model need to relearn balance from scratch?
If its latent state entangles lighting with dynamics, likely yes. If it has separated state estimation from transition structure, only the observation interface should change. This is a replacement test for modularity between seeing and evolving.
At time t, copy the complete simulator state, including the same hidden gust that will arrive one second later. In branch A, the robot brakes. In branch B, it accelerates. A useful counterfactual comparison asks how the action changes the outcome while the exogenous circumstances remain fixed.
If each rollout resamples the gust, the difference between branches mixes action effect with different luck. The videos may look diverse, yet the causal contrast is unmeasured. Counterfactual consistency requires paired worlds, rather than only two plausible samples.
Survival is stronger than robustness, but weaker than truth
Ordinary robustness often means that output changes little under a perturbation. That is wrong for many interventions. Double the braking force and the stopping distance should change. Replace a camera and the physical trajectory should not. A model must therefore know where sensitivity belongs.
A world model survives an intervention class when it does four things together: it changes the predicted descendants in the correct direction and approximate magnitude; it preserves relations outside the intervention’s causal reach; it localises new uncertainty or required revision to the affected mechanism; and the plan selected through the model remains within a declared performance or safety bound.
This definition is deliberately operational. Passing does not prove that latent coordinate 17 “is” friction, nor that the complete learned graph matches the metaphysics of the world. Multiple internal representations can support the same correct intervention responses. Bisimulation-based work makes a related point: states can be grouped when they imply the same reward and transition consequences for control, even when their pixels differ (Zhang et al., 2021).
Still, one should not infer causal variables from unsupervised representation learning by optimism alone. Locatello and colleagues showed that disentanglement is not identifiable without inductive biases on models and data. Interventions, environment labels, object structure or weak supervision may supply such bias, but they are assumptions and experimental resources, not free discoveries (Locatello et al., 2019).
The intervention survival profile
Most evaluation compresses model quality too early. A single rollout score, mean prediction error or task return hides whether the model succeeded by preserving the right structure or by exploiting a stable proxy. The practical alternative proposed here is an Intervention Survival Profile, or ISP. It is not a consciousness test, an intelligence score or a claim of complete causal discovery. It is a deployment-facing record of which changes the model has earned the right to simulate.
Six axes, one deployment envelope
The profile contains six measurements. They should be reported separately because a model can be strong on one and weak on another.
1. Familiar fit. Measure next-state, latent-state or observation prediction on the ordinary operating distribution. This remains necessary. A model that cannot represent the familiar regime is not rescued by causal vocabulary.
2. Action contrast. Starting from matched states, vary the action while holding relevant exogenous conditions fixed. Score the direction and magnitude of the predicted difference, not only each rollout in isolation.
3. Mechanism transfer. Change one environment mechanism such as friction, mass, delay, elasticity or reward rule. Test whether the model propagates the change to its descendants while retaining unaffected relations.
4. Counterfactual pairing. Fork the same latent state and, where the simulator permits it, preserve the same exogenous noise. Compare the predicted action effect with the realised paired effect. This catches models that generate two plausible futures without a stable causal contrast.
5. Revision locality. After a small calibration set from the changed environment, measure how much of the model must move. A sparse mechanism change should not require global representation collapse. Locality is evidence of useful factorisation, though not proof of a unique causal decomposition.
6. Planning consequence. Let a planner choose actions through the model, then execute them in the intervened environment. Report regret, constraint violation and abstention quality. The decisive test of a decision model is not whether its imagined future looks right, but whether acting through it remains acceptable.
The output is a profile plus a declared intervention envelope. For example: “validated for camera replacement, payloads from 2 to 8 kg, floor-friction coefficient from 0.35 to 0.55, and actuator delay below 80 ms; unsupported for deformable objects or human contact.” This sentence is more useful than “world-model accuracy: 93%”.
Score the difference, the residue and the decision
Each intervention trial should produce three records. The difference record asks whether the changed variable produced the right change in its descendants. The residue record asks whether unrelated predictions drifted. The decision record asks whether a planner using the model selected an acceptable action. Keeping the records separate prevents a dramatic but directionally correct effect from hiding widespread collateral errors.
For a paired action test, let y(a) be the realised outcome after action a, and let ŷ(a) be the model prediction. Compare effects rather than endpoints:
Now measure invariant leakage. Suppose friction changes, but gripper geometry, camera calibration and the position of a distant pallet should not. For each declared invariant quantity zk, record the model’s unwanted change. The benchmark should publish the vector of leaks, rather than only their mean, because one safety-critical invariant can matter more than twenty harmless ones.
A small numerical case shows why. A model predicts that doubling push force increases crate travel by 0.8 metres; the measured increase is 0.75 metres, so effect error is 0.05. Yet the same rollout moves a stationary human avatar by 0.4 metres even though no contact occurs. An average scene metric may still look good. The residue record exposes that the model has not held the rest of the world fixed.
Revision locality needs a similarly careful denominator. Parameter distance alone is architecture-dependent. Prefer behavioural locality: after calibrating the changed friction mechanism, rerun a library of unaffected tests and count regressions. Also report the amount of new data and computation required. A model that preserves old behaviour only after full retraining has adapted, but it has not demonstrated sparse repair.
Finally, test calibration against the intervention boundary. Give the model changes just inside, just outside and far outside its validated range. A useful system should become less certain near the edge and abstain beyond it. This is not guaranteed by a low prediction error or an ensemble. It must be measured against realised failures. A survival profile is credible only when it includes both competence and the model’s ability to recognise unsupported change.
A benchmark must change causes, not decorate inputs
A strong benchmark begins with a configured environment whose manipulable variables are known. CausalWorld exposes interventions on physical and visual variables in robotic manipulation, allowing training and test distributions to differ along selected factors (Ahmed et al., 2020). The Causal Chambers extend the principle to automated physical devices whose variables can be manipulated and whose causal models are sufficiently understood to support ground-truth tests (Gamella, Peters and Bühlmann, 2025).
Recent evaluation work also shows why paired intervention matters for generative models. The What-If World preprint starts from one real frame and asks models to generate two futures that differ in one controlled physical variable. Its authors report that individually plausible videos can fail to diverge in the causally required way. That result is preliminary and benchmark-specific, but the diagnostic principle is sound: judge the pair and the intended difference, not only the beauty of each sample (Cai et al., 2026).
A medical pump controller has been moved to a new device. You may perform one harmless calibration intervention before dosing: change the display brightness, pulse the motor without fluid, or vary line pressure within a safe range. Which probe should the world model request?
The best probe is not the easiest prediction. It is the intervention expected to separate rival mechanism hypotheses that would choose different doses. Under scarcity, a model should expose its uncertainty about structure and seek the observation with the highest decision value.
The warehouse team tests four shifts. A camera-colour change should alter only the observation encoder. A payload increase should alter acceleration and stopping distance. A floor-friction change should alter slide distance but not gripper kinematics. An actuator-delay increase should shift timing while preserving static geometry.
Kestrel passes the camera swap and payload range, partially passes friction after five calibration pushes, and fails delay because its latent state contains no explicit timing variable. The correct release decision is not “world model passed” or “failed”. It is: release for payload and camera variation, gate low-friction operation behind calibration, and prohibit delayed-actuator deployment until the state representation is repaired.
The smallest useful protocol
The proposed Intervention Survival Benchmark can begin with five stages:
- Define the task, candidate-system boundary, action space and safety constraints.
- List manipulable variables and group them into observation, action, mechanism and policy interventions.
- Create matched pairs or forks that differ in one causal property, with nuisance variables fixed or recorded.
- Score effect error, invariant violation, uncertainty, update locality and downstream planning consequence.
- Publish the survival envelope, failed interventions and prohibited inferences alongside the average score.
Models whose internal dynamics are organised into reusable mechanisms should adapt to a sparse mechanism shift with fewer samples and less unrelated parameter drift than equally accurate monolithic predictors. Evidence would strengthen the hypothesis if locality predicts lower post-shift planning regret across several intervention families. It would weaken it if monolithic models match transfer with no greater data or revision cost. A rival explanation is simple capacity: larger models may appear modular because they contain redundant routes. The smallest useful test compares matched-capacity models on environments with known sparse mechanism changes.
stateDiagram-v2 [*] --> Claim state "Two models can agree on every<br/>recorded night" as Claim state "A minimal anatomy" as Test state "Survival is stronger than<br/>robustness, but weaker than<br/>truth" as Revision Claim --> Test: expose mechanism Test --> Decision: evidence survives Test --> Revision: rival survives Revision --> Claim: narrow or rebuild Decision --> [*]
A benchmark you can run
The following synthetic lab makes the identification problem visible without a large neural network. A crate’s displacement depends on push strength, floor friction and wind. During training, curtain colour perfectly tracks friction. Two linear models are fitted:
- the proxy predictor uses curtain colour as if it governed motion;
- the mechanism model uses the friction variable.
Because colour and friction are identical in the training data, both models learn the same coefficients and achieve the same error. The benchmark then intervenes on colour while holding friction fixed. This is deliberately a test harness, not a causal-discovery algorithm. It demonstrates why observational fit cannot choose between causally different representations.
With a fixed random seed, both models achieve about 0.05 units of root-mean-square error on training and ordinary test data. When the curtain colour is flipped independently of the floor, the proxy model’s error rises to roughly 1.04 while the mechanism model remains near 0.05. On paired pushes, the proxy’s action-effect error is about 1.08. A planner using it accumulates about 1.76 units of regret in the toy objective.
These numbers are synthetic and have no external deployment meaning. Their purpose is logical: identical evidence under one regime can support sharply different decisions after intervention.
Move the scenery while keeping the floor fixed
Choose floor friction, curtain colour and push strength. The “true world” and mechanism model respond to friction. The proxy predictor responds to colour. Set colour equal to friction to recreate the training regime, then flip only the colour.
- True displacement
- 0.75
- Proxy prediction
- 2.10
- Mechanism prediction
- 0.75
- Proxy absolute error
- 1.35
- Mechanism absolute error
- 0.00
What a positive result permits: confidence that the tested representation supports this specific intervention class within the sampled range. What a negative result means: the model has not separated the manipulated property from its proxy, or lacks the state needed to do so. What it cannot establish: a complete causal graph, robustness to untested mechanisms, or safe operation in a real warehouse.
Open the complete Python benchmark
import numpy as np
SEED = 7
rng = np.random.default_rng(SEED)
def proxy_features(x, action, colour, wind):
"""Observation-only model: colour is allowed to stand in for friction."""
return np.column_stack([
np.ones_like(x), x, action, action * colour, wind
])
def mechanism_features(x, action, friction, wind):
"""Mechanism-labelled model: motion responds to friction."""
return np.column_stack([
np.ones_like(x), x, action, action * friction, wind
])
def true_transition(x, action, friction, wind, noise=0.0):
# Low friction gives 1.4 units of motion per action unit.
# High friction reduces this coefficient by 0.9.
return x + action * (1.4 - 0.9 * friction) + 0.25 * wind + noise
def fit_ols(features, target):
weights, *_ = np.linalg.lstsq(features, target, rcond=None)
return weights
def rmse(prediction, target):
return float(np.sqrt(np.mean((prediction - target) ** 2)))
# 1. Observational training data. Colour and friction are perfectly coupled.
n = 5_000
x = rng.normal(0.0, 0.7, n)
friction = rng.integers(0, 2, n)
colour = friction.copy()
action = rng.uniform(-2.0, 2.0, n)
wind = rng.normal(0.0, 1.0, n)
noise = rng.normal(0.0, 0.05, n)
y = true_transition(x, action, friction, wind, noise)
proxy_w = fit_ols(proxy_features(x, action, colour, wind), y)
mech_w = fit_ols(mechanism_features(x, action, friction, wind), y)
# 2. Matched test generator.
def make_test(size, intervene_on_colour=False):
x = rng.normal(0.0, 0.7, size)
friction = rng.integers(0, 2, size)
colour = 1 - friction if intervene_on_colour else friction.copy()
action = rng.uniform(-2.0, 2.0, size)
wind = rng.normal(0.0, 1.0, size)
noise = rng.normal(0.0, 0.05, size)
y = true_transition(x, action, friction, wind, noise)
return x, friction, colour, action, wind, y
for name, intervention in [
("ordinary test", False),
("camera-colour intervention", True),
]:
x_t, f_t, c_t, a_t, w_t, y_t = make_test(3_000, intervention)
proxy_pred = proxy_features(x_t, a_t, c_t, w_t) @ proxy_w
mech_pred = mechanism_features(x_t, a_t, f_t, w_t) @ mech_w
print(f"{name:28s} proxy={rmse(proxy_pred, y_t):.3f} "
f"mechanism={rmse(mech_pred, y_t):.3f}")
# 3. Paired action-effect test with the same state, wind and friction.
m = 2_000
x_p = rng.normal(0.0, 0.7, m)
f_p = rng.integers(0, 2, m)
c_p = 1 - f_p
w_p = rng.normal(0.0, 1.0, m)
a0 = np.full(m, 0.4)
a1 = np.full(m, 1.6)
true_effect = (
true_transition(x_p, a1, f_p, w_p)
- true_transition(x_p, a0, f_p, w_p)
)
proxy_effect = (
proxy_features(x_p, a1, c_p, w_p) @ proxy_w
- proxy_features(x_p, a0, c_p, w_p) @ proxy_w
)
mech_effect = (
mechanism_features(x_p, a1, f_p, w_p) @ mech_w
- mechanism_features(x_p, a0, f_p, w_p) @ mech_w
)
print("paired effect MAE ",
f"proxy={np.mean(np.abs(proxy_effect - true_effect)):.3f}",
f"mechanism={np.mean(np.abs(mech_effect - true_effect)):.3f}")
# 4. Planning test: choose a push that reaches target displacement 1.0.
actions = np.linspace(-2.5, 2.5, 21)
target = 1.0
def choose_action(kind, friction, colour):
costs = []
for a in actions:
if kind == "proxy":
pred = proxy_features(
np.array([0.0]), np.array([a]),
np.array([colour]), np.array([0.0])
) @ proxy_w
else:
pred = mechanism_features(
np.array([0.0]), np.array([a]),
np.array([friction]), np.array([0.0])
) @ mech_w
costs.append(float((pred[0] - target) ** 2))
return actions[int(np.argmin(costs))]
regret = {"proxy": [], "mechanism": []}
for friction in rng.integers(0, 2, 2_000):
colour = 1 - friction
oracle_cost = min(
(true_transition(0.0, a, friction, 0.0) - target) ** 2
for a in actions
)
for kind in regret:
selected = choose_action(kind, friction, colour)
realised = true_transition(0.0, selected, friction, 0.0)
regret[kind].append((realised - target) ** 2 - oracle_cost)
print("mean planning regret ",
f"proxy={np.mean(regret['proxy']):.3f}",
f"mechanism={np.mean(regret['mechanism']):.3f}")Run with Python 3 and NumPy. The random seed makes the printed values stable within ordinary numerical variation. Change the training relation from colour = friction.copy() to randomised colour to see how a single intervention family removes the proxy’s advantage.
Why the planner can make the model worse
A model used only for passive forecasting encounters states drawn from the world. A planner searches the model for states that look valuable. This changes the distribution again. Small inaccuracies can become attractors because the optimiser actively seeks the region where the model is most optimistic.
A learned driving model is accurate for steering angles between −10° and +10°, the range used by the training policy. At +18°, sparse data cause it to underestimate tyre slip. The planner discovers that repeated +18° turns appear to cut a corner at high speed without losing traction. In the real vehicle, the tyres saturate and the path leaves the lane.
Average model error may remain small because the dangerous region occupies little dataset mass. Planning makes it central. The corrective benchmark must therefore include policy interventions and adversarial search for actions where ensemble disagreement, calibration error or model-real divergence rises.
This failure is not unique to neural systems. Any approximate simulator can be exploited. The practical implication is to couple planning with an epistemic boundary: action proposals should carry support, uncertainty and intervention-coverage information. Unsupported actions should trigger a real-world probe, a conservative fallback or human review rather than a confident imagined trajectory.
A stable, low-stakes process with narrow actions may be served perfectly well by a predictive model. Weather nowcasting, video compression or routine demand forecasting can create value without supporting arbitrary interventions. Even in control, a task-specific value model may outperform a more interpretable simulator.
The argument of this paper is conditional: when a model is used to choose consequential actions under mechanism, sensor, policy or environment change, ordinary predictive validation is insufficient. Do not impose the full benchmark where the deployment claim is narrower. Do not make the deployment claim broader than the benchmark.
Failure modes of the benchmark itself
Intervention testing can also mislead. A benchmark may leak the changed variable through labels, making the task a lookup problem. Its simulator may encode cleaner modularity than the real world. Paired rollouts may fail to preserve hidden exogenous state. A small list of interventions may reward specialised engineering while missing new mechanisms. A planner may pass because its objective ignores the harm that matters.
For this reason, the benchmark manifest should record who can set each variable, whether the intervention is hard or soft, which variables are held fixed, what hidden state is reset, how intervention realism was checked, and which decisions the metric is meant to license. Physical testbeds such as Causal Chambers help because they allow controlled manipulation outside a purely digital simulator, but no chamber reproduces an open warehouse, road or clinic in full.
Established in bounded tasks: learned dynamics can support planning, data-efficient control and imagination-based policy learning. Still contested: whether current large-scale world models learn reusable causal variables or merely increasingly broad predictive regularities. Practitioner synthesis: the six-axis ISP and its release gate. Open hypothesis: sparse mechanism structure will predict sparse repair and lower post-intervention regret.
The release gate
A useful assurance rule has three layers. First, verify familiar fit and state observability. Second, require intervention evidence that matches the intended action and change classes. Third, bind authority to the tested envelope. A model may propose outside that envelope, but the system should not execute the proposal as though the world model had validated it.
Release a world-model planner only when every consequential action is covered by a tested intervention class, planning regret stays within the declared bound, and unsupported changes trigger abstention or a reversible probe. A high average prediction score cannot substitute for any of these conditions.
This rule also changes research reporting. A paper should go beyond show generated futures or reward curves. It should publish the intervention manifest, matched pairs, invariant checks, planning consequences, uncertainty behaviour and negative results. The 2026 stable-worldmodel platform is one current attempt to standardise world-model baselines, data pipelines and evaluation across controllable visual, geometric and physical variation (Maes et al., 2026). As a preprint and platform report, it should earn authority through replicated use rather than be treated as a universal benchmark standard.
sequenceDiagram participant Q as Question participant M as Mechanism participant E as Evidence participant D as Decision Q->>M: The amber light that moved a crate M->>E: Two models can agree on every recorded night E-->>M: compare rival explanations E->>D: Release only the intervention contract you can defend D-->>Q: revise scope or act
Release only the intervention contract you can defend
When someone presents a learned simulator as a world model, stop asking only whether its rollouts look plausible or whether average prediction error is low. Ask a harder, more useful question: which controlled changes has this model survived?
The answer should name the intervention, the matched baseline, the variables held fixed, the effect that moved, the relations that remained invariant, the uncertainty produced, the calibration data required and the consequence for planning. Without that record, “world model” describes an architectural aspiration rather than an earned operational capability.
This changes model selection. Prefer the model with the better intervention profile for the intended decision, even when another has slightly better ordinary reconstruction. It changes data collection. Spend some interaction budget on interventions that break plausible shortcuts, rather than gathering more samples from the same routine. It changes architecture. Separate observation formation, state estimation and transition mechanisms where the deployment expects them to change independently. It changes governance. Bind execution authority to a tested intervention envelope and require abstention, calibration or reversible probing beyond it.
The decision is not to demand a complete causal theory before using any predictor. It is to match the strength of the model claim to the strength of the action. A narrow predictive model can be enough for a narrow stable task. A model asked to plan through changing physics, sensors, policies or institutions must meet a stronger burden.
A sequence model says, “this usually comes next”. A world model fit for intervention says, “change this, these consequences move, those relations remain, and here is where I no longer know”. For consequential agents, that second contract is the one worth releasing.
Glossary
- Action intervention
- Setting or varying an agent action while controlling the starting state and relevant exogenous conditions.
- Counterfactual pairing
- Comparing alternative actions from the same latent state while preserving the same background circumstances as far as the simulator permits.
- Intervention envelope
- The declared set and range of changes for which a model has evidence of acceptable prediction and planning behaviour.
- Mechanism intervention
- Changing how a variable is generated, such as altering friction, mass, delay or a causal coupling.
- Planning regret
- The performance gap between the best achievable action under the changed world and the action selected through the learned model.
- Revision locality
- The extent to which adapting to a sparse environmental change leaves unrelated model components or behaviours stable.
- World model
- Here, an internal state-and-dynamics model used to estimate action-conditioned possibilities for prediction or planning. The term does not imply exhaustive representation or causal truth.
References
- Ahmed, O., Träuble, F., Goyal, A., Neitz, A., Bengio, Y., Schölkopf, B., Wüthrich, M. and Bauer, S. (2020). CausalWorld: A robotic manipulation benchmark for causal structure and transfer learning.
- Ball, P. J., Parker-Holder, J., Pacchiano, A., Choromanski, K. and Roberts, S. (2021). Augmented world models facilitate zero-shot dynamics generalization from a single offline environment. ICML.
- Gamella, J. L., Peters, J. and Bühlmann, P. (2025). Causal chambers as a real-world physical testbed for AI methodology. Nature Machine Intelligence.
- Ha, D. and Schmidhuber, J. (2018). World Models.
- Hafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H. and Davidson, J. (2019). Learning latent dynamics for planning from pixels. ICML.
- Hafner, D., Pasukonis, J., Ba, J. and Lillicrap, T. (2023). Mastering diverse domains through world models.
- Lambert, N., Amos, B., Yadan, O. and Calandra, R. (2020). Objective mismatch in model-based reinforcement learning. Learning for Dynamics and Control.
- Lee, K., Seo, Y., Lee, S., Lee, H. and Shin, J. (2020). Context-aware dynamics model for generalization in model-based reinforcement learning. ICML.
- Locatello, F., Bauer, S., Lucic, M., Rätsch, G., Gelly, S., Schölkopf, B. and Bachem, O. (2019). Challenging common assumptions in the unsupervised learning of disentangled representations. ICML.
- Maes, L. et al. (2026). stable-worldmodel: A platform for reproducible world modeling research and evaluation. Preprint.
- Schölkopf, B., Locatello, F., Bauer, S., Ke, N. R., Kalchbrenner, N., Goyal, A. and Bengio, Y. (2021). Toward causal representation learning. Proceedings of the IEEE.
- Schrittwieser, J. et al. (2020). Mastering Atari, Go, chess and shogi by planning with a learned model. Nature.
- Sutton, R. S. (1991). Dyna, an integrated architecture for learning, planning, and reacting. ACM SIGART Bulletin.
- Wang, T., Du, S. S., Torralba, A., Isola, P., Zhang, A. and Tian, Y. (2022). Denoised MDPs: Learning world models better than the world itself. ICML.
- Cai, K. et al. (2026). What-If World: A causal benchmark for general world models in embodied scenarios. Preprint.
- Zhang, A., McAllister, R., Calandra, R., Gal, Y. and Levine, S. (2021). Learning invariant representations for reinforcement learning without reconstruction. ICLR.