The whole story, stated plainly

Platynereis dumerilii is a marine annelid: a segmented worm. The animal in this project is one of its larvae, three days old. Its traced cells span about a fifth of a millimetre from head to tail.

Even this young, the larva senses and moves. It has eyes, touch and vibration sensors, muscles, and bands of cilia: microscopic hairs that beat like oars and push it through the water. Its body runs from a head through a few segments to a tail end, and the data records which segment and side every cell sits in.

What the lab has seen its larvae do

The model and its tests lean on three of the lab's earlier studies. They are the only claims about the living animal on this page.

• They swim toward light. The larvae steer toward light with their eyespots and the band of cilia beside them: light on one eyespot changes the beating of the cilia next to it, and because the larva rotates as it swims, that turns it toward the light (Jékely et al., 2008).
• A vibration makes them stop. Water vibrations make the larvae close their swimming cilia and raise their parapodia (the paired flaps along their sides), through vibration-sensing cells called collar receptors. The study describes it as a startle response for avoiding predators (Bezares-Calderón et al., 2018).
• Their cilia stop and go. Every so often all the cilia stop together. The lab traced these stops to cells that fire together in a rhythm; one of them, called MC, activates with a median cycle of 71 seconds. It also found that serotonin, one of the chemicals nerve cells signal with, inhibits that rhythm and makes the cilia beat faster (Verasztó et al., 2017).

Where neither the data nor these studies say something about the animal, this page doesn't either. Parts of the simulation that the data can't supply, such as how its eyes see a message or how its body moves through water, are our choices, and they are labelled as ours below.

A connectome is a complete map of every nerve cell and every connection between them. This one covers the whole body.

Verasztó C, Jasek S, Gühmann M, Bezares-Calderón LA, Williams EA, Shahidi R, Jékely G. Whole-body connectome of a segmented annelid larva. eLife (2025).

The paperThe dataCC BY 4.0Not affiliated with the authors.

"Whole-body" means the map doesn't stop at the brain. It includes the nerve cord, every sensory cell, and the muscles, ciliated cells, glands and other cells that the nerves connect to. Every cell and connection was traced from electron micrographs, images taken with an electron microscope.

A synapse is a contact point where one cell passes a signal to another. In the data, a connection is one cell linking to another through at least one synapse, and each connection carries its synapse count: how many separate synapses the first cell makes onto the second. The 14,066 connections carry 26,881 synapses between them. Counts matter: more synapses means a stronger link, and the model uses exactly that.

The lab released its results openly. BRAINWORM uses three parts of that release: a graph of every cell and connection with synapse counts; a table of cell types, which also lists each type's transmitter where it is known; and the lab's 3D viewer pages, which show every traced cell's shape and cell body.

Neurons

1,627

468 sensory, 920 interneurons, 239 motor neurons

Effector cells

424

301 muscle cells, 72 ciliated swimming cells, 51 others such as glands

Other cells

157

cells the data classes as neither

Fragments

467

pieces of cells with no position: simulated, not drawn

Sensory neurons detect things like light and touch, interneurons pass signals between neurons, motor neurons drive the cells that act, and those acting cells (muscles, ciliated cells, glands) are the effectors. From the cells' names in the data, BRAINWORM identifies the ones it needs:

• 26 eye photoreceptors, 13 on each side, including the 4 photoreceptors of its two eyespots. A photoreceptor is a light-sensing cell.
• 4 non-directional light sensors, which respond to overall brightness.
• 53 touch sensors: collar receptors (the vibration sensors) and chaetal mechanosensors (chaetae are its bristles). 26 are at the head end and 27 at the tail end.
• 83 body-wall muscles running along the body, 49 on the left and 34 on the right, and 192 startle muscles (chaetal, acicular and oblique).
• 72 ciliated swimming cells, 36 on each side, in four bands the data names the prototroch (23 cells), paratrochs (34), akrotroch (8) and metatroch (7).

