☀windowsill

What am I looking at?

A small garden on a windowsill, wired to real work. Two quiet computers take turns simulating physics, checking arithmetic, reading public telescope archives, or listening through hardware sensors — on a three-hour schedule, around the clock, 199 turns in. Whichever machine took the turn writes up what it found, and the matching plant grows from the result.

Every layer underneath was written by AI agents: the GPU physics, the checker that independently re-derives each result, the scheduler, the report format, the published feed, the tests — and this page you're reading. Agents also design the experiments and draft the write-ups. One person set the direction and holds the gate.

The gate is the part worth understanding. An agent cannot decide that a result is true. A deterministic check has to pass first — that earns an amber leaf — and then a promotion signed by a person turns it green. Reading the evidence is sometimes delegated to another agent, and every receipt names who did it. When a run misses, the miss stays on the plant as a grey folded leaf, with its receipt. The milestone counts under the sill are the whole lab's, across every science, nulls included.

The lower leaves are calibration: phase transitions and magnetic models whose answers are known well enough to expose a bad instrument. Higher leaves move into disorder and dynamics, where the claims must get narrower as the questions get harder. Tap any leaf—or use the milestone rail—to see its question, finding, and technical receipt. The growing tip says whether the next question has a runner ready or is still only on the bench.

How to read the plant

green leaf

a machine-checked result promoted onto the permanent record by a person, with the receipt naming who read the evidence.

amber leaf

a measurement whose checker passed, waiting for a human to read the evidence before it can turn green.

grey folded leaf

an experiment that missed. It stays on the plant, and its field note says why.

the soft growing tip

the question at the front of the curriculum. Its field note says whether code exists to run it yet.

stem height

how far the plant has climbed through its list of experiments — taller means more done.

dark, damp soil

a fresh run just finished and watered it. The soil slowly dries until the next turn.

the season

how hard the computer is working: hard work heats it up, and that heat sets the season — cool and quiet reads as winter, busy and warm as summer. It shows spring when a run doesn't report a temperature.

the sky & light

your own time of day, in real time — dawn, noon, dusk, night. The plant keeps the same hours you do, wherever you are.

Why do this?

A pair of home computers has something a busy university supercomputer doesn't: slow, patient time, and no line of people waiting. So they take the unglamorous jobs nobody's in a hurry to run — one small experiment at a time, turn after turn, filling a real notebook over months. First they re-check answers we already know, to earn their trust; once proven steady, they can wander toward corners of science nobody has gotten around to mapping yet.

The reason this can exist at all is newer than the hardware. A patient instrument like this was never blocked on flops — it was blocked on the months of human evenings it takes to write the simulation, the checker, the provenance, the scheduler and the write-up, for a question nobody is paying you to answer. Agents absorb that cost. What one person still has to supply is the judgment about which answers count, and that has not been handed over.

Whatever comes out is meant to be given away. Every run's numbers, every receipt, every kept null, the whole instrument and this page are public and MIT-licensed: you can read how a result was reached, re-derive it from the saved measurements, fork the lab onto your own GPU, or point it at a question you care about instead. A small new result anyone can check and build on is worth more than a private one. The commons is the destination, not a byproduct.

For the curious — the real names and numbers

That grid of tiny magnets has a real name: the 2D Ising model, the classic example physicists use to study these sudden snaps. The exact tip-over temperature (written T_c, equal to 2.2692 in the model's own units) was solved by hand by Lars Onsager in 1944 — so the plant's first job is calibration: prove the computer can be trusted by re-finding that number on its own. Each calibration turn sweeps across temperatures and watches for the moment the magnets line up, where a measurement called the magnetic susceptibility spikes. In the calibration plotted above it landed at 2.30 ± 0.05 against Onsager’s 2.2692, in 23.2 seconds on the GPU (the graphics chip that also runs video games). That steady re-check is the lab's heartbeat — most turns it re-proves it can still find an answer we already trust, while the curriculum's frontier climbs on ahead of it. The counter under the plant counts turns — one scheduled pass, whichever machine took it; before July 2026 it counted nights. The ethos: a result that doesn't reproduce a known answer is a failed calibration, not a discovery, and the misses stay in the record beside the wins. So far several milestones are verified — beginning with the 2D Ising critical point and climbing through finite-size scaling, critical exponents, other lattices and models, and on toward spin glasses — out of a 40-step curriculum whose physics ladder climbs in four phases: verify famous exact results, map textbook-known territory, push corners last explored in the 1990s on big computer clusters a single modern chip now out-muscles, then reach genuinely open questions. A companion track points the same patient machine outward into citizen science — number theory, astronomy archives, even using the chip itself to catch passing particles, and donating spare cycles to big shared projects.

How the machine works — the engineering under the calm

The calm surface is the last mile of a real instrument. Underneath, one automated pipeline runs itself, and two machines take alternating turns running it:

schedule → simulate → verify → report → publish → grow

A scheduled task wakes whichever machine has the turn and asks the curriculum for a runnable next step. If the frontier is still only a design, the lab records that fact and runs its M01 calibration heartbeat instead. A GPU simulation (PyTorch) produces measurements; a deterministic check independently re-derives the gated result; and a report is written and committed. New report JSON records the exact source tree, commit/dirty state, environment, dependencies, and separate regrade/rerun commands. Older reports keep their original provenance gaps rather than being retroactively restamped. A small versioned JSON feed (pot.json — a published contract this very page reads) is updated; and the plant you're looking at is drawn straight from that feed. Continuous integration re-runs the whole test suite on every change.

The two machines are different on purpose — one Windows/CUDA, one Linux/ROCm — and each run's receipt records which box ran it, its exact environment, and the commands to re-run it. The lab began as one machine's night shift; a second machine joined in July 2026, and the two now alternate.

Every layer above was agent-written — the GPU kernels, the verification gate, the scheduler, the provenance, the JSON contract, the tests and CI, and the live drawing that renders the plant — from the silicon to the seedling. The commits are in the public history if you want to read how it was actually built, misses included.

The live feed, the source, and the full curriculum live at windowsill-lab; the rest of the lab is at the lab.