Figure 1

Enterprise software likes to tell its history as a sequence of “systems of.” Systems of Record came first: the databases of truth, where ERP, CRM and the general ledger keep one authoritative copy of the state of the business. Then Systems of Engagement, where the people are. The automation wave gave us Systems of Action, software that doesn’t hold state but changes it: workflows, RPA, and now agents, which are systems of action with judgment. The current wave is building Systems of Context: vector stores, knowledge graphs, retrieval layers, the infrastructure that tells an agent what the world looks like before it acts.
Taxonomies like this are marketing. They are useful anyway, because each category names a question the stack can answer. Laid out that way, the agent-era stack is missing a layer — the one we propose to call a System of Proof. The name is ours, not an industry category.
| Layer | The question it answers | Horizon |
|---|---|---|
| System of Record | What is the state of the business? | Years to decades |
| System of Context | What should inform the next action? | Weeks — context decays |
| System of Action | What changes the state? | Months — agents churn |
| System of Proof | Did the claimed change really happen — and did it count? | Decades — proof must outlive everything above it |
The hole in the stack
When an agent completes a task, the system of context supplied what the agent knew, the system of action did the work, and the system of record now shows a new state: an order released, an invoice posted. Ask the stack whether the work was done correctly and no layer was designed to answer independently: each one is a participant reporting on itself. The agent’s trace says what the agent chose to log. The record shows the new state but not the validity of the transition: the ERP knows the order exists, not whether it should. The context layer knows what the agent was told, not what was true.
Any engineer who has thought about trust boundaries will recognize the anti-pattern: every witness in this architecture is also a participant. We would never accept this in security: the process being audited doesn’t get to write its own audit log. Internal controls and external audit exist precisely to counter it — but they sample, and they work from the same actor’s records. This is largely how enterprises account for machine work today: execution, measurement, and attestation living inside the same actor’s stack.
A System of Record tells you the state. A System of Proof tells you whether the transition into that state was valid, and can show its work to anyone, years later.
What a System of Proof is
As an architecture, it has a short spec. It sits outside every actor’s stack — neutral by construction, because attestation by a participant isn’t attestation. It consumes claims about state transitions, not activity streams. It evaluates each claim against a contract that defined “done” before the work began, using evidence tested against the system of record. It writes an append-only, hash-chained history: records are added, never edited. And its verification is replayable: the check is mechanical, so re-running it in ten years yields the same verdict from the same record, even though the agent that did the work no longer exists. Evidence is signed where it lives; what travels is a self-contained record whose verdict anyone holding it can re-derive.
Why it anchors the Long-Horizon Stack
Order the agent-era stack by how long each layer’s output must remain valid, and you get what we call the Long-Horizon Stack. Context decays in weeks. Agents are replaced in months; the model behind today’s system of action will be deprecated before the fiscal year closes. Records last longer, though even ERPs get migrated. But proof has the longest horizon of all: audits, disputes, warranties and regulators reach back years into decades, and the proof must still check out when every other layer that produced it has been rewritten, retrained or retired.
That is why the proof layer belongs at the bottom of the stack, and why it compounds while everything above it churns. Swap the agent vendor, and the ledger keeps its history; migrate the ERP, and the records stay checkable. The proof layer does not even care whether the worker is software or steel. The short-horizon layers compete on capability. The long-horizon layer wins on permanence — a permanence that is maintained, not conferred: keys rotate, algorithms age, and a record kept for decades is kept checkable by re-anchoring it, the way archives are kept readable.
Verified is a System of Proof: Work Contracts that define done, evidence tested against the ERP, verification you can replay — and an append-only ledger of records, the part we are building now. The stack above it will be rebuilt many times in the next decade. The layer underneath is the one we intend to make permanent. How we are building it, component by component, is on the Technology page.