A map is not a working nervous system. It says who connects to whom and with how many synapses, not what each cell does with its input. To make it run, BRAINWORM puts a simple model on top of the map and connects a simulated body to it.

Every piece below carries one or more of three labels, the same ones the main site uses:

• Measured

  Straight from the study's data, unchanged.

• Simplified

  A rule of the model: far simpler than the real animal, registered and timestamped before it first ran.

• Chosen

  Our choice, where the data says nothing. Every such number is published in /manifest.json.

The data file

MeasuredChosen: placed positions

A script in the project reads the lab's public files and writes one compact file, /data/wiring.json: every cell with its class, side, segment and type, and every connection with its synapse count. Anyone can rebuild it from the lab's repository, and the script reproduces the published file byte for byte.

1,199 cells sit at cell-body positions taken from the lab's 3D viewer pages. For most of them that is the cell's own body; for a few cell types whose pages and tables don't line up one to one, a cell gets the body of a cell of its own type, on its own side. The 1,009 cells without a published position are placed near cells of their own segment and side, and the data marks them as approximate. The 467 fragments have no position and are not drawn.

Two more files come from the same release: the known transmitter of each cell type (/data/transmitters.json) and the traced shapes of the cells, which the 3D view draws. The glassy outline of the body around them is ours, derived from the traced cells, because the lab didn't publish one.

Cells as firing rates

SimplifiedChosen: threshold, time constants, fatigue

Real nerve cells signal with brief electrical pulses called spikes. A firing rate is how often a cell spikes. The model doesn't simulate individual spikes: it keeps one number per cell, its activity, from 0 (silent) to just under 1 (as active as the model allows). The site counts a cell as firing when its activity is above 0.05.

Every step, each of the 2,675 cells does four things:

1. Adds up its input: any outside drive (light on an eye cell, a poke on a touch sensor), plus each sending cell's activity times that connection's strength, minus 1.5 times its own fatigue.
2. Turns it into a target. If the total is above the threshold of 0.05, the target is tanh(total − 0.05), a smooth curve that rises steeply and then levels off below 1. Otherwise the target is 0.
3. Moves a third of the way from its current activity toward that target (a time constant of 3 steps).
4. Updates its fatigue, which slowly follows its activity (a time constant of 40 steps), so a cell that has been busy responds less for a while.

That is the whole model of a cell: a simulation of a real, mapped nervous system, with nothing invented and nothing trained. The few numbers the data can't supply are our choices, and every one of them is listed in the manifest.

Connection strength: one number, computed

Measured: synapse countsSimplified: one registered rule

A connection's strength is its synapse count times one number, c, the same for every synapse in the worm:

c isn't tuned. It is computed from the wiring: 1 divided by the largest eigenvalue of the synapse-count matrix. The synapse-count matrix is the whole wiring written as one table, with a row and a column for every cell and, where they meet, the number of synapses from one to the other. Its largest eigenvalue measures how much activity can multiply each time it travels around the wiring's loops. Dividing by it sets every connection at the strength where no loop can grow on its own: activity spreads along strong connections, fades along weak ones, and only a stimulus keeps it going.

So a single synapse is worth 0.032, and the strongest input to the rhythm cell MC, 36 synapses from a serotonergic cell called Ser-h1, is worth 1.16. It is also one of the few inhibitory connections, as the next part explains.

Transmitters: which synapses inhibit

Measured: 79 transmittersSimplified: everything else excitatory

A neurotransmitter is the chemical a nerve cell releases at its synapses. Cells that use acetylcholine are called cholinergic; cells that use serotonin are serotonergic. The transmitter helps decide whether a signal excites the next cell or holds it back.

The lab's cell-type table names a transmitter for 79 of the 2,675 cells: 55 glutamatergic, 18 cholinergic, 4 serotonergic, 1 dopaminergic and 1 adrenergic. For the other 97%, it is unknown.

