the fly experiment

abstract: there is a token on pons, there are fees, and there is a fly. the fly is the male drosophila central nervous system connectome, 164,838 neurons and 171,901,440 synapses traced from one animal by electron microscopy, run as a spiking model over its own wiring. every epoch of 128 blocks the price of the token is drawn onto the fly's eye as a grating that drifts when the price moves, the fly's motion vision pathway is simulated over that stimulus, and the turn it makes is read out of its horizontal system cells. if the fly turns to follow a falling price it bites: the contract buys the token with a slice of the fly's half of the fees and sends what it bought to the dead address. the other half of the fees belongs to a metronome that bites every epoch regardless. every act writes a receipt holding a hash of the frames the fly saw and a hash of the spikes it fired, and the frames and spikes are published, so anyone can check that a buy came from a brain state. the experiment measures which arm burns more of the token per coin. this document is the whole of it.

note: this page is a reader. it renders public accounts and public frame files and signs nothing on its own.

keywords: connectome, optomotor response, leaky integrate and fire, motion vision, creator fee routing, two arm experiments

the fly

the animal in this experiment is not a model of a fly. it is a fly. in 2026 janelia flyem and google research published the complete wiring of the central nervous system of one adult male drosophila melanogaster: every neuron reconstructed from electron micrographs, every synapse between them located and counted, every cell assigned a type. the release is public under a cc by license and lives on neuprint under the name male cns. the numbers in the table below are its own numbers. nothing in this experiment invents a neuron or a connection; the only freedom taken is to run current through wires the fly already has.

a connectome is a map, not a machine, so a rule is needed to turn it into one. the rule used here is the simplest that produces behavior: every neuron is a leaky integrate and fire unit, every synapse is a fixed jump of membrane potential whose size is proportional to the number of synapses counted between the two cells and whose sign is set by the transmitter the presynaptic cell is predicted to release. the parameters are those of shiu and colleagues, who showed in 2024 that this rule over the fly wiring reproduces known sensorimotor reflexes. the docs give every parameter. the point of using a published rule is that the fly in this experiment is the same fly anyone else would get.

the eye

a fly's eye is a lattice. each facet looks at one direction and behind it sits one column of neurons, and the right eye of this fly has 892 such columns at its first synaptic layer. the experiment draws the market onto that lattice and nothing else. there is no price feed into the model, no number typed into a neuron, no vector of features. there is a picture, and the picture is the only way the market reaches the fly, exactly as light is the only way the world reaches a fly. the lattice is drawn in fig. 1 with the layout the site uses for every frame.

the layout is a drawing convention, not a claim about the shape of the eye. the rig assigns each of the 892 L1 cells of the right eye to a position in this lattice by the hexagonal column coordinates published with the release, and where a coordinate is missing it orders the remaining cells by the position of their cell bodies along the eye's long axis and fills the lattice in that order. the assignment is fixed once and published in the circuit file so that the same cell always sits in the same place in every frame.

the grating

flies do not see prices. they see motion, and the reflex that a moving world triggers, the optomotor response, is the best understood behavior in the animal. when the whole visual field drifts to one side, a fly turns to follow it, because in nature the only thing that makes the whole world drift is the fly itself turning the other way. this experiment shows the fly a whole field drift and lets the price decide its direction. the stimulus is a vertical sinusoidal grating, eight columns per cycle, and its phase advances in proportion to the log return of the token's price between samples:

where x_c is the horizontal index of column c within its row, P_k is the price of the token in the pons market at the k th of sixteen sample blocks spaced eight blocks apart through the epoch, and I_c(k) is the luminance of column c in frame k on a scale from zero to one. a falling price drifts the grating toward the fly's left; a rising price drifts it toward its right; a price that does not move leaves the grating still, and a still grating drives no motion detector and produces no turn. κ is set so that a move of one part in 128 advances the grating by one full cycle, which puts ordinary moves in the range of drift speeds the fly's detectors respond to. the sixteen frames of an epoch are drawn in fig. 2.

the pathway

