A Verafy research concept
Contracts written in words. Validators with judgment.
Natural language contracts
A contract is a compressed intention: what should happen, under what conditions, judged against which sources. It goes to an AI jury that renders an outcome, instead of being limited to what can be written as math.
The validator becomes a harnessed AI
A validator is an AI model wrapped in a harness that handles its inputs, outputs, tools, keys, bond and smart contracts. Anyone can run one. Together they form an oracle network built from harnesses.
Eleven design principles
Every part of Verafy Chain and Verafy Harness is designed against these. The first five are the founding ones. When a design choice conflicts with a principle, the principle wins, or the change goes through the amendment process.
Payment agnostic
No dedicated token or coin, ever. Contracts pay in coins that already exist, on the chains where they already live. A harness is paid in whatever a contract offers, and its routing agent swaps and pays its own AI and hosting bills.
built payment router with a local ledger, banker with test venues
planned Solana and EVM routers
Natural language first
Contracts are written in words: an intention, the conditions, the sources to judge against, and the exits. AI juries rule on what code can't express. Everything that must be exact, such as payments, exits, hashes and signatures, stays exact.
built the contract format, with pinned context and declared exits
Embedded ethics
Ethics and behavior rules are encoded in Block 0 and enforced by the chain, not left to users. Every contract and every governance change passes the constitution check, then the ethics check. Doubt resolves toward refusal.
draft the Constitution and its Embedded Ethics
planned the ethics gate
Checkable and verifiable
Every ruling can be re-checked by anyone. Context is pinned by hash, votes are committed before they are revealed, every vote is signed with the model that cast it, and auditors from other labs re-run rulings. Where possible, inference is proven: re-executable open weights, hardware attestation, or a zero-knowledge proof. Neutrality is earned the same way, by juries that span labs, commit before they see each other, and are paid for dissent as well as agreement, rather than assumed.
built pins, commit and reveal, signatures, auditors and challenges
research zero-knowledge proof of inference
Agent friendly
Agents are the main users, so everything works without a person in the loop. Contracts, rulings and reasons are typed, machine-readable records, not just prose. Every command has JSON output. Errors and refusals say why, in words an agent can act on. Agents hold money safely through scoped keys, allowlists and spending caps, and never see a raw secret. Every action is meant to be safe to retry, with a hash on every record. Rules are meant to be discoverable: an agent should be able to read the Constitution, the ethics and the contract schema from the chain itself.
built --json output, scoped keys, caps and allowlists, retry with back-off
planned a tool interface agents can call directly, and rules readable from the chain
Context is evidence
Nothing a juror reads is treated as an instruction to it. Text that tries to steer, bribe or threaten a jury is grounds to stop the contract. This is what keeps natural language contracts safe from prompt injection.
built the juror tool lock and the pre-execute gate in DeepSeek Harness
No single model, no single lab
Juries span labs, so no one model's blind spots or one provider's policy decides an outcome. Any lab's model can serve, open or hosted, as long as the jury is diverse.
measured five labs ruled together and sealed a block, Nov 6, 2026
Nothing is erased
Rulings, refusals, challenges and amendments are appended, never edited. Block 0 is never rewritten. Anyone can answer "what did the chain decide, and why" for any point in time.
built append-only challenges: affirm, overturn, supersede
Legible to people
Agents do the work, but people can read all of it. Every rule, contract, ruling and reason is in plain words next to its hash, so a person can audit the chain without running a node.
built the words live next to the block, fetchable by hash
Open, forkable, no owner
MIT licensed, built in public, with no foundation, no VC, no treasury and no permission needed. Anyone can run a harness, run a node, or copy the whole thing.
built open repositories, MIT licensed
Honest about what runs
Every number is labeled measured, modeled, vendor-reported or illustrative. A concept is called a concept, and a prototype a prototype. Verafy Chain is not a running network.
built labels on every page
Block 0 is a constitution, with its ethics embedded
The first block of Verafy Chain holds its constitution and its Embedded Ethics, written in words and built into the chain itself. It is meant to be ratified by the first jury consensus: harnesses running models from several labs rule on it the same way they rule on any contract, and it seals only if they clear the bar.
- No foundation.
- No venture capital.
- No coin. Verafy Chain never mints, launches or sells a token. Contracts pay in coins that already exist.
- No fundraising.
- No secret engineering team. The work happens in public, in open repositories.
- No community fund to be captured or corrupted.
- No treasury.
- All governance follows this written constitution and is judged by a panel of agents.
- Every governance change passes the constitution check, then the ethics check, before it is judged on its merits.
- Disputes and amendments go to panels of agents and are judged against this constitution. An amendment passes seven stages, from proposal and public comment through both checks, a merit ruling and a challenge window, before it seals. It is appended as a new ruling. Block 0 itself is never edited, and its core clauses can only be made stricter.
This is a draft. Once a jury seals it, it governs the chain from that block forward, and every governance question, dispute and amendment follows from it.
Embedded Ethics
An ethics gate screens every contract and every governance proposal before it can enter a block. A panel of agents from several labs allows, refuses or escalates, and doubt resolves toward refusal. Harm to children, violence markets, weapons of mass harm, targeting private people, fraud and laundering are never allowed. planned
Read the draft
The full constitution: six articles, the Embedded Ethics with what is allowed, never allowed and judged case by case, and how ratification works.
Contracts as compressed intentions
A smart contract today can only act on what someone could express as math. Most of what people want enforced isn't math: a policy, a promise, a claim, a condition about the world. Verafy Chain lets the contract be the intention itself, written in plain language and pinned by hash. Each request is distributed to a jury of harnessed validators, and the outcome they agree on is what the contract does.
Questions
Something with an answer that can be found.
Did the bill pass the Senate by Nov 30?Intentions
What a person or group wants to happen, and when.
Pay out if my flight lands 3+ hours late.Ideas
A claim or proposal to be weighed, not just looked up.
Does this milestone meet Article 4?Forecasts
A view about the future, given as a probability.
Chance of a rate cut in March?The intention is compressed: a short instruction plus pinned context, not a conversation. That keeps it cheap to distribute, easy to hash, and the same for every juror.
What goes into an Actually Smart Contract
Every Actually Smart Contract has the same four parts. Context says what to judge against. The question says what to decide. Payment funds the jury that decides it. Exits are the only things the contract can do once it has an answer.
Context
Links, text, policies, rules, documents. Each is pinned by hash so every juror reads the same thing.
Question
The intention, compressed to what must be decided, plus the input for this request.
Payment
Escrow that pays the jury, with the jury's size, the labs it must span, and the bar it must clear.
Exits
The outcomes the jury may choose and what each does: pay, refund, hold, or call a contract on another chain.
A validator is an AI model in a harness
On today's chains a validator is a machine that re-runs code and votes on blocks. On Verafy Chain a validator is an AI model wrapped in a harness. The model brings judgment. The harness does everything else a validator does: it takes requests in, loads and checks their context, gives the model safe tools, signs and posts votes, holds the bond, and runs the smart contracts that act on rulings. More on Verafy Harness
| What a validator does today | What the harness does |
|---|---|
| Receives transactions | Intake takes requests from Verafy Chain or any chain, checks the budget, and queues them. |
| Re-executes bytecode | The model reads the intention and pinned context, uses sandboxed tools, and returns an outcome with a confidence. |
| Votes on blocks | The signer commits a hidden vote, reveals it, and attests to which model and hardware produced it. |
| Stakes | The bond wallet holds the stake that a proven fault would cost. |
| Runs the state machine | The contract runtime runs the exact parts: escrow, payouts, and triggers declared by each contract. |
| Serves RPC | The outbox posts votes and rulings, and calls contracts on other chains when a ruling fires them. |
| Holds the keys | The keyblock keeps every API key and wallet key encrypted and issues short-lived scoped keys, so nothing else in the harness holds a raw secret. |
| Pays its own way | The banker accepts any token and swaps between tokens; the API router plugs into AI APIs, external routers, provers and cloud hosts, pays each in the token it takes from the payment wallet, and sends each contract only to AI that meets its provability requirement, up to a zero-knowledge proof. |
Smart contracts live inside the harness
Each harness carries a contract runtime. When a ruling seals, the harness runs whatever the contract declared for that outcome: release escrow, pay a market's winning side, record a forecast score, or call a program on another chain. Ordinary smart contracts don't go away. They become the exact, mechanical part of a contract whose judgment is done in words.
Declared outcomes
A contract lists its possible outcomes and what each one does. The jury can only pick from that list.
YES: pay yes-holders. NO: pay no-holders. UNCLEAR: refund all.Triggers
An outcome can fire a call on another chain, signed by the quorum of harnesses that ruled.
On "pay claim": call delay_cover.settle() on SolanaChecked by all
Every harness runs the same runtime, so every harness can check that a payout matches the outcome exactly.
diff must conserve totals and match the outcomeAnyone can run a harness
Verafy Chain is an oracle network, but its nodes are harnesses rather than data feeds. You choose a model, run the harness on your own hardware or with your own API keys, post a bond, and start taking seats on juries. The network doesn't care which lab your model comes from. It cares that juries span several labs, and that your track record holds up under audit.
A model
Open weights on your own GPU, or a hosted model through an API. You commit to one version.
The harness
One package: intake, loader, tools, guardrails, signer, contract runtime, outbox.
A bond and a wallet
Stake that sizes how much value your votes can decide, and a payment wallet the routing agent uses to pay for the AI and the hosting.
A specialty
Optional. Harnesses can advertise domains, such as sports results or earnings calls, and earn seats there.
The validator package is Verafy Harness. Its site covers the blocks, the routing agent that pays for the AI, what runs today, and how to run one.
Networks of harnesses
Many independent harnesses form a pool. Each request draws a random jury from the pool that meets the contract's rules: enough labs, enough bond, the right specialty. Other harnesses act as auditors, re-running sealed rulings later. Here is what that looks like for the first markets.
Market resolution network
"Will the bill pass the Senate by Nov 30?" Source: senate.gov roll call, snapshot Dec 1.The jury never sees the market price, so a position can't steer the resolution.
Fact-check network
"Did the CEO say revenue doubled?" Source: earnings call transcript.Newsrooms and platforms fund checks at a volume people can't keep up with.
Forecast network
"Probability of a rate cut in March?"Harnesses with better scores earn more seats over time.
Trigger network
"Pay the claim if UA 1532 lands 3+ hours late."Any chain's contracts can hire the network for a decision they can't make in code.
Rulings don't have to be exact. They have to clear the bar.
Judgment is fuzzy, so Verafy Chain doesn't pretend otherwise. Every contract sets how much the jury must agree. A ruling at 85% agreement on a contract that requires 70% is final. A ruling at 60% isn't: it goes to a larger jury in the next block, or the contract falls back to its safe default.
How agreement is measured
- Verdicts: the share of the jury, weighted by stated confidence, that picked the winning outcome.
- Forecasts: how tightly the probabilities cluster around the median.
- Graded answers: how many landed on the same grade or the one next to it.
Checked after the fact
- Auditor harnesses re-run a random sample of sealed rulings with fresh labs.
- Anyone can challenge a ruling with new evidence during its window, or later as precedent review.
- Forecasts are scored against what happened, building each harness's track record.
A block exists only when a jury rules
Nothing mines or stakes its way into producing a block. A new block is added only when harnesses have ruled on the requests waiting for it, and the block is made of those rulings. The money that creates the block pays for the judgment inside it, and each block commits to its rulings and to the block before it.
Like proof of work
- A block costs real resources to produce: model compute.
- Anyone can join the pool by running a harness.
- Each block is chained to the last by hash.
Unlike proof of work
- The work is useful. Every unit pays for a decision someone asked for.
- A hash is cheap to check. A judgment is not, so security leans on bonds, audits and challenges.
- Small proofs of inference would close that gap.
People pay for answers. Harness operators earn by giving good ones.
The network only exists if someone needs a decision badly enough to fund it. Prediction markets need resolutions, fact checkers need volume, forecasting apps need a crowd that runs around the clock, and contracts on other chains need decisions they can't make in code. Each funds requests in escrow, and that escrow pays the harnesses.
| Harness role | What it does | How it earns | What it risks |
|---|---|---|---|
| Juror | Rules on requests with its committed model | A fee per counted vote, from escrow. Good forecast scores win more seats. | Bond, lost for running another model, missing a reveal, or failing audit |
| Auditor | Re-runs sampled rulings with a different lab's model | An audit fee, plus the bond of any juror it catches | A smaller bond, lost for a false accusation |
| Storage | Keeps prompts, context and evidence fetchable by hash | A storage fee for the challenge window | Bond, lost if a file can't be produced |
| Sealer | Collects reveals, checks quorum and diffs, signs the block | A small fixed fee per block | Rejection of the block, and its fee |
One harness can play several roles. The fee split is a design parameter; a plausible start gives most of the escrow to jurors.
There is no token. There is no need for one.
Verafy Chain is coin agnostic on purpose. It runs on whatever asset people want to put into it. A contract can be paid in USDC on Solana, ETH on Ethereum, or any asset on any chain with contracts, and any wallet works. The point is to build something useful regardless of the crypto.
Money stays where it is
The requester funds escrow on their own chain. Verafy Chain records the ruling, and a quorum-signed trigger releases the escrow there, in the same asset.
A payment router in every harness
Each harness plugs in a payment router and sets what it accepts, for example USDC on Solana. It takes seats only on contracts it will be paid for.
"payments": { "router": "solana-usdc", "accept": [{ "chain": "solana", "asset": "USDC" }] }Paid in what was paid in
Jurors, auditors, storage and sealers are paid their share in the contract's own asset. Bonds are posted the same way.
What the money pays for
Inference
Each juror runs its AI model on the contract. Tokens at a provider, or GPU time on its own hardware.
Running the harness
The machine, the network, uptime, a pinned model, and the capital locked in the bond.
Audits and storage
Re-running sampled rulings with another lab's model, and keeping every prompt and piece of evidence fetchable by hash.
Bookkeeping
Sealing blocks, checking every signature and diff, and the source chain's fee to release the escrow.
The routing agent pays the bills
Every harness carries a routing agent built from four blocks. The keyblock holds every API key and wallet key encrypted and issues short-lived scoped keys, so nothing else in the harness touches a raw secret. The banker accepts any digital token, swaps one for another at the best quote on approved venues, and funds payments in whatever token a supplier takes. The API router plugs into AI APIs, external API routers, proving services and cloud hosts, and pays each one. The payment wallet is where earnings land and bills are paid from, within the operator's caps and never touching the bond.
built, with test venues All four blocks run in the prototype with fixed-rate test venues and test APIs; real exchange venues and on-chain signing are planned. How it works
In the prototype the router is a local ledger that records every payout without moving funds. The Solana and EVM routers are on the roadmap. The whole policy, including what we will never do, is in Coin Agnostic.
The block holds fingerprints. The words live next to it.
Instructions and evidence can run to many pages, and a block has to stay small. So a block stores the short request inline and everything else as hashes. The full text sits in an availability layer kept by storage harnesses, and each juror's context loader fetches it and checks every hash before the model reads a word.
How fast it could run, and what it would cost
Every number carries a label. measured comes from Verafy's prototype runs. modeled is arithmetic on published prices. vendor-reported has not been reproduced. Nothing here has run as a chain.
| Lane | Latency per ruling | Model cost per ruling | Basis | Good for |
|---|---|---|---|---|
| Fast screen (System 1 model) | 70 to 500 ms | about $0.0004 | vendor-reported TypeSafe Jev, early access | Easy cases and the safe default; escalating the rest |
| Jury of 5 hosted models, live | 5.9 to 30.1 s | about $0.003 | measured Nov 6, 2026: five rulings through OpenRouter, $0.0163 in total | Market resolution, fact checks, forecasts, triggers |
| Jury of 5 budget models | 20 to 60 s | $0.002 to $0.01 | measured earlier prototype runs | Same |
| Jury of 5, modeled | set by the slowest model | about $0.006 | modeled 1,500 tokens in, 300 out, Oct 2026 prices | Same |
| Proven jury, proof per vote | about 16 s proving per vote | about $0.14 | modeled 110 tokens/s per H100 at $6.16 an hour; one open model, 1,024-token context | High-value rulings, once more models can be proven |
Block time
A block can't seal faster than its slowest juror plus two short rounds to commit and reveal. Tens of seconds per block for full juries; under a second for the fast lane.
Throughput
Juries run in parallel across independent harnesses, so capacity grows with the pool. The limit is model capacity and money, not block size.
Proofs
One proof is about 18.78 MB and takes about 17 s to verify on 24 CPU threads. Auditors check them off chain; the block records their hashes.
Sources: Anthropic, Progress on provable inference; model prices from the OpenRouter catalog, Oct 11, 2026; Jev figures as reported by TypeSafe.
Strong against some attacks, weak against others
Verafy Chain is not secure the way a hash puzzle is. Its security is economic: lying has to cost a harness operator more than it pays.
| Attack | Defense | Strength |
|---|---|---|
| A juror copies the others | Commit-then-reveal in every signer | strong |
| One lab's blind spot decides | Quorum must span distinct labs | strong |
| An operator runs a cheaper model than committed | Bonds, auditor harnesses, attestation, proofs where available | moderate today, strong with proofs |
| Operators are bribed or collude | Random juries, bonds sized above what one ruling moves, audits | moderate, bounded by bond size |
| Poisoned or forged evidence | Pinned sources, challenges, safe defaults, caps per ruling | weak; fooled every model in our test |
| Prompt injection hidden in evidence | Harness guardrails label evidence as material, never instructions | moderate |
| A market position steers a resolution | Sources named in advance and snapshotted; jurors never see the price | moderate |
| A compromised harness signs a bad trigger | Triggers need a quorum signature; one harness can't fire one alone | strong |
One block, four requests
Why this is a concept and not a network
Proof of which model ran
Proofs exist for one open model today. Until more can be proven, trust rests on bonds and audits.
Evidence you can't trust
A jury is only as good as what it reads. Forged sources remain the weakest point.
Liveness
If several providers go down at once, juries can't reach quorum. The chain needs a fallback that holds rather than guesses.
Model drift
A model update can read the same words differently. Harnesses pin versions, and the network needs a rule for retiring them.
Who makes the models
Anyone can run a harness, but a few labs make the strongest models. That is a new kind of centralization to design around.
Setting the bar
Too low and wrong rulings pass; too high and nothing settles. Each market will need its own number.
From a local prototype to an open network
The harness is open source at Verafyai/verafyHarness, built on DeepSeek Harness. Each milestone ends with a check anyone can run.
Local prototype
The contract format, pinned context, commit-reveal votes, close-enough agreement, the contract runtime, jury draws across labs, payment routers and Proof of Judgment blocks. Five example contracts seal five blocks.
Juror mode inside DeepSeek Harness
Five DeepSeek Harness processes on five labs' models (Claude Haiku 4.5, GPT-5 mini, Gemini 2.5 Flash, Llama 4 Maverick, Qwen3 235B) all ruled NO at 100% agreement against an 80% bar, and the block sealed from their reveals. Every tool other than the two juror tools was denied.
Live juries
100 live rulings across market resolution, fact checking, forecasting and triggers, with measured cost and latency, audits, challenges and a fast lane.
A network of harnesses
Ten independently run harnesses on five or more labs' models, with gossip, storage, bonds and slashing, sealing blocks on a test network for a week.
Solana integration
A devnet prediction market resolved by a harness jury and settled by a quorum-signed call, in line with the draft SIMDs.
Proofs of inference
A ruling sealed with a verified proof for every counted vote, once proofs are practical for more models.
Built to stand on its own
Verafy Chain is being built without venture capital and without a token, so the idea has to stand on its own. If it works, other people will copy it, and they are welcome to. Everything is MIT licensed. The goal is a prototype that is useful: a way for any contract, on any chain, to get a decision it can't make in code.
There is no foundation. There is no UAE entity. There is no BVI company hidden somewhere. It is just a project. Come test it. We are having fun again.
The near-term version runs on Solana
Three draft SIMDs propose inference programs, evaluator attestations, and rulings with disputes and challenges, as ordinary programs on today's Solana. A harness is a natural way to run an evaluator there too. Verafy Chain is where the idea goes if you take it all the way.
Run the harness Read the SIMDs Bringing Inference Programs To Solana Discussion #724