Agents are starting to do real work inside companies, and the usual ways of trusting work (watching who is busy, who has access, who signed off) tell you less and less. A business needs a neutral way to say what counts as done, and anyone it deals with needs a way to check that decision for themselves. We call that a verification layer: a record of each job that someone can answer for and anyone can check. The history behind it is in the Journal.
Twelve principles for accountable autonomous work
- Activity is not work.
- A claim is not proof.
- Define done before evaluating done.
- The executor should not be its only witness.
- Outcome evidence and execution evidence are different things.
- Missing evidence is information, not permission to guess.
- Contradiction is a first-class result.
- Say what a check establishes, and what it cannot.
- A second party should be able to reproduce the decision.
- Minimize evidence; never centralize raw data by default.
- The ledger records history; the Work Record carries meaning.
- AI may explain the verdict, never render it.
From supervising workers to verifying work
For most of the industrial era, organizations kept track of work by organizing people: jobs, shifts, approvals, timesheets, access. The worker and the work were tightly coupled, so watching one meant knowing the other. Agents break that coupling. The question changes from “what did the agent do?” to “what work can we establish was actually done?”
Enterprise software is full of signals that look like completion: a success flag, a closed ticket, a green node in a workflow. They help you run operations, but they establish little, because with machine work the system that did the job usually writes the record of how it went. The worker ends up as its own witness.
When doing the work becomes cheap, checking it becomes the expensive part. What’s missing is a statement that someone else can check, showing the action produced the result that was agreed.
An old problem gets a new shape
The principal–agent problem begins with a simple fact: one party delegates work to another and cannot perfectly observe the agent’s effort or incentives. Software agents make the gap wider. They act faster, across more systems, with fewer people watching, and they write convincing accounts of their own success.
Not every agency problem is equally hard. In chess, both players observe the same board; there is little room to disagree about whether a move occurred. Enterprise work can move in that direction, with one caveat: here the board is the system of record, and no cryptography can stop a board from being wrong. Verification does not remove trust. It narrows trust to named sources and makes everything after them checkable.
Verified does not address the agency problem by trusting the agent more. It reduces the information asymmetry by making the outcome state independently checkable.
Define done before execution. Verify after
| Building block | What it is |
|---|---|
| Work Claim | Someone, person or agent, says a piece of contracted work happened: “invoice 4711 matched.” |
| Work Contract | The definition of done in a form software can check: the conditions, the evidence that counts and who can sign it. It is versioned and set before the work starts. |
| Evidence | Signed statements from the systems where business reality lives. Raw data stays home. |
| Verification | A deterministic evaluator tests the claim against the contract: supported, contradicted, or undetermined. Missing evidence stays explicit. |
| Work Record | What was accepted, under which contract and on which evidence. It can be moved, kept and checked again. |
Verified doesn’t run agents and doesn’t replace the ERP. The work happens elsewhere; checking it is what we do.
The record carries everything needed to check it
A trusted database is useful inside one organization. It is not enough when two parties need to agree about work: a second party should be able to check a claim without asking the system that produced the decision to interpret itself. The Work Verification Protocol makes the Work Record self-contained (claim, contract, signed evidence and decision), so a record means the same thing inside Verified, outside Verified, before it is written to a ledger and after it is exported.
And verification never just says “valid.” Package integrity, evidence authenticity, signer authority and decision reproducibility are each checked separately, and no version ever claims that the source system told the truth. Cryptography can show who said something, but not that it was true. A result of contradicted that can be reproduced is still useful; a check should keep doubt visible rather than hide it.
What we don’t do
We don’t do process mining. Reconstructing flows and finding bottlenecks across a company’s data answers questions about processes. Verification decides one claim against one contract, and for that a verifier doesn’t need to rebuild the whole company. Staying small is part of why it can be trusted. The two work well side by side.
We don’t pool your raw data. Evidence can contain sensitive business data, so the protocol prefers minimized observations, explicit field policies, and evidence that stays near its source. Zero-knowledge proofs can establish selected predicates without revealing the underlying data, but they can’t prove the source data was accurate. Formal verification proves properties of a model, not of the whole production system. We use both as tools, not as the product.
Verified work becomes an economic unit
Once a unit of work has a stable definition and reproducible evidence, an enterprise can bill for accepted work, replay an audit, compare humans and agents against the same definition of done, measure genuine autonomy, and resolve a dispute against one record instead of two logs. All of that comes from the same record.
Not every human contribution should be reduced to a machine score. The protocol is most useful where a clear business outcome can honestly be written down. Whether work was valuable can stay up for debate; whether it was done can still be checked.
From AI governance to a protocol for work
The immediate work is enterprise AI operating against the systems of record, and we are starting with the back office. Further out, the same record could become a shared way for companies that don’t share systems to agree on work: what was ordered, what was done, and what gets paid.
Verified is one implementation of this idea. We want the record format to outlive any single vendor, including us. If software agents are to become economic actors, their work needs something like a receipt, a test, an audit trail and a proof, without pretending those are the same thing.
How it works is on the Technology page. To talk to us, use the form below.