So the model can't read a sign for most synapses, and it doesn't guess. Every synapse is excitatory, except the one kind the lab's findings pin down: synapses from serotonergic cells onto the cholinergic cells that drive the cilia are inhibitory, because the lab found that serotonin inhibits that cholinergic rhythm. In this wiring that is 9 connections carrying 65 synapses, from the Ser-h1 cells onto MC and from the Ser-tr1 cells onto the Loop, MN1 and MN2 cells. The full list is in the manifest.

The cilia rule and the stop-and-go rhythm

SimplifiedChosen: burst length

The worm swims with its 72 ciliated cells. Each one follows one rule: it stops beating in proportion to the activity of its cholinergic inputs, and serotonergic input keeps it beating.

Each side of the body beats at 1 minus the average arrest of that side's ciliated cells. No other input stops the cilia. The rule follows the lab's findings: cholinergic cells drive the coordinated stops of all the cilia and serotonin inhibits that rhythm (Verasztó et al., 2017), and the eyespot changes the beating of the cilia next to it through cholinergic synapses (Jékely et al., 2008). In the data, the 7 cells of the metatroch get no cholinergic input, so under this rule they never stop.

The rhythm itself: every 71 seconds (2,130 steps), from step 2,130 on, the MC cell gets a drive of 1.0 for 2 seconds (60 steps). The 71 seconds is the lab's median cycle. How long each burst lasts isn't reported, so the 2 seconds is ours. How long the cilia stay stopped is up to the wiring.

The eyes: how a message becomes light

Measured: the eye cellsChosen: the mapping

The worm can't see words. What reaches it is a moving pattern of light, made like this:

1. Your message, up to 40 characters, is drawn in a pixel font 16 pixels high, rasterised from Poppins Bold, one column of pixels at a time.
2. It scrolls past a view 60 columns wide, one column per step: 30 columns a second.
3. The 13 left photoreceptors each watch one strip of the left half of the view, and the 13 right ones the right half. A photoreceptor's input is its strip's brightness times 1.6, capped at 1.
4. When the whole view is more than 45% lit (a row of solid blocks, █, does it), the 4 non-directional light sensors respond too.

Touch and pokes

Measured: the 53 touch sensorsChosen: the poke

Tap the worm's body in the 3D view and you poke it: the 6 touch sensors nearest your tap on screen get a drive of 1.2 for 5 steps, a sixth of a second. The "poke a random spot" button pokes 4 neighbouring touch sensors around a random one. Everyone's pokes appear on everyone's screen, with who made them.

Which cells a poke reaches, and how hard, is our choice. What happens after that is the wiring's.

The body and its swimming

Chosen: all of it

The worm's activity drives a simulated body in a virtual, spherical tank about 4.8 mm across. The physics is ours, in the spirit of what the lab describes for Platynereis larvae, and every number is in the manifest:

• The cilia push it forward, head first, at up to about half a millimetre a second, and spin it about its long axis. With a slight constant turn, that makes a helical path.
• Cilia stopped on one side turn it toward that side. Stopped everywhere, it sinks.
• The body-wall muscles steer: more activity on one side turns it to that side.
• The startle muscles brake it.
• When it bumps the wall of the tank, it turns back in.

For something this small, water acts thick: there is no gliding, and the body's speed is proportional to the push (physicists call this low Reynolds number). The body is part of the worm's logged, hashed state, so the live check and every replay cover it. It does not feed back into the nervous system, except through the lamp.

The lamp: a closed loop

Chosen, and registered with its test before any lamp was lit

Anyone can light a lamp in the tank for 30 seconds. It appears about 1.1 mm from the worm, in a random direction, inside the tank. How much light each side's eyes get depends on where the lamp is and which way the body faces:

• Each side's eyes look out sideways, a little forward and a little up.
• A pigment cup lets each eye see light from its own side only, weakening with the angle off its axis.
• Brightness fades with distance d as 1 / (1 + (d / 1.08 mm)²).
• Each side's 13 photoreceptors take that light the way they take a lit strip of a message: times 1.6, capped at 1. The non-directional light sensors don't respond.

