booting connectome…
the prover · don't trust, verify

One fly. One task. A receipt you can't fake.

Pick a genome and hit run. The fly runs on a locked down copy of the connectome (pure integer math, zero randomness), so the same fly on the same task gives the exact same answer on every machine. Each run seals one tiny hash receipt anyone can reproduce.

Step 1 · pick a fly, then run it

Every number is a different fly brain, wired from that seed. Type any number, roll a random one, or tap a proven fly below that already reaches the food. Then hit run.

proven to reach the food · tap one
the arena · genome #130tick 0 · dist 0 · act -

cyan is the fly (its motor neurons steer it). gold is the food. the trail is its path. it only knows the bearing and distance to food. the brain does the rest.

proof receiptawaiting run
genome root·
start commit·
end commit·
transcript root (hash chain)·
ticks
·
final dist
·
outcome
·
breed a new genome
×

deterministic crossover. the child seed is reproducible onchain (FlyGenome.sol). find the ones that solve the task, breed the winners.

prover log
press run to watch the fly solve the task.
verified runs registrystore: … · GET /api/runs

no runs yet. prove one above and it lands here, recheckable by anyone.

Straight talk on the seams: verify today is optimistic, it reruns the exact engine and checks the receipt, the same move a challenger makes onchain to take a liar's bond (FlyVerifier.sol). The one shot zk proof (check it without rerunning) is wired but not faked (IProofVerifier.sol). And the wiring is a deterministic stand in until the real FlyWire import. No LARPing. Everything here actually runs.

wtf am i looking at

Anyone can post a fly brain. Nobody can prove it ran. We can.

Every “AI onchain” play has the same hole: you have to trust that the thing actually ran the way they say. A fruit fly's brain is the rare neural net small enough to make that provable, so VERIFLY makes it the “gm” of verifiable compute: run it, hash every tick, and let anyone check the receipt or take your bond. Don't trust. Verify.

140 K

neurons, the whole brain

A fruit fly's entire connectome is small enough to run in full, and, unlike every LLM, small enough to actually prove end to end. That's the unlock.

100 %

same input, same output

Pure integer math, no dice rolls, no GPU weirdness. Run the same fly on the same task on any machine and you get the identical result. Every time.

1 honest

is all it takes

One person who reruns it can catch a fake and take the liar's bond. You don't have to trust the team, the RPC, or anyone.

1 hash

is the whole run

Every tick gets hashed and chained into one 32 byte receipt. Tiny to post onchain, impossible to fake, trivial to recheck.

01 · RUN
the fly does the task

A locked down connectome smells its way to the food on a grid. Same run on every machine. That's the point.

02 · HASH
every tick is a receipt

Each step's brain state gets hashed and chained onto the last. Change one thing and the final hash changes. No hiding.

03 · POST
drop the hash + a bond

Whoever ran it posts the receipt onchain with a stake. Cheap, it's a hash, not a GPU farm. The compute never touches the chain.

04 · VERIFY / REKT
rerun it, or slash

Anyone reruns and challenges a mismatch to take the bond. Live now. The zk version does it without rerunning, coming soon.

why anyone should care

“Proving a computation ran” sounds boring. It's the whole game.

The fly is the mascot. The tech underneath, cheap public proof that a specific AI computation actually happened, is what these unlock:

01

Verifiable AI agents

An agent claims "the model told me to ape in." Prove it actually ran that model, not a cheaper one, not a human at a keyboard. The receipt doesn't lie.

02

Onchain games and worlds

NPCs, mobs, and bots whose behavior is provably the real sim, not a cheat. Every move re derivable, so nobody can rig the boss fight.

03

Trustless prediction markets

Settle "will X happen?" from a reproducible computation instead of a human oracle you have to trust. The house is a hash.

04

Decentralized compute markets

Pay someone to run inference, then cryptographically confirm you got the real result, not a stub. Slash them if not.

05

Auditable model outputs

A model made a call that affects someone. Anyone, a user or a regulator, can rerun it and confirm the output was legit.

06

The benchmark itself

The fly is small enough to prove end to end, so it's the reference workload the whole verifiable inference stack gets tested against.

for builders · the API

Prove and verify over HTTP.

The prover is a real service. Runs persist to Postgres (with a zero config in-memory fallback so it boots with nothing installed). Point anything at it:

POST/api/prove{ "seed": 130 }run a genome server side, seal the proof, store it
POST/api/verify{ "seed": 130 }independently rerun and check the stored receipt
GET/api/runs?limit=24list proven runs, most verified first
GET/api/healthservice status and which store is active
# seal a proof, then verify it independently
curl -s https://veriflylabs.xyz/api/prove  -H 'content-type: application/json' -d '{"seed":130}'
curl -s https://veriflylabs.xyz/api/verify -H 'content-type: application/json' -d '{"seed":130}'
# => { "ok": true, "reason": "reran the whole thing, commitments match", ... }
why a fly, why now

The meme was “we deployed the brain.” The alpha is proving it ran.

Deploying a fly brain and showing pretty spikes is a screensaver. Cool, but anyone can fake the numbers. The thing nobody's shipped at meme scale is provable compute: a cheap, public way to know a specific run actually happened, without rerunning it yourself or trusting the dev.

VERIFLY makes the fly the benchmark for exactly that. The genome is an onchain asset. Running it spits out a receipt anyone can recheck. Meme on top, actual cryptography underneath. That's the moat a screensaver doesn't have.

And it's honest about the seams: rerun verification is live today, the one shot zk proof is wired, not faked. Read every hash. Rerun every fly. No trust required.

A fly can't read a chart. But its brain, run for real, spits out an answer you can check without trusting whoever ran it, which is the one thing every AI coin is missing.
the fine print, no cap

Art experiment and working prototype, not an investment. The engine is real and deterministic, verification is rerun and slash today, and the zk SNARK backend is a wired slot, not a live proof yet. The wiring is a deterministic stand in until the FlyWire import lands. Nothing here is financial advice.