Product

Every control, stated once

Every way an agent goes wrong in a regulated institution, and the control that closes it, stated once. Everything here runs today.

The whole surface

20 ways this goes wrong, and what closes each one

Organised by the failure and not by the feature, because you arrive with a fear rather than a shopping list. Everything listed here runs today.

before the call runs

The amount is outside what this agent may approve: Three outcomes: the call is capped to the limit and an approval routed, so the work carries on
Every call is inside the limit; the position they add up to is not: Running state keyed to the entity, so trailing totals and velocity bands are expressible
A tool is used for a customer or a purpose it was never meant for: Least privilege per agent, scoped to the tools and argument ranges that agent needs
The model is talked into an action by the customer or by injected text: The boundary decides on the arguments, so what the model was persuaded of does not matter

in flight

A disclosure was in the prompt, and nothing proves it reached the customer: Consent, disclosure and approval run as obligations and are receipted before the action commits
A human approved one thing and the agent executed another: What was approved is what executes: the approved parameters are pinned and replayed verbatim
A high-risk action ran without re-verifying who was on the line: Identity and secure input, so a card number or a national ID goes to a channel the model never reads
A cooling-off or cancellation window was not respected: Temporal actions: the clock is a policy condition, not a reminder in someone's runbook

on the figures

A rate, a balance or a payment is stated fluently and bound to nothing: Bound facts and quote tokens: a figure the model did not author and cannot alter
A figure is arithmetically right and derived from a stale source: Fact-graph lineage, so a reviewer reads where a number came from instead of recomputing it
Customer data reaches the model because it was in the context: PII tokenization: sensitive fields become opaque tokens and resolve server-side at execution
One customer's information surfaces in another's conversation: Governed memory, isolation-refused across cases, with erasure that returns a receipt

after the fact

Logs record that the action ran, not that the policy ran: Signed, hash-chained decisions pinned to the policy version that made them
A threshold changes and nobody can say what it would have done: Replay and backtest a proposed bundle against real historical traffic before it ships
Enforcement goes live and customers are the ones who find out: Shadow mode decides and records on live traffic while changing nothing
A threshold changed and nobody can say who changed it, or which decisions ran under the old one: Policy changes are chained too, so a decision's bundle digest joins back to the change that produced it

around all of it

The rule exists in a policy document and nowhere a machine can read: Upload the document: clauses are extracted, drafted against your registered tools, compiled and fuzzed, and approved one at a time
You believe the controls hold and cannot demonstrate it on demand: Adversarial probes generated from your own policies, including forged identity, consent and approvals, with a pass-fail report
Agents are running somewhere in the estate and nobody can say which of them are governed: An estate report inventories what is running, which endpoints are governed and which are not, and which models are in use
A reviewer asks which rules apply to this tool and the answer means reading Rego: Every tool lists the policies that govern it, and any policy explains itself in the reviewer's language

Where does it attach?

One call, at the seam you already have

Verdict wraps the place your agent executes tools. Agent-agnostic and model-agnostic: it reads the action itself, whatever framework proposed it.

Where does it run?

A single Go binary inside your boundary

A single Go binary in your VPC. What it stores, what it touches, and that nothing leaves your environment to reach a decision.

Bring one workflow and the owners who sign off on it. We map controls, obligations and evidence against how you actually operate.