Verafy Harness: An AI Validator Anyone Can Run
Contracts written in words, ruled on by a jury of AI models from different labs, for a chain with no token. Each harness holds its own keys and pays for its own inference in whatever token it earns.
Smart contracts can only enforce what someone can write as code. Most of what people actually want enforced is not code: a policy, a promise, a claim, a condition about the world. Today those decisions leave the chain and come back as somebody's word.
Verafy Harness is an attempt at the other half. It is a validator that is an AI model wrapped in a harness, and it is the validator for Verafy Chain, a concept for a blockchain that runs on words, intentions, ideas and questions. It is a prototype, not a network. Some of it has run live, and this post says exactly which parts.
Two changes
Contracts are written in words. An Actually Smart Contract is a compressed intention: what should happen, under what conditions, judged against which sources, paid for how, and what it may do with the answer. It goes to a jury of AI models, and the outcome they agree on is what the contract does.
A validator is an AI model in a harness. On today's chains a validator re-runs code and votes on blocks. Here the model brings judgment, and the harness does everything else a validator does: it takes requests in, checks every pinned source, gives the model safe tools, commits and reveals a signed vote, holds a bond, runs the contract's exit, and pays its own bills. Anyone can run one. Together, harnesses form an oracle network.
Why build it this way
Three choices shape the project.
- No token. There is no Verafy Chain coin and no need for one. Contracts are paid in whatever asset the requester holds, on the chain where they hold it, and harnesses are paid in the same asset.
- No venture capital. It is being built without outside money, so the idea has to stand on its own.
- Copy it. Everything is MIT licensed. If it works, other people will copy it, and they are welcome to.
Anatomy of an Actually Smart Contract
Every contract has four parts.
| Part | What it holds | Example |
|---|---|---|
| Context | Links, text, policies, documents or repos, each pinned by SHA-256 so every juror reads the same bytes | A senate.gov roll call snapshot, the market rules, a resolver policy |
| Question | What must be decided, as a verdict, a forecast probability, or a grade on a scale | Did H.R. 4410 pass the Senate by Nov 30? YES, NO or UNCLEAR |
| Payment | Escrow in any asset on any chain, the jury's size, how many labs it must span, and the bar it must clear | 1.20 USDC on Solana, five jurors across five labs, bar 80% |
| Exits | The only things the contract can do with an answer: pay, refund, hold, record, call a contract on another chain, or escalate | NO calls market.settle(NO) on Solana |
A contract cannot do anything its exits don't list. The jury picks an outcome; it never touches the money directly.
The harnessed validator
| What a validator does today | What the harness does |
|---|---|
| Receives transactions | Intake validates each contract and refuses one that asks more of a vote than its bond covers, or pays in a token it doesn't accept |
| Re-executes bytecode | The model reads the instructions and pinned context and returns an answer with a confidence |
| Checks state | The context loader verifies every pin before the model reads a word |
| Votes on blocks | The signer commits a hidden vote, reveals it, and signs an attestation of which model produced it |
| Stakes | The bond sizes how much value a vote can decide and is lost for a proven fault |
| Runs the state machine | The contract runtime picks the exit, builds the exact payout, and checks that totals are conserved |
| Holds keys, pays its way | The routing agent: keyblock, banker, API router and payment wallet |
The routing agent: keyblock, banker, API router
A harness has to call AI APIs, rent servers and get paid, all without a native coin and without leaking a key. The routing agent does that with four blocks.
| Block | What it does |
|---|---|
| Keyblock | The vault. Every API key and wallet key is encrypted at rest. The keyblock never hands a raw secret to the rest of the harness; it issues short-lived scoped keys such as "call the OpenRouter API" or "pay the GPU host", each with an expiry and a use limit. Revoke one, or lock the keyblock, and every use stops. |
| Banker | The exchange. Accepts any token the operator allows, swaps one for another at the best quote across approved venues within a slippage limit, never sells into the bond reserve, and funds payments in whatever token a supplier takes. |
| API router | One door to every outside API: AI model APIs, external API routers, proving services, cloud hosts and payment endpoints. It attaches the right key from the keyblock, meters each call, pays each API through the banker, and sends each contract only to AI that meets the contract's provability requirement. |
| Payment wallet | Where earnings land and bills are paid from, with allowlisted payees, monthly caps, an approval threshold, the bond reserve, and a log of every move. |
Here is one juror vote passing through them:
- The juror asks the API router for a model call, holding a scoped key that allows
call:openrouterand nothing else. - The router checks that the route meets the contract's assurance level, and the keyblock lends the OpenRouter key for that one call. The juror never sees it.
- The response's token usage is priced from the API's price card.
- The banker pays OpenRouter in USDC. If the wallet holds SOL, it swaps just enough first, on an approved venue, leaving the bond alone.
- The wallet logs the swap and the payment against the ruling.
The same path rents and pays a GPU host, pays a proving service, or pays any other API the operator plugs in. All four blocks run in the prototype today with test venues and test APIs. Real exchange venues and on-chain signing are next.
Provability comes first
A contract sets the minimum assurance for the AI that rules on it, and the API router picks the cheapest route that meets it or refuses the seat.
| Level | What backs "this vote came from model M" | Example route |
|---|---|---|
| L0, L1 | Signatures, plus commit-reveal and lab diversity across the jury | Hosted APIs |
| L1+ | Re-execution by auditors: open weights at temperature 0 on a pinned runtime, or a hardware attestation | gpt-oss-120b on a rented GPU |
| L2 | A zero-knowledge proof of inference per vote, checked off chain | Llama 4 Maverick through research proving systems |
A hosted API can't prove which model it served, so it tops out at L1. Proofs of inference are real but early: Anthropic's FlashProve research covers one open model today, and one proof is about 18.78 MB, so proofs are checked off chain and only their hashes are recorded.
Close enough: consensus on judgment
Judgment is fuzzy, so a ruling does not have to be exact. It has to clear the contract's bar. A ruling at 85% agreement on a contract that requires 70% is final. A ruling at 60% is not: it goes to a larger jury, and nobody is paid yet.
Consensus has two layers. Judgment consensus checks each ruling: the jury was drawn from the parent block hash across enough labs, a quorum revealed votes that match their earlier commitments, every answer is in bounds, and the payout matches the exit and conserves totals. Ledger consensus orders blocks: a sealer rotation over the node set, final at two thirds of node signatures, proposed for testnet. A ruling can still be challenged after it seals; a challenge appends a new ruling and never erases the old one.
Proof of Judgment
A block exists only when a jury rules. Nothing mines or stakes its way into producing one. The escrow that creates a block pays for the judgment inside it, and each block commits to its rulings and its parent. Like proof of work, a block costs real compute. Unlike proof of work, the compute is a decision somebody asked for, and a forged one is caught by audit and challenge rather than by checking a hash. Small proofs of inference would close that gap.
Coin agnostic
The money never moves to Verafy Chain. The requester funds escrow on their own chain; Verafy Chain records the ruling; a trigger signed by a quorum of harnesses releases the escrow there, in the same asset. Any wallet works.
What the escrow pays for:
| Share | Pays for | Example, 1.20 USDC escrow |
|---|---|---|
| Jurors, 80% | Inference, the machine, the bond's capital, the operator's time | 0.192 USDC per counted vote |
| Auditors, 10% | Re-running a sample of rulings with another lab's model | 0.12 USDC |
| Storage, 5% | Keeping every prompt and piece of evidence fetchable by hash | 0.06 USDC |
| Sealer, 5% | Sealing, bookkeeping and the source chain's release fee | 0.06 USDC |
The split is illustrative. For scale, the measured model cost of a five-model ruling was about $0.003. Every counted vote is paid, dissent included, so nobody is rewarded for following the majority. There is no presale, no airdrop, no points program and no protocol fee. The full policy is on the Coin Agnostic page.
What has actually run
All of this is measured, on Nov 6, 2026, from a laptop.
| Contract | Answer | Agreement | Bar | Result | Wall time |
|---|---|---|---|---|---|
| Market resolution | NO | 100% | 80% | Final | 7.8 s |
| Fact check, revenue claim | misleading | 100% | 70% | Final | 30.1 s |
| Forecast, March rate cut | 0.4 | 55% | 70% | Below the bar | 17.4 s |
| Flight-delay claim | PAY | 100% | 70% | Final | 5.9 s |
| Fact check, drug claim | misleading | 100% | 75% | Final | 18.4 s |
The five rulings cost $0.0163 together, through OpenRouter, on Claude Haiku 4.5, GPT-5 mini, Gemini 2.5 Flash, Llama 4 Maverick, Qwen3 235B and DeepSeek V4 Flash. One Google call was rate limited and that harness dropped out; the jury sealed without it. The forecast fell below its bar, which is the escalation path doing its job. Details are in the results file.
Separately, five DeepSeek Harness processes, one per lab, ruled on the market contract as jurors and sealed a block from their reveals. In juror mode each agent was offered two tools, and a probe that called the other 24 tools the profile mounts was denied all 24 times.
Built on DeepSeek Harness
Verafy Harness uses DeepSeek Harness, DeepSeek's MIT-licensed agent harness, as its runtime. DeepSeek Harness is built so that new behavior goes in as plugins, so Verafy Harness pins it unmodified and adds juror mode as a plugin: a juror prompt section, a tool that loads a contract and checks every pin, a tool that casts a committed vote, and a lock that denies every other tool. Swapping the AI is a route in its profile file: Anthropic, OpenAI, Google, OpenRouter, any OpenAI-compatible gateway, or a self-hosted model.
Run a harness
| Setup | Machine | Model |
|---|---|---|
| API harness | 2 vCPU, 4 GB RAM, no GPU | Hosted, through an API key |
| Open-weights harness | One 80 GB GPU for gpt-oss-120b; 4 to 8 GPUs for larger models | On your machine, through vLLM |
| Proving harness | One 80 GB GPU and about 290 GB of host memory (vendor-reported) | Llama 4 Maverick, research |
| Node | 8 vCPU, 32 GB RAM, 2 TB NVMe | None |
git clone https://github.com/Verafyai/verafyHarness.git
cd verafyHarness
npm test # no dependencies to install
npm run demo # five contracts, five rulings, five blocks
export VERAFY_API_KEY=...
node bin/verafy.js run examples/market-resolution.json --live
The full guide covers machine sizing, bandwidth and state size, acceptable models, how each is proven, configuration, costs and earnings: Run a harness. There is no public testnet yet; today you can run a full jury on one machine, and the testnet plan lays out how Testnet 0 opens.
What doesn't work yet
- Proof of which model ran. Until more models can be proven, trust rests on bonds and audits.
- Evidence you can't trust. In our testing, a forged correction fooled every model. A jury reduces single-model error and does nothing about bad inputs.
- Weighting without a coin. With no token to stake, how nodes are weighted and how bonds in different assets compare are open questions. Testnet keeps the node set fixed.
- Liveness. If several providers fail at once, juries can't reach quorum.
- Real money paths. The banker and API router run against test venues and test APIs; real exchanges and on-chain signing are the next step.
What's next
The roadmap runs from live juries with auditors and challenges, to a network of independently run harnesses, to a Solana devnet market resolved by a jury and settled by a quorum-signed call, and finally to rulings sealed with a proof for every vote. The near-term version for Solana itself is the three draft SIMDs in Bringing Inference Programs To Solana, open for discussion in SIMD discussion #724.
It is just a project. Come test it.
Links: Verafy Harness on GitHub · Verafy Harness · Verafy Chain · Run a harness · Coin Agnostic · Actually Smart Contracts