Evidence is only worth what it costs to fake. So instead of calling Decision Horizon "tamper-proof", here is what an attacker would actually need for each kind of lie, and what the record says about itself when it can't rule one out.
The short version: a record is tamper-evident and verifiable offline. An alteration is detected, not made impossible. Each mechanism below narrows what an attacker can do, and each states what it leaves open, in the record itself.
To rewrite history
What it takes: the signing key, and k of n witness keys.
Every record carries the hash of the previous one inside its signed body, so you can't remove, reorder or edit a record without breaking the chain. With the signing key, though, someone could rebuild the whole chain from scratch. Witnesses close that gap. They're separate processes that countersign the chain's head as it grows. Once they have, rewriting earlier records needs their keys too. With before_execute, an action doesn't run until the witnesses have countersigned its intent, so a rewrite has to happen in real time, before the next countersignature.
What's stated: with no witness configured, the signing key alone could rewrite a chain, and every record says so in its coverage block.
To write a false record
What it takes: the signing key, in real time.
Witnesses countersign the chain, never its content. They'll countersign a lie as readily as the truth. What they stop is fabrication after the fact. The key itself can sit in a separate signer process, encrypted at rest, so the agent never holds it.
What's stated: how the key was held, plaintext included, is written into every record.
To fake an execution
What it takes: the agent runner's key.
At the model-API gateway, Decision Horizon sees the tool call the model asked for, not the execution itself. So an outcome there is what the agent reports, unless the agent's runner signs a receipt for it under a key you pinned. Then the record says executed.
What's stated: the runner is trusted for execution facts. A runner can sign for a call it didn't perform.
To hide an action
What it takes: a path around the insertion point.
A call that never passes the interceptor leaves no record. No product can record what it never sees. So every record names its insertion point and lists what that point can't see. The absence of a record is evidence about that insertion point only.
What's stated: the list of blind spots is what the product knows about itself. A blind spot nobody has named isn't in it.
To blur what the agent used
What it takes: nothing works, for use by value.
Whether content the agent read reached the action is decided from the bytes, or the record says it can't tell. A credential read in one session and written out in a later one is flagged too.
What's stated: whether the agent read something and reasoned about it without copying is an estimate, and it's labelled as one.
To make a hosted copy lie
What it takes: nothing the verifier would accept.
The hosted record store is trusted to keep your records available, not to vouch for them. It holds only your public keys. Every chain it stores can be downloaded and re-verified offline under the keys you pinned, and the verify response says plainly when the expected head came from the server rather than from you.
What's stated: the operator can withhold, delete or roll back what it stores. Keep your own copy of the head if that matters to you.
One more: the approver
An approval endpoint can say a person approved. The record writes "the approval endpoint reported", never "a human decided". If the approver can't be reached, the record says no human was consulted.
What isn't proven yet
The mechanism has been through ten structured adversarial review rounds and 124 findings, each closed by a fix or published as a limit. That's not an accredited audit. There's no SOC 2 and no third-party penetration test yet. We'd rather say so here than have you find out later.
The full trust model is on the security page, and the stated limits are in the docs.