the fly's motion vision pathway is the part of the connectome the experiment runs, and it is run whole. light enters at the lamina, where L1 carries brightening and L2 carries darkening. those split into the on and off channels of the medulla, Mi1 and Tm3 on one side, Tm1, Tm2, Tm4 and Tm9 on the other. the channels converge on T4 and T5, the elementary motion detectors, of which there are four subtypes each, one for each cardinal direction, and each T4 or T5 cell compares a delayed signal from one column with a direct signal from its neighbor, which is the correlation that makes a motion detector a motion detector. T4 and T5 project to the lobula plate, where the horizontal system cells HSN, HSE and HSS pool thousands of them across the whole eye and respond to whole field horizontal drift, left cells to one direction and right cells to the other. the horizontal system cells project onward to descending neurons, among them DNa02, which carries steering commands to the body. the whole path is drawn in fig. 3 and every cell in it is a real cell with a body id in the release.

the model is a leaky integrate and fire neuron at every one of those cells, with the parameters of shiu and colleagues: membrane time constant 20 ms, resting potential −52 mV, threshold −45 mV, reset to −52 mV, refractory period 2.2 ms, and a synaptic jump of 0.275 mV per counted synapse, positive for acetylcholine and negative for gaba and glutamate. the step is 0.1 ms. each of the sixteen frames is held on the eye for 50 ms of model time, so an epoch is 800 ms of fly time and 8,000 steps. the stimulus enters as a current into the L1 and L2 cells of each column proportional to the change in that column's luminance between steps, positive into L1 for brightening and positive into L2 for darkening, which is how the lamina splits the world. the neuron is drawn in fig. 4.

the turn

the fly's answer is read where a fly's own body reads it: at the horizontal system. during the 800 ms of an epoch the rig counts every spike fired by the HS cells of the left lobula plate and every spike fired by the HS cells of the right, and the turn is the difference:

the reading is deliberately crude. the sign of t is the direction the fly is turning. if the grating drifted left during the epoch, because the price fell, and the fly turned left to follow it, the fly saw the fall and bites. if the price rose, or did not move, or the fly did not turn to follow it, the fly rests. size is the strength of the turn as a fraction of all horizontal system activity, quantized to eight levels, and it sets what fraction of the fly's cap is spent. a fly that turns hard spends the whole cap. a fly that barely turns spends an eighth. no other output of the model is used, no threshold is tuned, and the descending neurons are simulated but not read, because the experiment wants the reading to be at the cell type whose response to whole field motion has been characterized for fifty years, not at a cell whose role is still being described.

the arena

the money lives in one contract, the arena. the arena is the creator fee recipient of the token on pons. anyone may call collect, which pulls the accrued fees in and splits them exactly in half: one half into the fly's budget and one half into the metronome's budget, with an odd wei going to the metronome. the arena has no owner. it has one privileged key, the fly key, which the rig holds, and the only thing that key can do is call the fly's act with a kind, a size, and two hashes. the key cannot withdraw, cannot redirect, cannot change a parameter, and cannot spend more than the cap the contract computes. the contract's whole interface is these five functions:

collect     pull creator fees from pons, split them in half between the arms
flyAct      fly key only: rest or bite, with a size and the two hashes, once per epoch
controlAct  anyone: the metronome bites its cap, once per epoch
sweep       anyone: if the fly has not acted for 256 epochs, its budget moves to the metronome
capNow      view: what each arm may spend right now

a bite is a buy on the pons market with no minimum output, followed by a transfer of every token received to the dead address. the arena counts the tokens it holds before and after so the number burned is measured, not predicted. a rest spends nothing but still writes a receipt, with the hashes, so that the epochs in which the fly looked and declined are on the record alongside the ones in which it bit. the storage is drawn in fig. 5.

the two arms

an experiment needs a control, and the control here is a metronome. the metronome's budget is spent by anyone calling controlAct once per epoch; it bites the same cap the fly is allowed, a sixteenth of its budget, every epoch, whatever the price is doing. the fly's budget is spent only when the fly bites, and only by the size the fly's turn sets. both arms buy on the same market, both burn to the same address, both write the same receipt. the difference between them is that one of them looked.

the measure is tokens burned per coin spent, computed for each arm from its receipts and rendered side by side in the state of the experiment. a fly that bites on falls buys at lower prices than a metronome that bites on a schedule, so if the fly is seeing, its number should be higher. if it is not, the metronome wins, and that result is as public as the other one. the experiment does not have a preferred outcome, and the page does not editorialize the ratio; it prints two numbers.

the cap and the sweep

the cap keeps either arm from moving the market. an act may spend at most a sixteenth of its arm's budget, so the largest buy the market ever sees from the arena is bounded and the usual one is small, and a searcher who sandwiches an act is bounded the same way. the cap is a fraction, not a fixed amount, so it scales with the fees and needs no one to adjust it. the cadence is one act per arm per 128 blocks, enforced by the contract by block number, and it cannot be shortened by anyone.

