Each physim task drops an agent into a procedurally generated world with
hidden laws behind an anonymous port interface: it can set input
ports in [−1,1] and read noisy, unnamed sensors — nothing else. These pages
show what those worlds actually are, from two perspectives: the god view
(evaluator-only: the hidden lattice, the wiring, the true collective modes,
films of the dynamics) and the agent view (exactly what the agent
gets). Under the hood every world is a grid of simple units (24×24 up
to 96×96 cells) updated by one local rule per track family; everything an
agent encounters — materials, chemistry, organisms, evolution — emerges
from that rule. Time advances in discrete ticks; experiments spend a
tick budget.
Coupled tanh lattices: collective bistability, hysteresis, per-region
timescales, slow fatigue. The tutorial track that ends in a moody, 8-region
material (D4) frontier agents still fail.
Reaction–diffusion: self-sustaining "atoms", movable measurement apparatus,
drifting objects, two coupled species, and an excitable wave medium (C4) whose
timing physics breaks every frontier model.
Make the food finite and chemistry becomes ecology: carrying capacity,
competition, natural selection, the exclusion boundary — and B2, where
excitable waves are the weather that feeds the world.
Add heredity: a mutable trait field new tissue copies from its parents.
Gene pools shift under selection the world itself applies — storms, famines,
port-driven eras — and the population's history is written in its genotypes.
How the worlds work — the shared machinery
All four tracks are instances of one template: a multi-channel lattice
field theory (diffusion/mixing + a pointwise nonlinear reaction + input
fields + noise). The track pages describe each reaction family; everything
below is common.
The idea: why the worlds are built this way
The benchmark asks one question: can an agent do science? Not recall
science — do it. That requires a world where:
There are real laws to find, at the right level. The cell-update
rule is the "microphysics", deliberately impossible to read off from outside
(sensors are too coarse, too noisy, too few). But the dynamics guarantee that
a small number of collective quantities — branch states, object counts,
wave rates, populations, gene-pool means — obey simple, discoverable laws.
Exactly like real physics, the useful theory lives at a coarser level than
the mechanism; the agent must find the level itself. Nothing in the interface
hints that regions, objects, species, or genotypes exist.
Observation is an achievement, not a given. Sensors are anonymous,
scrambled, biased, sometimes dead. Before any physics can start, the agent has
to calibrate its own senses — find the noise floor, identify dead channels,
work out polarities and groupings. "Learning to use your hands before
building instruments."
Experiments cost. A tick budget forces choices: sweep slowly or
probe many ports? Long releases or many repetitions? Strategy, not stamina,
separates agents.
The test is out-of-sample by construction. After exploration, the
world poses contracts on fresh copies of itself (same laws, new random
start). Memorised trajectories are useless; only laws transfer.
What the agent can see and do
The agent never sees the grid, the wiring, or any panel marked "god view"
on these pages. Its entire universe is:
6–10 input ports ("dials"). Each port either projects a
smooth, invisible field onto one patch of the grid (a force on the world) —
or, in apparatus worlds, secretly operates a sensor instead. The agent does
not know which is which, or where anything points. It sets the dials tick by
tick, each in [−1, +1].
24–60 output sensors ("gauges"). Each live sensor reads the
average of one small random patch, times a random gain (possibly negative),
plus a random offset and fresh noise per tick. Several gauges are dead: pure
noise around a constant. Channel order is shuffled; nothing is labelled.
Actions (through a fixed tool interface, no other access):
run(program) (hold/ramp dials, get per-sensor summaries),
run_policy(code) (closed-loop control executed inside the world
loop), reset() (fresh initial state, same laws, costs budget),
then ready() → contracts, answer(...),
answer_prep(policy), submit_theory(simulator).
Scoring, all on fresh world-copies the agent never touched:
prediction contracts answered with points or quantiles and scored by a
proper distributional rule (CRPS vs god-mode truth ensembles, noise floor
subtracted); preparation policies run on 5 fresh clones; optional executable
theories replayed against every contract. Full mechanics:
the scoring page.
Everything an agent can access runs in a separate process from
the world engine; hidden state, wiring, and ground-truth ensembles never cross
that boundary. Worlds are procedurally generated from a seed (plus an optional
evaluator-side salt, so public code cannot reproduce a live evaluation
world).