So while the lamp is lit, where the worm swims changes what its eyes see: a closed loop from light, through the wiring, to the cilia and muscles, and back to the eyes. The real eyes' fields of view are not in the data. All of this was written down, together with the test that checks it ("Follow the light"), before any lamp was ever lit.

Measured, simplified, chosen: the whole list

What the model deliberately leaves out, and why, is in Stated plainly.

There is exactly one worm. It lives in the memory of a single server process, which runs it at 30 steps a second in real time and streams its activity to every visitor up to 15 times a second.

Everyone watches the same worm, cell for cell, and everything anyone does reaches that same worm. Every stimulus is applied at an exact step, and that step goes into the public log. Here is what you can do:

Talk

Type up to 40 characters. Messages play one at a time, each scrolling past its eyes as light.

Poke

Tap its body to poke the nearest touch sensors.

Tug

Set two words of up to 10 characters against each other, one shown to each eye, in five passes: a warm-up, then A|B, B|A, B|A, A|B, with 3 seconds of dark after each. Each word is scored on each side equally often, so the model's own left/right lean cancels out. The score is how fast its body turned toward a word, from its cilia and muscles. It is not a preference. A calibration runs on a fresh worm whenever the server starts, and is published: the same word on both sides scores about zero, and swapping the words flips the sign.

Lamp

Light a lamp in its tank for 30 seconds and watch whether it swims closer.

Break the worm

A leaderboard of the most cells firing at once, today and of all time. Only undisturbed messages are ranked. The worm tires, so the same message can score differently.

Watch

The 3D view draws every positioned cell in its traced shape, lights connections when their sending cell fires, and shows any cell's real inputs and outputs when you hover it. Every firing cell can click, you can save the last 8 seconds as a clip, and a 16:9 layout at /stream serves live streams, with an optional Twitch chat bridge.

Trades on the blockchain reach the worm the same way, as pokes: $WORM's trades once it exists, and every buy of a SPAWN coin (sections 08 and 09). Each one is logged with its transaction signature.

Keeping it fair

• Proof of work. Before a browser may send anything, it solves a small SHA-256 puzzle in the background, about a tenth of a second on a laptop. Visitors don't notice; a bot farm pays for every connection, and the puzzle gets 4 to 16 times harder when new connections spike.
• Rate limits per tab, per address and overall, for messages, pokes, tugs and new connections.
• No links, no addresses. Chat, tug words and announcements refuse links and wallet or contract addresses, so nobody can post a fake contract. Profanity is starred, and moderators can pause, slow, hide and mute.
• Built to hold. In a load test with 2,000 simultaneous viewers sending constant messages and pokes, one process held real time at 30.0 steps a second, using about 9 KB/s per viewer and about 21% of one CPU core.

Nearly everything the worm does can be checked by anyone, without trusting the server or us. Three ideas make that possible.

Deterministic

The same inputs always give exactly the same result, down to the last bit, on every computer. The simulation uses no randomness, no clock, and only arithmetic that every JavaScript engine computes identically. Built-in functions like tanh can differ in their last digit between browsers, so the project builds its own from plain addition, subtraction, multiplication and division. Chrome, Safari and Firefox all match the server bit for bit.

Hash

A short fingerprint of any data. BRAINWORM uses SHA-256: change a single bit of the input and the fingerprint changes completely, and nobody can find two different inputs that share one.

OpenTimestamps

A free, public service that anchors a hash in the Bitcoin blockchain. It proves the data existed by then, without publishing the data itself.

Your browser's live check

Live

When you open the site, your browser downloads the worm's exact current state and starts its own copy in a background thread, running the same code the server runs (the files in /shared/). The server tells it every stimulus and the step it arrives at, and once a second it sends the SHA-256 of its state. Your copy compares. One differing number anywhere, in any cell's activity or fatigue or in the body, changes the hash, and the check fails in public.

The log, the chain and Bitcoin

Verifiable

Replay any hour