the sweep keeps the fly honest. if the fly key has not acted, bite or rest, for 256 consecutive epochs, anyone may call sweep and the fly's entire budget moves to the metronome. a fly that stops looking loses its turn. this is the only way money moves between the arms, it is one directional, it is public, and it is drawn in fig. 6. the rig can therefore fail in exactly one visible way: by going quiet, and the consequence of going quiet is written into the contract rather than left to anyone's discretion.

the receipt

every act writes a receipt: the arm, the act index, the block, the kind, the size, the coin spent, the tokens burned, the budget left, and two 32 byte hashes. for the fly's acts the first hash is the keccak256 of the sixteen frames it was shown, 892 luminance bytes each in lattice order, 14,272 bytes in all, and the second is the keccak256 of the spike count of every neuron in the circuit over the epoch, two bytes each in ascending body id order. for the metronome's acts both hashes are zero, because it saw nothing and fired nothing. the rig publishes the frames and the spike counts for every fly act as a plain json file at a public url, and this page fetches each file, recomputes both hashes in your browser, and marks the receipt verified only if both match.

this is the part that makes the experiment checkable rather than merely claimed. a receipt whose file is missing, or whose file does not hash to what the contract recorded, is marked as such on the tape in red and counted in the state block, and no explanation the operator could give would change the mark. a receipt whose file hashes correctly is a proof that those exact frames and those exact spikes existed before the act was signed, because the hashes were signed with it. what the hashes do not prove is that the spikes were produced by an honest simulation of the circuit; that is what the published circuit file and the published model are for, since anyone can rerun the epoch from the frames and compare.

the rig

the rig is the only part of the experiment that is not on chain, and it is described here so that it cannot hide. it runs on a schedule every 128 blocks. it reads the token's price in the pons market at sixteen sample blocks through the epoch from a public rpc node. it renders the sixteen frames by the grating rule. it runs the model over the circuit for 8,000 steps. it counts the horizontal system spikes, applies the turn rule, writes the frame file, hashes it, and signs one transaction with the fly key: flyAct with the kind, the size, and the two hashes. that is everything it does. it holds no other key, it cannot call anything but flyAct, and if it dies, the sweep takes its budget away after 256 epochs.

the circuit the rig runs is imported once from neuprint: every cell of the types in the pathway, both sides, and every synapse between them with its count and predicted transmitter, plus the descending neurons downstream of the horizontal system by synapse count. the import is written to a circuit file whose hash is printed in the docs and on the state block, so that a reader can fetch the file, hash it, and confirm the fly on the page is the fly in the file.

failure

the failure modes are few and all of them are visible. if the rig stops, the fly rests by omission, its receipts stop, the epochs since its last act climb on the state block, and at 256 the sweep moves its money. if the rpc node the rig reads lies about the price, the frames are wrong, but they are published, and anyone comparing them against the pool's history at those blocks will see it. if neuprint were unavailable at import, there is no circuit and the rig cannot run; the arena still collects and the metronome still bites, so the token is still burned, just not by a fly. if pons reverts on a buy, the act reverts, nothing changes, and no receipt is written. if the token's transfer to the dead address returns false, the act reverts and the bought tokens return to the pool through the revert.

what cannot happen matters more. the fly key cannot withdraw, because there is no function that sends coin anywhere but the market. the fly key cannot spend more than a sixteenth of its budget per act, because the contract computes the cap. the fly key cannot act twice in an epoch, because the contract counts blocks. no one can change the cap, the cadence, the sweep, the split, the token, the market, or the fee vault, because they are compiled in. a burn cannot be undone. a receipt cannot be edited. and the operator of the rig cannot claim the fly saw something it did not, because what it saw is hashed into the receipt before the act exists.

what remains

here is the complete list of what a holder of this token trusts. the arena, whose functions have no owner and whose one privileged key can only spend under a cap. the pons market, which prices the buys. the robinhood chain block number, the only clock. the published connectome, which is the fly. and the rpc connection of their own choosing. the list of what they do not trust is longer and is the point: no server's word, no dashboard, no operator's account of what the fly did. every number on this page is a read from public state or a hash check anyone can repeat.

the experiment is small on purpose. one fly, one grating, one turn, one cap, two arms, and a receipt that carries what the fly saw. everything else that could have been added, and was not, was left out so that the question could be asked cleanly.

state of the experiment

the last frame

the tape