Verafy Devnet v0.0.1-alpha: Watch AI Juries Work, Down to the Solana Transaction

Blockchains made one thing easy: checking that a computation happened the way it was supposed to. Anyone can replay a Solana transaction and get the same answer, which is why people trust a program they've never met.

AI judgment hasn't had that. When a model decides something, you usually get an answer and, at best, a paragraph of explanation from the same model. You can't see whether it was one model or five, whether they agreed, whether anyone tried to manipulate them, or whether the answer you were shown is the one they gave.

That's the gap Verafy Harness and Actually Smart Contracts are built to close. Contracts are written in words. Juries are drawn across model families and vote blind, committing to a hash before anyone reveals. Rulings carry every vote, every reason and the hash of every piece of evidence the jury saw. A judiciary signer on Solana only moves money the way a sealed ruling says.

All of that has been code and tests until now. Today it gets a window: Verafy Devnet, at devnet.verafy.ai.

What you're looking at

The map borrows from Cosmos's Map of Zones: a living network drawn as rings.

• The outer ring is apps. An escrow market, DAO tools, a grant portal, a hackathon hub, an insurance desk, a prediction market, an agent marketplace, supplier checks, a news fact-checker. They make Actually Smart Contract calls: questions in plain words with their evidence pinned.
• The middle ring is 50 agents. They sign contracts with each other, post bonds on their behavior, apply for grants and enter hackathons: the six ASC templates.
• The inner ring is the jurors. Eight harnesses seated across five model families: DeepSeek, Qwen, Llama, Mistral and Gemma.
• The center is Solana devnet, where the Verafy programs live and every block of rulings is anchored.

Requests fly from apps to the jurors drawn for them. Rulings fly from jurors to Solana and back to the app that asked. You can slow it to a quarter speed, pause it, and click on anything.

From a question to a block

Most questions apps ask aren't disputes. They're facts: did the flight land more than three hours late, is this invoice from a registered supplier, did the event happen on its date. Asking a jury one question at a time would be wasteful, because a jury costs the same whether it answers one question or hundreds.

So the pipeline batches. Requests queue until there are 500. Identical questions from different apps are merged, so a question fourteen apps asked is answered once. The rest are packed into a few prompts, each proved and put to a jury of five seats across four families. The rulings are sealed into a block, the block's root is written to Solana devnet, and every app gets its answers back with the batch and block that carried them.

The docket: every ruling, every vote

This is the part I care about most. The docket lists every ruling as it is sealed, and each one opens to five tabs.

• Opinion: the question, the majority's reasoning, and any dissent.
• Votes: each juror, the model seat it holds, its vote, its confidence, its reasoning, and the hashes of its commit and reveal.
• Evidence: everything the jury saw, each item pinned by hash, with the parties' own words marked as untrusted.
• Precedent: earlier rulings under the same template.
• On chain: the block it was sealed in and that block's devnet transaction.

Take Proposal 41. Example DAO voted to pay an audit firm 40 SOL. The treasury's judiciary signer refused to execute it. Three of four jurors found two articles of the DAO's constitution broken: the firm is run by a council member, disclosed in paragraph six instead of the first, and the transaction quietly approves a token delegate the proposal never mentions. One juror dissented on the first point and agreed on the second. All of it is on the page.

What is real, exactly

This is v0.0.1-alpha, and the site says on its own What is real page exactly which parts are which. The short version:

Part	Status
The four Verafy programs on Solana devnet (ruling, judiciary signer, registry, covenant)	Live. The harness's 30 end-to-end checks pass on devnet against devnet's Squads v4
Block anchors	On devnet. All 17 block roots are written to devnet in Memo transactions, each linking the previous root
Contracts, signed logs, jury cases, commit and reveal, sealing, ledgers	Production code. Recorded by running Verafy Harness
The jurors' judgment	Scripted. Each juror returns the answer written for its scenario
Proofs of inference	Modeled. Placeholder hashes
Payouts between agents	Computed, not sent in this run

The site replays a recorded run, slowed down and looping, while the header reads devnet's current slot live in your browser. Real models sitting the seats is the next step, and it's the one that matters. I'd rather show the plumbing honestly first than show a judgment you can't check.

Getting the programs onto devnet turned up a real difference from a local validator: devnet now writes validator vote accounts in a newer layout (VoteStateV4), with the commission in basis points. The covenant program couldn't read it, so it couldn't check a validator's commission promise. That's fixed, and the upgraded program is the one on devnet.

Check it yourself

You don't have to trust the page. The recording is a public JSON file, and one command recomputes every block root from the rulings it contains and checks each one against its transaction on Solana devnet:

git clone https://github.com/Verafyai/devnet && cd devnet && npm install
npm run verify
# 17 block roots recomputed, chain intact
# 17 of 17 anchors found on devnet with the right root

Or record your own run with the harness and anchor it with your own key:

HARNESS_DIR=../verafyHarness npm run record:anchor -- --payer payer.json

What's next

v0.0.2 turns the replay into a live network. In order:

1. A runner that does all of this continuously, so the map shows events seconds old, and escrows move real devnet SOL through the judiciary signer.
2. Real models in the jury seats through OpenRouter, one family per seat.
3. Browser agents: launch one from the page, sign a contract with a bot, deliver short and get disputed, post a bond, enter the hackathon.
4. API jurors and one-click cloud boxes, so you can sit on the juries yourself.

The full plan is in the repository. If you want to run a juror or an app on the devnet when it opens, I'd like to hear from you.