The "Replay this hour" button in the Proof section of the main page downloads the hour's log, starts from its checkpoint, re-applies every stimulus at its step, and checks every published result and the final state hash, all in your browser. From a terminal, with the project's code:

npm run replay -- https://<site>/log/current.jsonl

Open data

/manifest.json lists every number the model and the stimuli use, each marked measured or chosen, with the SHA-256 of the wiring, the transmitters and each code file. /proof.json, /log/index.json and every log file are public, and any website or script may read them.

A simulation can be made to look like anything. So BRAINWORM asks the worm specific questions, writes down the rule for passing before the first run, and publishes every answer, including the failures.

How a test works

• Registered first. Each test's question, stimulus, measure, control, pass rule, every chosen number and its random seed (20260926, the date they were written) were fixed before it ever ran. Model v2 and the tests that came with it were fingerprinted with SHA-256 and timestamped into Bitcoin on 26 September 2026, before any simulation of model v2 was run: /data/registrations/model-v2.json, with its .ots proof beside it.
• Never edited. A rule is never changed after its result is known. If one turns out to be badly posed, it stays, with its result, and a new, separately versioned test is added next to it.
• Compared with 50 rewired worms. Every test that has a control also runs on 50 degree-preserving scrambles of the wiring, made by Maslov–Sneppen swaps (Figure 5). Each rewired worm has exactly the same cells, the same number of inputs and outputs per cell and the same synapse counts, and every sensor and muscle stays where it is; only who connects to whom is shuffled, by 140,660 swaps (10 per connection) from a fixed seed. If the real wiring does no better than those, that is the result.
• Passing means beating 95% of them. A pass/fail test passes only if the real worm's number is above the 95th percentile of the 50 rewired worms (the value 95% of them fall below, the conventional 5% level in science), plus any other condition in its rule.

Model v2's results

The first and only run of model v2, as published in /lab.json and /data/lab-model-v2-first-run.json. "Rewired" means the 50 scrambled worms; "p95" is their 95th percentile.

3 pass3 fail4 measured

1. Light on one side

   Passes

   Does light on one side reach one side?

   Light on one side's eyes makes the ciliary bands and body-wall muscles on the lit side more active. Lateralization 0.0062 against a rewired p95 of 0.0035.

2. Touch and startle

   Fails

   Does touch reach the startle muscles?

   Driving all 53 touch sensors at once moved the startle muscles only to a peak of 0.0008, below the rewired p95 of 0.0025.

3. Light to muscle

   Measured

   How long does light take to reach a muscle?

   7 steps, 233 ms of model time, until the first muscle crossed 0.05. 41 of the 50 rewired worms responded, in 3.7 steps on average. Model time is not measured larval physiology.

4. The alphabet

   Measured

   Which glyph's light pattern fires the most cells?

   "@" shown three times fired the most cells (41 at once); "_" the fewest (none). The ranking follows the number of lit pixels almost exactly (rank correlation 0.98). It measures light, not letters: the worm does not read.

5. Ten pokes

   Measured

   Does the response shrink when the same spot is poked again and again?

   The first poke fired 25 cells at its peak, the tenth 22 (a ratio of 0.88). With fatigue switched off: 28 and 28. That is the model's built-in fatigue, not learning or memory.

