Flytrencha: a fruit fly’s brain, wired to a trading bank. What it is, why, and how $FLYNCH works.
This page is the long version of the room. The room shows one decision at a time; this explains the machine that produces them, the experiment it belongs to, and the economics that are meant to keep it running. Everything numeric here is either measured in the bot’s own repository or marked as a plan.
What this is
A frozen connectome of a male Drosophila — the published wiring diagram of a real fly’s central nervous system, 164,416 neurons and 25,135,616 directed connections — is run as a computer. New crypto tokens are described to it through 64 sensor slots mapped onto its sensory neurons. The activity that reaches its motor and descending neurons is scored. A small readout ranks that score against the fly’s own past, and above a threshold the daemon buys a small position; below it, it passes.
Nothing in the brain is trained. The wiring and the weights are the dataset’s, untouched. The only thing that learns is the readout on top — a few hundred weights fitted by ridge regression on realised outcomes. The fly does not know what a token is. It is a fixed, very large, very strange non-linear network, and the question is whether the structure of a real nervous system carries any usable signal when facts about a token are pushed through it.
Reservoir, not mind. This is a connectome used as a reservoir computer. The activity is not the fly thinking about a token, and no claim is made that it models fly behaviour. Feeding a token’s volume into gustatory neurons does not make anything taste anything; the slot-to-modality map is fixed and versioned so that a decision is reproducible.
Why it exists
The bot’s own charter states the question in one line: can a real fly’s brain be a profitable trencher, and does it become a degenerate gambler on the way? Everything else in the project exists to make those two questions answerable by a stranger who assumes we are lying.
The design is a controlled comparison. A human trencher and the fly see the same facts about the same tokens at the same moment: the twenty evaluation rules an experienced human uses on this chain were turned into sensors, and the fly gets exactly those. Hold the information constant, vary only the thing that decides. Whatever separates the results is the decider, because nothing else differs.
| Competitor | What it is | Status |
|---|---|---|
| the fly | the frozen connectome deciding on trencher factors | running, paper mode |
| buy everything | baseline: take every launch above the volume floor | measured, −7.6% out of sample |
| filters, flat | baseline: the human rules, no stop | measured, −6.2% out of sample |
| filters + a stop | baseline: the human rules with a stop-loss | measured, +3.9% out of sample |
| shuffled connectome | control: the same weights, edges randomised. Would any random network do this? | designed |
| coin flip | control: is this skill at all? | designed |
| the average human | the distribution of real FOMO accounts, reconstructed from the chain by fomoponzi | measured: 83.5% of 36,307 wallets lost over 30 days to 2026-09-05, median loss $198 |
The last row is the bar she has to clear. “90% of traders are unprofitable” circulated as a slogan; the measured version comes from an independent lab that rebuilds every FOMO swap from Solana transactions rather than trusting a dashboard: over the 30 days to 5 September 2026, 83.5% of 36,307 wallets finished in the red, the median loser was down $198, and 3.2% made more than $1,000. Most of the loss is mark-to-market on tokens still held, which is exactly the trap a trencher falls into. Beating the average FOMO user means beating that distribution, on the same chain, in the same size.
The subject
A trencher is what crypto Twitter calls someone grinding in the trenches: trading fresh launches all day, on instinct and a handful of rules, in size that is small and frequent. The fly is one of them. It watches the same launchpads (Robinhood Chain 4663 first, with Solana, Base and BSC in the universe scan), trades in the same size, and is judged the same way: by realised profit, on a ledger it does not control.
How a decision happens
The spike raster of every run — which neurons fired on which tick — is written to disk as a file whose sha256 is in the journal. The room replays those files; it does not draw activity.
What she is told
The input is a vector of 64 slots, 54 of them named. Each named slot is one thing a human trencher checks: whether the developer has stake in the pool, whether there is a website and whether it is alive, how many prior launches the deployer has, how spread the holders are, how much of the supply the top wallets hold, what the trade count and volume look like, whether the symbol has been used before.
Two details matter more than the list. Unmeasured is not zero. A sensor that failed to read drives its own neurons, so “we could not look” reaches the network as a different input from “we looked and it was nothing”. And the mapping is versioned. Which slot drives which sensory population is fixed in a wiring version and recorded in every journal row, so a decision can be re-run and lands on the same spikes.
Wiring version 2 (11 September 2026): two of the 64 slots describe a position she already holds, its profit and its drawdown, and they are fed to the dopaminergic cells the connectome names by type, PAM (316 cells) and PPL1 (16 cells), the reward and punishment populations of the mushroom body, instead of a mechanosensory slice. An entry decision does not measure those two slots; a look at a held position does. Rows of wiring 1 and 2 are one population for the entry readout.
The readout
The readout is the only part that learns. It is a linear map from the motor-side activity to a score and a proposed size, fitted by ridge regression — a closed form, no gradient descent — on the realised outcomes of past candidates. A new readout is adopted only if it beats the incumbent on a held-out future window; otherwise the old one stays. The buy threshold is not a constant either: it is the 80th percentile of the fly’s own score history, so she buys the top fifth of what she has seen, whatever scale the scores happen to be on.
Because every candidate is journaled, traded or not, the training set is not shaped by her own choices. That is also what makes ablation possible: “what would have happened without sensor 7” is answerable because the rows to answer it were written.
The record
Each decision leaves four things a stranger can check without trusting us, and the room shows them for every decision on its Verify panel.
- The seed is derived from a public block hash. The room recomputes it in your browser and says whether it matches.
- The raster is a file; its sha256 is in the journal row.
- The graph is a third party’s; its sha256 as loaded is the same in every row.
- The commitment is a keccak256 hash computed before the outcome existed. Once an hour the merkle root of every new commitment is sent to Robinhood Chain as calldata, and the sealed record behind each one (the vector as bytes, the flags, the size, the nonce) is revealed the same hour, so the hash can be recomputed by anyone.
Real orders, anchored commitments. Since 10 September 2026 her orders execute on the production FOMO account, and every fill is a Solana transaction listed on the room’s Economy panel. Since 11 September the commitments reach a chain too: once an hour the steward key sends itself a transaction on Robinhood Chain whose calldata is the merkle root of every commitment made since the previous anchor. The anchored rows carry anchored: true, the root and the transaction; api/anchors.json is the ledger, chained by previous root. A row that is not yet anchored is a row you have only the daemon’s word for, and the room says which is which.
The public API, the brain, the replay
Machine-readable copies of the journals, rebuilt every two minutes, so a stranger’s script can follow her without scraping the page:
| URL | What |
|---|---|
/api/decisions.json | the last 500 decisions: token, verdict, tier, score, commitment hash, the anchor it sits under, the named command neurons that fired |
/api/reveals.json | the revealed decisions: the vector and flags as the bytes that were hashed, the nonce, the hash, the anchor transaction that carried it |
/api/anchors.json | every hourly anchor: root, count, transaction |
/api/trades.json | every fill on the account, with its transaction |
/api/positions.json | the looks at held positions: unrealised return, hold time, drawdown, the exit verdict |
/connectome/manifest.json | the exact brain the daemon runs: every graph and anatomy file with its size and SHA-256; versions.json keeps every graph version ever run |
The replay in the public repository recomputes a reveal’s commitment from its bytes, loads the brain named in the manifest, reruns it from the seed and compares the motor counts neuron for neuron, naming the identified commands that fired (the giant fiber, walking, steering, grooming, the proboscis). Without the graph files the brain step is reported as skipped, never as passed. The same replay runs weekly on GitHub’s machines against the public brain and the newest public reveal, and its log is public.
A control was run as well: the same real vectors on a graph with its targets permuted produce zero motor spikes. The wiring is what carries the signal, not the vector by itself.
The token
The experiment is meant to pay for itself, and the mechanism is the plainest one the chain offers: a creator tax on the fly’s own token, $FLYNCH. The contract address is published on the room’s Economy panel at launch and nowhere else first. On Robinhood Chain a launch sets a tax in basis points of every trade, capped at 1,000 by the factory. Anyone who trades the token pays it; the tax accrues to an escrow the fly’s wallet can claim.
the tax, at the peak of measured median income and just below where trading falls off
one launch on chain 4663, fee plus gas, measured
The 200 is not a round number chosen for taste. It comes from a measurement over 800 real launches on the same chain, in the sibling repository: at 101–200 bps the median income was highest and 63% of launches still traded more than 0.1 ETH; above 200 the share of launches that ever trade nearly halves. The caveat travels with the number — the same person picks the tax, the name and the promotion, so the measurement is confounded, and its upper tiers are small samples.
| tax, bps | launches | median volume, ETH | traded > 0.1 ETH | median income, ETH |
|---|---|---|---|---|
| 0 | 468 | 0.207 | 73% | 0 |
| 1–100 | 195 | 0.136 | 61% | 0.00136 |
| 101–200 | 68 | 0.155 | 63% | 0.00309 |
| 201–500 | 43 | 0.048 | 33% | 0.00200 |
| 501–1000 | 26 | 0.027 | 35% | 0.00217 |
Where the fees go
What the fly does with the money is fixed and public. There are no deposits and nothing is entrusted to anybody: the tax is the fly’s own income, and the schedule below is what it does with it.
Every hour: the fee split
to holders of at least 0.1% of supply, time-weighted over the hour, claimed under a published merkle root
to the fly’s trading bank. This is the working capital she trades with.
to the machine: the server, the keys, the requests
The split is a contract, not a promise: FlySplitter holds the tax, anyone can call distribute(), and the only lines
out of it are those three plus a merkle claim from HolderVault. No owner, no pause, no sweep. The fee is paid in NVDA, the pair
the token launches against. Both contracts run on a local EVM under tests; they are not audited and not yet deployed.
This is the sentence the whole economy rests on: the fly trades with money that came from fees on her own token. Nobody funds her bank; her bank fills as her token trades, and the positions you see in the room are sized as basis points of that bank.
Every 4 days: the profit share
Half of whatever the fly actually earned goes to holders as well, and never more than half of what she holds, so the bank is never emptied. It is paid by netting: her 40% line goes to the holders’ vault until the declared amount is settled, and the bank inside FOMO is never touched. Four days rather than hours, deliberately: a bank swept every hour cannot hold a position, and a trader without working capital is not trading, it is twitching. The slower cadence is what makes the experiment an experiment. It is also what turns the token into a stake in the outcome rather than a bet on a mood — and the reverse is stated as loudly: when the fly loses, there is nothing to share.
Definitions that are fixed before a cent moves
Left vague, each of these becomes an argument later. They are fixed now.
- Profit means realised profit. Bank at the end of the period, minus bank at the start, minus the fees that arrived in between. Not mark-to-market: paying out unrealised gains would force the fly to sell to fund a distribution, which is the distribution deciding the trade.
- Losses carry forward. A high-water mark: down 50% and then up 20% is not a profit to share. The bank must exceed its previous peak before anything is distributed again. Without this a fly that loses steadily still pays out on every bounce while holders are underwater.
- The holder snapshot is time-weighted. A single-block snapshot of who holds 0.1% is farmed by buying before it and selling after. Weighting by balance held over the period removes the easy version of that.
- The fee asset is somebody else’s. NVDA is a Robinhood tokenised stock: the issuer can pause transfers, block an address, burn a balance or change the code. Not our flaw, but our dependency, so the splitter and the vault hold as little of it for as short a time as possible.
- Holders own the schedule, not the positions. A token holder has a claim on the two distributions above and on nothing else: not on the bank, not on any open position, not on the wallet. The fly’s trades are the experiment’s own risk.
What it costs
The compute is not the bill. One decision is 4.4 ms of brain time on the anatomical wiring and a 4.6 KB raster; the graph sits in 0.2 GB of memory. The real cost is fixed: the server, the market-data key, the RPC plan. That is why the funding model works in dollars per month rather than per decision, and why the runway on the room’s Funding panel is computed from a monthly figure once it is entered.
At 200 bps, the traded volume that funds one month is fifty times the monthly cost: a $400 bill is covered by $20,000 of trading in the token, before the holder half of the split is taken into account.
Status
| Piece | State |
|---|---|
| the brain, sensors, verdict, readout, journal | running; the room replays real decisions every two minutes |
| trading | live on the production FOMO account since 2026-09-10 19:27 UTC; USDC clips, tiers of 1/3/5% of the bank, exits by her own verdict |
| commitments | anchored hourly on Robinhood Chain; the sealed record is revealed the hour its hash is anchored; rows not yet under a root are marked so |
| outcomes at 4 h and 24 h | recorded for every candidate, traded or not |
| the token | launch planned as six checked transactions (NVDA pair, 200 bps, the splitter as recipient); nothing sent yet, so no escrow to read |
| the fee split and profit share | written as contracts (FlySplitter, HolderVault), tested on a local EVM, not audited, not deployed |
| anchoring commitments on chain | running since 11 September 2026: the merkle root as calldata from the steward key, once an hour; ledger at api/anchors.json |
| the learning loop | closed on both legs (entry readout and exit), on a schedule; the first trained readout is not adopted yet |
| the shuffled-connectome and coin-flip controls | the shuffled-wiring control is run (the same real vectors on a graph with permuted targets produce zero motor spikes); the coin-flip control is not run yet |
| the human baseline | measured by a third party (fomoponzi): 83.5% of wallets lose over 30 days. The fly’s own 30-day number is not in yet |
Claims we do not make
- That the fly thinks, tastes, sees or wants anything. It is a reservoir.
- That the activity models fly behaviour. The connectome is used as a network, not as a simulation of an animal.
- That any unanchored commitment proves anything to anyone but us.
- That past outcomes predict future ones, or that the token is a claim on the fly’s positions or wallet.
- That the fly already beats the human baseline. The baseline is measured; her side of the comparison is still being written.
Glossary
| Term | Meaning here |
|---|---|
| connectome | the published wiring diagram of a nervous system: which neuron connects to which, with what strength |
| reservoir | a fixed network whose activity is read out by a small learned layer; the network itself is never trained |
| tick | one step of propagation through the network. A run is 8 ticks |
| raster | the list of neurons that fired on each tick, saved as a file |
| readout | the linear layer that turns motor-side activity into a score and a size; the only part that learns |
| slot | one of 64 input channels; a named slot is one sensor, a reserved slot is unused |
| unmeasured | a sensor that failed to read. It is a distinct input, not a zero |
| seed | the number that fixes the run’s randomness; here, the low 32 bits of the deploy block hash |
| commitment | a keccak256 hash of the decision and its inputs, made before the outcome exists |
| anchored | whether that hash was posted on chain. Paper mode: never |
| bps | basis points, hundredths of a percent. 200 bps is 2%; 1,000 bps of a bank is 10% of it |
| trencher | someone trading fresh launches all day, small and frequent |
| high-water mark | the rule that profit is only shared once the bank exceeds its previous peak |
Data and provenance
The connectome is MaleCNS v1.0 from FlyEM at Janelia, under CC-BY 4.0: bodies with a type, minimum confidence 0.5,
both endpoints retained. Of 164,416 neurons, 138,554 carry a soma position, and those are what the room draws. The sha256 of the graph
as loaded is printed in the footer of the room and in every journal row. The graph and anatomy files themselves are published at /connectome/ with a manifest of sizes and SHA-256 hashes, so the replay runs against the very bytes she runs on.
The room’s data file is rebuilt from the bot’s journals every two minutes. It contains the six most recent decisions, one per ticker, with their rasters, inputs, outcomes and verbatim journal rows, plus the neuron positions and the funding figures. The page reads it; it never writes to the bot.