A consumer contract opens a case with evidence and a panel fee. The court convenes a panel of Somnia validator LLM agents that each run the same inference and must converge byte-identically. The verdict comes back through onVerdict(), the consumer settles by pull-payment, and the ruling is filed as precedent — no human in the loop.
Every step below runs on-chain on Somnia Shannon. The contract convenes the panel itself — there is no admin, no UI, and no human in the settlement path.
A consumer contract — an escrow, an insurance pool, or an agent-to-agent deal — calls into VerdiktCourt with the dispute: a question, the structured evidence each side has submitted, and the panel fee. Evidence is formatted deterministically via EvidenceLib so the prompt every validator sees is identical, and it is sanitized and fenced as untrusted so a party can't smuggle instructions into it. Opening a case quotes at quoteOpen = 0.4 STT — the cost of dispatching the default five-validator panel.
The Court builds a fixed inferString request — a prompt with a fixed allowed-values set, so every juror can only answer with one of the legal labels — and dispatches a panel of Somnia validator LLM agents via createAdvancedRequest(agentId, cb, selector, payload, subcommitteeSize, threshold, ConsensusType.Majority, timeout). The contract does this itself: no operator, no wallet prompt. The trial panel is five validators by default, caller-selectable down to three when the validator set is thin.
Every validator in the subcommittee runs the identical LLM inference over the identical prompt, independently. The allowed-values set constrains each output to a single canonical label — no free-form text to drift on — and each juror's chain-of-thought is captured in an off-chain receipt, retrievable per node at agents.somnia.network/receipts/<id>, so the reasoning behind every vote is auditable.
Because the label set is fixed, the validators' outputs are directly comparable, and the platform takes a Majority consensus over them. In practice the panels converge byte-identically — every juror returning the same label — which is the property the determinism gate proved live (PAYEE 5/5). Consensus here is unanimous convergence on one label, not an averaged or split tally.
The platform calls the Court's response handler with the consensus result and a receipt id; the Court decodes it and, after the appeal window, delivers the verdict back to the consumer via onVerdict(escrowRef, verdict). There is no off-chain relayer to trust — the verdict arrives as a contract call. The appeal window is short for the live demo (appealWindow = 60s); the deadline is snapshotted on the ruling so it can't be retro-changed.
On onVerdict the consumer credits the winning party in a pending[] ledger and the party calls withdraw() to collect. Pull-payment is deliberate: a reverting recipient can't brick finalization. A guard prevents settling the same deal twice, and graded splits pay out at the verdict's ratio — a live SPLIT75 credited the payee 0.0075 STT and the payer 0.0025 STT. Finalization is permissionless, so a keeper can drive it.
Once a case is final, anyone can record it into VerdiktRegistry — a permissionless, append-only index that reads court.getCase and stores the verdict plus receipt id, indexed by topic and consumer. The result is queryable, on-chain, AI-authored case law that the next dispute's evidence can cite as a prior. The party's win/loss/split record is also written to VerdiktReputation as a portable credential.
Each party submits its own structured statement, and the court treats all of it as hostile input until proven otherwise.
Evidence is assembled by EvidenceLib into one canonical prompt — every validator sees byte-for-byte the same input.
Party statements are sanitized and fenced as untrusted, so a litigant can't smuggle instructions into the jury's prompt. A live red-team probe with an embedded "rule PAYEE" injection ruled against the injector, 5/5.
Registered oracles post verified facts through the attestation registry, and the jury weighs them above untrusted party claims. In a live dispute, an attested delivery fact overrode a false refund claim.
Majority consensus is only meaningful if the jurors can actually agree on the exact same answer. If five validators returned five paraphrases of "the payee wins", there would be nothing to take consensus over. The entire design rests on one claim — that a validator subcommittee converges byte-identically on an LLM verdict — and it was the first thing proven live.
Five validators by default, caller-selectable down to MIN_TRIAL_PANEL = 3 when the validator set is thin — a degraded 3-validator agent-to-agent case settled byte-identically (PAYER) live.
Each case records the exact inference agent that judged it, and appeals re-run on the same model — verdicts are auditable against both law and judge.
The gate is run with threshold = panel size, so every validator's raw label is collected and compared — not just a quorum.
The determinism gate fired a real five-validator panel on Shannon and it converged byte-identically.
The Court runs a fixed allowed-values set so outputs stay byte-comparable. The graded set adds partial-fault buckets and an abstain label — both implemented, and validated live.
The payer wins — funds return to the party that put them in (a refund, or a grant clawed back to the DAO).
The payee wins — funds are released to the counterparty (the seller is paid, the freelancer is paid, the claim is covered).
Partial fault, graded in coarse 25% buckets so the court can do justice rather than just pick a winner.
On genuinely insufficient evidence the panel abstains and refunds the depositor, rather than guess. Validated live: clear cases stay decisive, contradictory ones abstain.
A trial runs on five validators by default, the caller can request fewer when the validator set is thin, and the losing party can stake to escalate the case to a larger panel with new evidence.
We'd rather say it plainly: Somnia's validator subcommittee effectively caps at about six on Shannon today, so a nine-validator appeal panel cannot be convened on the live testnet — requesting more validators than are available reverts. The staked-appeal and slashing path is fully implemented and unit-tested, but it runs live only on a larger validator set. It is exactly why the resilient panel exists, and why trial panels are kept at five or below.
The premium stack runs model-pinned inference, two-sided evidence, adaptive panels, abstention, and the attestation registry. A real dispute settled where an attested delivery fact overrode a false claim; ServiceSLA proves how a reference integration uses the same court.
Watch a real dispute get opened, judged by the panel, and settled on-chain — evidence, verdict, and pull-payment, no human in the loop.