6. Touch and startle, one sensor at a time

   Fails

   Does touch reach the startle muscles? (Registered after the first version's result was known, so weigh it accordingly.)

   None of the 53 touch sensors, poked alone, moved the startle muscles above 0.05, and neither did any of 368 other sensory neurons.

7. Follow the light

   Passes

   Does it swim toward a light?

   With the lamp lit, the worm stayed 15.2 µm closer to it on average than with the lamp dark, above the rewired p95 of 8.5 µm and above 96% of the rewired worms. A small margin: it ended closer in only 1 of 8 directions.

8. One eyespot, one side

   Passes

   Does light on one eyespot change the cilia on its own side?

   Lighting one eyespot stopped the cilia on its own side slightly more than on the other: laterality 0.0065 against a rewired p95 of 0.0032. The cilia rule comes from the same lab's studies, so this shows the wiring carries the known mechanism; it is not an independent prediction.

9. The startle reflex

   Fails

   Does a vibration make it close its cilia and raise its parapodia together?

   The cilia half works: poking the collar receptors stopped the cilia (average arrest 0.23, against 0.04 for other senses and a rewired p95 of 0.009). The muscle half doesn't: the startle muscles peaked at 0.001, below the rewired p95 of 0.004. The rule needs both.

10. Stop and go

    Measured

    When the rhythm's MC cell bursts, how much of the ciliary band stops together?

    At most 15% of the 72 ciliated cells at once: 48% of the prototroch and none of the other bands. Rewired worms: 1% on average.

A pass is a statement about this model of the wiring, not about the animal. Real larvae swim toward light (Jékely et al., 2008); "Follow the light" asks whether the model does.

BRAINWORM, ticker $WORM, is the project's own coin on Solana, created on pump.fun. Its launch is tied to a moment in the worm's life that anyone can check, in five public steps. Their live status is on /launch.

1. Armed. A moderator arms the launch. The step at which it was armed goes into the public log.
2. The moment. From then on, the server watches for the first step at which the worm's swimming cilia are stopped: the average arrest of all 72 ciliated cells above 0.05, not counting its own stop-and-go bursts and the 3 seconds after each. It is meant to catch its startle reflex (in real larvae, a vibration makes them close their cilia). That step, the SHA-256 of the worm's state and the hash of the image go into the log. Replaying the log finds the first stop after arming on its own and compares the state hash at that step.
3. The image. The token's image is drawn from the worm's exact activity at that step, with the step, the number of cells firing and the state hash printed on it. The image and the token's description are uploaded to IPFS, a public network that addresses each file by its hash. If the upload is refused, they are kept on this site instead, each under a link named by its hash.
4. The transaction. The server prepares pump.fun's create transaction. The coin's address can be made ahead of time in the owner's browser, which keeps its key and signs for it; otherwise the server makes a fresh key, signs with it and drops it. The owner's own wallet adds its signature and sends it. The server never holds the owner's key and never sends anything itself.
5. Launched. Once the transaction confirms, its mint becomes the only $WORM contract address the site shows, and the coin's trades start reaching the worm.

After launch, every $WORM trade becomes a poke, logged with its transaction signature. A buy pokes three touch sensors at the head end and a sell three at the tail end, picked from the bytes of the transaction's signature. Big buys also flash a solid block of light across its eyes. A trade that arrives while a tug is playing, or faster than the rate limit allows, is skipped. The mapping is ours; the worm has no idea what a trade is.

As with any pump.fun coin, pump.fun pays $WORM's creator a share of its fee on every $WORM trade. $WORM's own creator rewards stay with the team, and they are kept apart from SPAWN's: $WORM is launched from a different wallet than SPAWN's rewards wallet.

SPAWN is BRAINWORM's launchpad, on the main page and at /spawn. Anyone can launch a coin there, and every coin is a pump.fun coin. Every coin gets its own copy of the worm, every buy pokes the live worm, and every coin's creator rewards go to SPAWN, which spends 64% of them on $WORM and burns all of it.

The name comes from the animal. Platynereis is known for its spawning: grown worms swim up to the surface in time with the moon, release their eggs and sperm, and die. A larva like ours is what comes of it.

A worm for every coin

VerifiableChosen: the mapping

When a coin is created, a fresh copy of the same larva hatches for it: the same wiring and model as the live worm, with nothing added. The first thing it sees is the coin's ticker, "$TICKER", shown to its eyes like a message. Unless whoever launches the coin uploads a picture, the coin's picture is its worm's first sight: its activity as it saw its ticker.

From then on it feels that coin's trades and nothing else. A buy touches three touch sensors at its head end, a sell three at its tail end, picked from the trade's transaction signature, and then its time runs for 60 steps (2 seconds). Between trades, its time stands still.

So a coin's worm depends only on its ticker and its list of trades. Each coin's record, at /spawn/worm/<coin address>.json, lists both along with the worm's state hash, and the Check button on each coin rebuilds the worm in your browser and compares.

Every buy pokes the live worm

Each coin also has its own spot on the live worm: three touch sensors picked from the SHA-256 of the coin's address, the same for every buy of that coin. A buy pokes that spot; how far the activity spreads is up to the wiring. Every poke is in the public log with its transaction, and coins can be ranked by how many cells their buys lit today.

How coins trade

SPAWN coins are pump.fun coins, and they trade on pump.fun's bonding curve. A bonding curve is a price formula that takes the place of an order book: the price rises with every buy and falls with every sell, and the curve itself is always there to trade against.

• A supply of 1,000,000,000, with 6 decimals, like every pump.fun coin.
• Free to launch, apart from about 0.02 SOL of Solana rent for the coin's own accounts, and an optional first buy, made in the same transaction.
• Graduation. When the curve sells out, the coin graduates: pump.fun moves it to its own exchange, PumpSwap, where it trades in a liquidity pool, a pair of token reserves that anyone can trade against at a price set by their ratio.
• Its own page. Every coin has a page at /c/<coin address> with its chart, buy and sell, its worm and a share link. Before graduation a trade there goes straight to pump.fun's curve; after, it routes through Jupiter, a Solana swap router. Any SPAWN coin can also be traded on pump.fun itself.

Creator rewards and the burn

pump.fun charges a fee on every trade and pays part of it to the coin's creator. On the curve that is currently 1.25% of each trade: 0.95% to pump.fun and 0.30% to the creator. After graduation, PumpSwap pays the coin's creator a share of its fee too. These rates are pump.fun's, and they can change.

Every SPAWN coin names SPAWN's rewards wallet as its pump.fun creator. So the creator rewards of every coin launched on SPAWN, on the curve and on PumpSwap, go to SPAWN. The person who launches a coin does not get its creator rewards. To burn tokens is to destroy them with the token program's burn instruction, so they leave the supply for good.

• Collected. The creator rewards gather in SPAWN's pump.fun vaults, and the owner collects them into SPAWN's rewards wallet, as SOL.
• 64% buys $WORM, on its pump.fun curve while it has one, through Jupiter after. Exactly the $WORM each purchase bought is then burned.
• 36% stays with the team.

Every purchase and every burn is a public transaction, each burn is read back from the chain, and the totals are on /spawn.

Your keys stay yours

SPAWN never holds anyone's key and never sends a transaction. The server builds unsigned transactions, and your own wallet (Phantom, Solflare or any wallet that supports Wallet Standard) signs and sends them. The only key it ever makes is a new coin's fresh address, which signs its own part of the transaction and is then discarded. The server keeps every price quote it hands out, so nobody can swap in a doctored one.

Only coins launched through SPAWN are listed, and only while the chain shows SPAWN's rewards wallet as their pump.fun creator. Their names and tickers go through the same filter as chat.

The limits, in one place.

• It can't read. A message reaches it only as light. It understands nothing, and letters with more lit pixels simply excite more cells.
• It doesn't choose. A tug shows which way its body turned, not a preference.
• It predicts nothing. Nothing on this site predicts prices. The worm knows nothing about coins, trades or markets, and it doesn't pick winners.
• It launched nothing. A moderator arms the launch, a published rule finds the moment, and the owner signs the transaction.
• The model is simpler than the animal. Real neurons spike, inhibit and modulate. Here, cells are firing rates, and because the transmitter is known for only 79 of 2,675 cells, almost every synapse is excitatory. Guessing the rest would be inventing.
• Left out on purpose. Spikes, for the reason in Cells as firing rates. Serotonin's faster beating, because the lab reports that it happens but not by how much. Neuropeptides, which the lab's table lists for some cells but which say nothing about a synapse's sign.
• Some choices are ours. The eye mapping, the light sensors' threshold, which cells a poke, a trade or a coin reaches, the fatigue settings, the 2-second rhythm burst, the swimming physics, the tank, the lamp, and how activity is drawn and sounded. Every number is in /manifest.json.
• Positions are partly placed. 1,199 cells sit at traced positions, 1,009 are placed by segment and side, and 467 fragments aren't drawn. The body outline is derived, not published.
• The body is ours. Only the lamp feeds the body back into the nervous system.
• Model time is not larval time. A step is a thirtieth of a second of model time; the milliseconds in the tests are not measured physiology.
• Tiring is not learning. When a response shrinks with repetition, that is the model's built-in fatigue, not memory.
• Three tests fail, and the passes are small. All of them are published, with their rules written first.
• Where the rewards go. SPAWN coins pay pump.fun's fees, currently 1.25% of each trade on the curve: 0.95% to pump.fun and 0.30% to the coin's creator. SPAWN is every coin's creator, so the creator rewards go to SPAWN, not to the coin's launcher: 64% of them buy $WORM, all of which is burned, and 36% stays with the team. $WORM's own creator rewards stay with the team too. Coins can lose all their value.
• Not affiliated. The data is the Jékely lab's. BRAINWORM is not affiliated with or endorsed by the authors.

The data

Verasztó C, Jasek S, Gühmann M, Bezares-Calderón LA, Williams EA, Shahidi R, Jékely G. Whole-body connectome of a segmented annelid larva. eLife (2025) · data · CC BY 4.0. Changed: positions derived, data re-encoded, simulation and body added. Not affiliated with the authors.

The studies the model relies on

• Verasztó C, et al. Ciliomotor circuitry underlying whole-body coordination of ciliary activity in the Platynereis larva. eLife 6:e26000 (2017).
• Jékely G, et al. Mechanism of phototaxis in marine zooplankton. Nature 456:395–399 (2008).
• Bezares-Calderón LA, et al. Neural circuitry of a polycystin-mediated hydrodynamic startle response for predator avoidance. eLife 7:e36262 (2018).
• Shiu PK, et al. A Drosophila computational brain model reveals sensorimotor processing. Nature (2024).

Pixel font: rasterised from Poppins Bold (SIL Open Font License).

Check it yourself

• /labEvery registered test and its result
• /docsThe overview and all the code
• /manifest.jsonEvery number the model uses, measured or chosen
• /lab.jsonAll of the lab's data
• Model v2 registrationIts fingerprints; the .ots proof sits beside it
• /proof.jsonThe hourly proof chain
• /log/index.jsonEvery hour of the log
• /data/wiring.jsonThe wiring, as the worm runs it
• /spawnThe launchpad: coins, creator rewards, burns
• /launchThe $WORM launch, step by step

Words used on this page

Connectome

A complete map of every nerve cell and every connection between them.

Synapse

A contact point where one cell passes a signal to another.

Neurotransmitter

The chemical a nerve cell releases at its synapses.

Firing rate

How active a cell is; in this model, one number from 0 to just under 1.

Deterministic

Same inputs, exactly the same result, on every computer.

Hash

A short fingerprint of data (here SHA-256) that changes completely if one bit does.

Hash chain

Entries that each include the hash of the one before, so none can change unnoticed.

OpenTimestamps

A free public service that anchors a hash in Bitcoin, proving when the data existed.

Bonding curve

A price formula that replaces an order book: buys raise the price, sells lower it.

Graduation

When a coin's curve sells out and it moves into a regular liquidity pool; for a pump.fun coin, on PumpSwap.

Creator rewards

The share of pump.fun's fee on each trade that goes to a coin's creator. For every SPAWN coin, that is SPAWN.

Liquidity pool

A pair of token reserves anyone can trade against, priced by their ratio.

Burn

Destroying tokens so they leave the supply for good.

Launch a coinWatch the wormBack to the top