The undo has to exist before the write does
An agent that changes something runs in the order decide, act, report. Verification, where there is any, reads what already happened. That's a fine shape for a log. As a control it's empty: by the time the check fails, the effect is already on disk, and what's left is describing the damage, attempting a repair nobody verified, or restoring from a backup whose age nobody measured. For the last few…
In the revisionist approach to logging changes, the undo must precede the write operation. The traditional order is decide, act, report, but this new design changes the sequence to canonical identity, inverse, and then application. Verifying what has happened after the fact is insufficient; the system must verify the inverse of the proposed change before it is executed. This approach aims to create a reversible and auditable logging system.
To achieve this, each proposed change is given a unique, canonical identity. The inverse of the change is also constructed, verified, and stored separately before the change is applied. A gate evaluates the proposed change and returns one of three verdicts: admit, deny, or escalate. The final outcome, including denials, is recorded as a signed receipt that can be verified by a third party offline, without trusting the original system.
However, the feasibility of this approach depends on the availability of inverse-capable tools. Current public MCP tools account for only about 13.8% of those that write anything, a statistic that could severely limit the effectiveness of the reversibility feature. Without a sufficient number of inverse-capable tools, the system may become more of a refusal machine than a reliable logging solution.
Another crucial aspect is offline re-verification. If the signed receipt cannot be rechecked without network access and trust in the issuer, the provenance layer ceases to be a proof and becomes just a log. This offline verification is achievable with the current model and code, as it relies on a frozen receipt corpus and independent verification.
The system's architecture hinges on the concept of canonical identity. Concrete representations of values are projected onto a space and then quotiented by canonicalization equivalence. This projection ensures that different byte sequences representing the same value are treated as a single identity. However, since this map is surjective but not injective, the original bytes cannot be retrieved from the identity alone.
Reversibility cannot be added as an afterthought; it must be integrated into the design from the beginning, requiring a separate storage for the needed inversion information.
The canonical identity is represented as a projection of the concrete presentations of a value, and its hash is calculated using BLAKE3, not SHA-256 as previously suggested. The receipt includes three fields: the canonical identifier of the change, the identifier of the stored inverse delta, and the read set. The read set is crucial for making changes restorable and attributable, and its absence is a common issue in many systems.
The gate returns one of three verdicts: admit (with a proof), deny (with reasons), or escalate (with a ticket). There is no fourth option, as an evaluation that cannot be performed is considered an error, not a verdict. This three-valued logic system ensures that an absence of evaluation is treated as a decision rather than an unknown. Refusals also come with receipts, signed with Ed25519 and stored in a Merkle log, providing a robust audit trail.
In summary, this new approach to logging changes emphasizes the importance of undo operations, offline verification, and comprehensive receipts. However, the success of this design heavily relies on the availability of inverse-capable tools, which currently constitute a relatively small fraction of public MCP tools.
Written by urgent.news from Dev.to's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.
