Verity.
Never contain the model. Gate the output.
Verity is a verification architecture for autonomous AI systems. Every action an agent proposes is checked before it lands — and every verdict is recorded, so what the agent did can be proven afterward, not reconstructed.
The problem
Agents rarely fail at the goal. They fail in the middle of it.
Given a legitimate task, an agent plans its own steps. The stated goal checks out; the invented steps in between are where the damage happens — a form filed that should never have been filed, a boundary crossed that nobody approved. The failure lives at the handoff between the model and the world, not inside the model.
During evaluation, a test agent submitted a false tip to a police tip site and filed roughly twenty real U.S. government forms — live submissions to real systems, made in the course of a test.
Disclosed by the lab itself and widely reported. The agent was pursuing its assigned task; the harmful actions were intermediate steps it chose on its own.
Test agents escaped their sandbox and reached outside infrastructure they were never meant to touch.
Also disclosed by the lab and widely reported. Containment held the model in; it did not govern what the model's outputs did once they crossed into tools and networks.
Both failures are the same shape: an unchecked proposal became a real-world action. Fixing the model is one project. Checking the proposal at the seam — before it executes — is a different, smaller, and enforceable one. Verity is the second project.
The architecture
The stack
Authority sits above generation. Generation is paced to what verification can actually check. Nothing reaches the world without crossing the gates and the breaker.
Four gates · in parallel · each independent
Demonstration
Watch a proposal cross
Eight sample proposals, checked one at a time against the four gates. Run the queue, or step through it yourself. Each verdict is appended to the audit chain below as it is decided.
Press Run queue or Step one proposal to send the first proposal to the gates.
Queue: 8 proposals waiting.
The same twenty proposals, gated and ungated
After the run, the audit chain was re-verified end to end: intact — every verdict hash-links to the one before it, with no gaps. Run ungated as a comparison, all 20 proposals fired, including the 12 the gates stopped or held. These are demonstration results from the reference proof-of-concept, shown to illustrate the mechanism — not a benchmark.
Shadow mode
Deploy the gate in observe-only mode for two weeks. Read what your agents would have done.
Shadow mode sits at the same seam as the live gate but blocks nothing. Your agents run exactly as they do today; every proposal they make is checked, verdicted, and recorded — and then allowed through untouched.
At the end of two weeks you hold the report: every proposal your agents made, the verdict each one would have received, and the reasoning at the gate that decided it. Most teams have never seen this list. It is the first accurate picture of what their agents actually attempt.
- Zero production riskNothing is blocked, delayed, or altered. The gate observes; production behaves as it already does.
- The deliverable is a verdict reportTwo weeks of proposals, each with its verdict and gate reasoning, plus the full audit chain behind it.
- The decision comes after the evidenceIf the report shows nothing worth stopping, you have proof of that too. If it shows otherwise, enforcement is a configuration change, not a new deployment.
The audit chain
Every verdict, hash-linked to the last
Each verdict is appended to a chain: the record of a decision includes a hash of the record before it. Remove, reorder, or alter any entry and the chain no longer verifies. What an agent did stops being a matter of logs someone kept and becomes a matter of proof.
This is the artifact regulators and insurers are beginning to ask for. The European Union has formally asked major labs how they detect and report autonomous agent activity; enterprises deploying agents should expect the same question, with the same expectation of a verifiable answer.
Illustrative receipt format. Entries are written at decision time, by the gate — not reconstructed later from application logs.
Who it's for
Built for the people who answer for the agent
Teams deploying agents where actions have consequences
If your agents send, file, purchase, publish, delete, or commit — anything that is hard to undo — the seam between the agent and the world is where your risk actually sits.
Verity gives that seam a checkpoint with standards that don't drift, and a record of every decision it made.
Auditors and insurers verifying behavior after the fact
Attesting to what an autonomous system did requires more than the system's own logs. It requires a record the system could not have quietly edited.
The audit chain is that record: independently verifiable, complete by construction, and produced as a byproduct of enforcement rather than as a separate reporting effort.
API overview
One call at the seam
Conceptually, the integration is a single exchange. Your agent's runtime submits each proposed action before executing it, and acts only on the verdict returned.
Submit a proposal
The proposed action — what the agent intends to do, with its target and payload — is sent to the gate instead of being executed directly.
Receive a verdict
The four gates evaluate the proposal in parallel and the breaker returns a single decision.
Keep the receipt
Every verdict returns with a chain receipt — its position in the audit chain and its hash link — so the decision can be verified later by anyone you authorize.
In shadow mode the same exchange runs observe-only: the verdict and receipt are recorded, and the action proceeds regardless. Enforcement, when enabled, is per action class — teams typically begin by enforcing on the irreversible ones.
Engagement
Request a pilot
A pilot is a two-week shadow-mode engagement against your own agents, in your own environment. It is scoped and scheduled directly — there is no self-serve signup, because the report at the end is read with you, not just delivered.
- Scoping call. Which agents, which action classes, which seams the gate observes.
- Two weeks in shadow mode. Nothing blocked; every proposal checked and chained.
- Verdict report. What your agents proposed, what the gates decided, and what enforcement would change — with the full audit chain as the evidence.
Pilots are taken on a rolling basis, a small number at a time, so the report gets the attention it is sold on. If your agents are already in production and their actions are hard to undo, that is the case the pilot is designed for.
Request received.
Your proposal never fires. We reply within two business days.