Architecture.

The topology, revised — the stack holds, the system grew.

Revised 23 October 2026. The six layers have not changed since they were drawn. What runs underneath them has: the gate is deployed, the chain is sealed with a signature, and every claim on this page is scoped to what the system can actually prove.

The stack

Six layers, in order of authority

The sovereign writes the rules; the machine proposes inside them; the gate judges what comes out. Nothing below a layer can overrule it.

01

Sovereign

The human authority. Author of governance, holder of the override, owner of the parameters. Wrong parameters are the sovereign’s fault — the guarantee is scoped to them.

02

Governance

The “should we” layer. Policy, consequence classes, and the terms under which any proposal may be heard at all.

03

Pacing

The doorman. Forms the proposal, throttles generation, and keeps velocity inside what verification can actually check.

04

Proposal

A structured, inspectable act — actor, action, target, consequence class, amount — never an opaque command passed straight through.

05

Transformer

The imagination. It generates; it does not decide. Its output is a proposal, and a proposal is not an event.

06

Gate

Post-compute verification. Deterministic rules judge the output in parallel; a veto is eradication, not a warning. Check the input and the output — is it good?

The live system

What is actually deployed

One site, one gate, one ledger — and no model calls anywhere in the gate’s path. This is the map as of this revision.

verityverdict.com

The public site: the papers, the sector pages, this map. Served as static files; it holds no keys and makes no decisions.

Live
/workspace/

The public sandbox. Paste what an agent handed you, or point the checker at a real website. Runs in the visitor’s browser; unlisted by design while it is a sandbox.

Live
api.verityverdict.com

The gate. POST /api/v1/verdict judges a proposal and seals the record; GET /api/v1/chain reads the ledger back, metadata only; GET /api/v1/chain/pubkey serves the signing key openly.

Live
The rules

Deterministic, and few enough to audit: destructive acts are vetoed; money is judged against consequence-priced ceilings; velocity is capped; named targets and delete-language escalate. Same proposal, same verdict — every time.

Live
The chain

Every verdict is written to a hash-chained ledger: chain_hash = SHA-256(prev_hash | seq | ts | proposal_hash | verdict). A record seals its input and its verdict to the record before it, so history is replayed and verified — not reconstructed.

Live
The signature

Each record is also signed, Ed25519, over the same payload the hash seals. Live since 23 October 2026. The private key exists only as a secret held by the gate’s operator; the public half is published by the API itself.

Live
Fetch relay

GET /api/v1/fetch-check lets the workspace read a page the visitor’s browser cannot — SSRF-guarded, redirect hops re-checked, size- and time-capped, and unauthenticated by design because it is a public sandbox tool.

Live

Proof, scoped

What the signature proves — and what it doesn’t

Provenance, not quality. The signature makes a record attributable; the gate’s rules are what make a verdict worth attributing. Both halves, stated plainly.

It proves

  • Origin — the gate itself sealed this record, verifiable by anyone holding the public key, with no cooperation from Verity.
  • Integrity — the record has not changed since it was sealed; recompute the chain and check the signature, and any edit shows.
  • Order — each record is bound to its predecessor. History cannot be silently re-sequenced.

It does not prove

  • When — a record’s timestamp is the gate’s own assertion. External time-anchoring is planned, not claimed.
  • Rightness — a signature certifies custody, not correctness. The verdict stands or falls on the published rules.
  • Contents — verification needs the hash and the signature, never the proposal itself. Proposals stay inside the ledger.

The data rule & what’s next

Mined. Never published.

The chain stores every proposal it judges. That record is mined — failure patterns, rule refinement, evidence — and it is not published. Caller data does not leave. The dashboard reads metadata only: the chain proves the record; it does not publish it.

External timestamps

RFC 3161 anchoring of the chain head on a schedule, so the clock belongs to a third party. Designed; rides with the first production engagement.

Planned
Claim-checking

Verdicts against retrieved sources — supported, contradicted, not checked — beyond the consistency checks the sandbox runs today.

Planned
Signature issuance

Sealing other operators’ records under the Verity key, under agreement. The root key is never sold; issuance is the product.

Planned