A real C. elegans nervous system, rebuilt from the published connectome and wired to a token's holder structure. Not a mascot with a price feed: the holders are the stimulus, the animal is the simulation, and every position it has ever held can be recomputed from chain state by anyone.
Caenorhabditis elegans is the only animal whose nervous system has been mapped completely, cell by cell, synapse by synapse. That map is what runs here:
397 cells in total. The connections carry signed weights, and every neuron is a source, so the graph is genuinely recurrent rather than a feed-forward toy. A cell fires when its accumulated charge crosses THRESHOLD = 30, then discharges into its targets on the next tick. That is the whole rule. Everything the animal does is what falls out of it.
The connectome comes from White, Southgate, Thomson and Brenner (1986), the paper that mapped the animal, via OpenWorm's machine-readable tables. We re-derived it ourselves from those tables and wrote the engine from the published behavioural specification. No code was copied from any existing implementation.
This matters more than it sounds. The well-known Arduino lineage of this simulation is GPL-2.0, and the project we started from vendored its data without saying so. We can name our source, point at its licence, and show you the derivation script.
White JG, Southgate E, Thomson JN, Brenner S (1986). The structure of the nervous system of the nematode Caenorhabditis elegans. Phil. Trans. R. Soc. Lond. B 314: 1–340.
Machine-readable tables: openworm/c302, MIT © 2024 OpenWorm. Derived by npm run derive; provenance in data/openworm/PROVENANCE.md.
The worm has no idea what a token is. It has sensory neurons, and we fire the ones the chain gives us a reason to fire.
Eight chemosensory neurons — ADFL/R, ASGL/R, ASIL/R, ASJL/R — the ones a real worm uses to find food. Fire them and the animal swims forward.
Ten mechanosensory neurons — FLPL/R, ASHL/R, IL1VL/R, OLQDL/R, OLQVL/R — the nose-touch circuit. A real worm hits something and backs off.
Forward and backward are not a metaphor we chose. Nose-touch drives the motor firing average past REVERSE_THRESHOLD = 19, and past that line the engine inverts the muscle sign and the animal reverses. Buys drive it forward and sells drive it backward because that is what the circuit does when you stimulate it. We did not add a rule for it.
Stimulus lands on sensory neurons, which have to reach interneurons, which have to reach motor neurons, which have to reach muscle. Measured from a fresh worm, the muscles are completely dead for the first 9 ticks. Nothing moves until the signal arrives around tick 10. We found that by measuring: an earlier cold-start window of 8 ticks produced a worm that never moved at all, and looked exactly like a bug in the renderer.
98 muscle cells in 24 segments. Dorsal-versus-ventral flexion is the swim; the travelling wave down the body is what a nematode actually does. Left-versus-right imbalance is the turn. Both axes are real, and they measure very differently:
| Per-segment difference | max | mean | drives |
|---|---|---|---|
| dorsal − ventral | 50 | 4.96 | the undulation you see |
| left − right | 10 | 0.21 | the steering angle |
The spec we started from said the visible bend was left/right. Drawn that way the worm is a straight rod, because the connectome drives the body almost symmetrically across left and right: the difference is 23.6× smaller. The animal lies on its side and undulates dorsoventrally. The renderer was wrong until we measured it.
Holder concentration does not steer the worm. It sets how hard the worm turns — and a worm that turns hard enough goes nowhere.
HHI maps to rightWeight, the probability that any given tick stimulates the right-side subset instead of the left. We measured what that actually does: rightWeight = 0 gives a mean turn of −0.169°/tick, and rightWeight = 1 gives −1.139°/tick. Same direction, 6.7× the rate. There is no left turn and no right turn available. There is only a lazy arc and a tight one.
Which is the whole point, because it is what concentration means. Over a 256-tick window, path efficiency (net displacement ÷ path length; 1.0 is a straight line, 0 is a closed loop):
| Holder structure | path efficiency | distance travelled |
|---|---|---|
| dispersed (low HHI) | 0.80 | 8,836 |
| concentrated (high HHI) | 0.16 | 1,761 |
A token held by a handful of whales draws a worm circling its own tail. A token held broadly draws one that goes somewhere. That is not editorial licence applied on top of the data; it is a 5× separation that falls out of the connectome when you drive it this way, and it is pinned by a test that fails if it ever collapses.
| Chain input | Becomes | Saturates at | Effect |
|---|---|---|---|
| new holders ÷ previous holders | chemotaxis ticks | +10% | swims forward |
| sells ÷ supply held | nose-touch ticks | 1% | reverses |
| HHI | rightWeight 0–1 | 2,000 | turn rate |
| holders below 2 | cold: 64 ticks, no travel | — | coils in place |
The two budgets are computed independently and then scaled together to fit the tick ceiling. Clamping them separately would quietly change the chemotaxis-to-nose-touch ratio, and that ratio is what decides forward versus backward — a ceiling would have become a steering input.
HHI saturates at 2,000 rather than its 10,000 maximum because HHI is hyperbolic (roughly 10,000 ÷ effective holders). A healthy token measures around 63; four equal holders measure 2,500. Mapping linearly against 10,000 would squash everything interesting into the bottom 2% of the range.
Two rules, and neither depends on us.
signalBlock = floor(finalized / 6000) * 6000. Signal blocks are a function of the block number, not of when our cron fired. You can enumerate every one of them without asking us. A late cron delays a row; it can never change which block that row is about.keccak256(blockHash ‖ holderSetRoot), where holderSetRoot is the keccak of the holder set sorted by address with balances at fixed width, over all holders with no role exclusions. A seed derived from operator config would not be derivable from chain, which would make the word “deterministic” do work it had not earned.The seeded PRNG chooses the interleave of chemotaxis and nose-touch ticks, and each tick's left/right subset. Nothing else. It buys organic variation at zero cost to verifiability, because the seed is chain-derived.
Holder counts, HHI, Gini and new-holder counts replay exactly from ERC-20 Transfer logs. Nobody has to take our word for them.
The sell signal is not trustless. It depends on which addresses we have configured as liquidity pools, and that is operator config, not chain data. If we got the LP set wrong, or changed it, the sell signal changes with it.
Every update publishes lpSetHash so the assumption is auditable rather than invisible, and so you can see whether the set moved between updates. That makes it checkable. It does not make it trustless, and we are not going to call it that.
Level 1 takes our holder set and re-runs the simulation: root → seed → plan → trajectory, then compares. It proves we did not lie about the simulation. It does not prove we did not lie about the data — if you take the holder set from us, you are trusting us for it.
Level 2 re-derives the holder set from your own archive RPC, from the token's mint block forward, and closes that gap. It is the one that actually settles the question. The commands are here.
Four things that are wrong, or fragile, or easy to misread.
Gini is bounded by (n−1)/n, so with 5 holders it cannot exceed 0.8 no matter how brutal the distribution is. Below roughly 10 holders it is not measuring concentration, it is measuring the holder count. The UI flags it there. HHI has no such bound, which is why HHI — not Gini — is the signal that drives the worm.
maxTicks decides whether the concentration arm works at all. Path efficiency, low HHI versus high HHI:
| maxTicks | dispersed | concentrated | |
|---|---|---|---|
| 128 | 0.73 | 0.64 | weak, barely separated |
| 256 | 0.80 | 0.16 | clean 5× separation — default |
| 512 | 0.78 | 0.15 | equally good |
| 1024 | 0.59 | 0.08 | degrading |
| 2048 | 0.03 | 0.05 | broken — the signal inverts |
Even at rightWeight = 0 the worm still turns −0.169°/tick, so it closes its own loop after about 2,130 ticks. Past ~1024 both regimes are circling and the readout only reflects where each one happened to stop. The metaphor holds exactly as long as the low-HHI worm is still going roughly straight, and not one tick longer. 512 is the safe ceiling; the cliff is at 2048, and there is a test that documents the inversion rather than hiding it.
Our engine is checked bit-for-bit against the original C implementation, every tick and every cell. That check only holds with -ffp-contract=off. Left on, the compiler fuses multiply-add into a single instruction with one rounding step instead of two, and the C program produces different floats on different machines — so the reference cannot reproduce itself, let alone be reproduced by JavaScript.
This is a property of the reference, not of us. Our engine is IEEE-754 and deterministic everywhere. It is worth knowing if you ever try to check the oracle against its own output.
The trail currently spans 31,229 × 43,872 world units. The worm is 312 long. At a zoom that fits the whole journey the animal is under 7 pixels, which is why the map redraws itself as you zoom rather than just scaling: far out it is a position among events, close in it is an animal with 24 segments. Neither view is the real one.