# A record you cannot revise

2026-08-12 · BUILD · https://karlaurel.io/articles/a-record-you-cannot-revise

Every autonomous trading agent I have seen keeps some kind of log. Almost none
of them keep a record.

The difference is not rigour, it is arithmetic. A log is a file the writer can
open again. Whatever it says now, the set of things it might have said an hour
ago is unbounded, so reading it back tells you nothing about the past — only
about the present, which you could have asked for directly. A record is a log
the writer cannot open again. That one missing capability is what makes the
contents worth reading at all.

This matters for one claim in particular, the claim an agent cannot otherwise
support: that it decided something before it knew how the decision turned out.
Nearly everything else about an agent can be checked by running it again. That
cannot. It has to have been captured at the time, by something the agent does
not control.

## Nobody has to be lying

The failure does not require bad faith, which is why warning people about it
does not help. An agent that can rewrite its reasoning will rewrite it for good
reasons. A retry overwrites the first attempt. A summariser tidies a rambling
note into a cleaner one. A bug fix backfills a field that was null for a week.
Each edit is defensible on its own, and none of them was made in order to look
better afterwards. Together they leave a history that has been continuously
reconciled with what happened next, which is the exact thing the record was
supposed to rule out.

So the design question is not how to persuade the agent not to edit. It is how
to remove the verb. No UPDATE, no DELETE, one INSERT per event, and a database
role whose grants stop there.

## Whose clock, and where the gaps are

Two details do most of the remaining work.

The first is the timestamp. If the caller supplies it, it is a claim rather than
a fact, and an agent that picks its own timestamps can date a decision to before
it made it. The record has quietly become a diary. So the server writes the time
it accepted the write, and the caller’s own idea of the time, if it wants to
send one, is stored beside it under a different name. When the two disagree that
is information, and it is only information because they were never the same
field.

The second is the sequence number. Timestamps collide and clocks drift; a
monotonic sequence per agent does neither. Its real value is negative space. If
entries 41 and 43 exist and 42 does not, something was written and is now
unreachable, and no amount of reading the surviving rows would ever have told
you so. A gap is the only way an append-only store can report an absence.

## Corrections, not edits

Being wrong in the record is normal. A system with no way to say so is a system
that invites people to fix things underneath it instead, which is how the
guarantee actually dies in practice — not by design, but by one afternoon of
manual repair.

The answer is that a correction is a new entry naming the one it supersedes. The
original stays readable. Anyone following the chain sees the first judgement, the
revision, and the interval between them, and the interval is often the most
interesting part, because it says how long the mistake stood.

That is also where the cost lands. There is no draft state, and nothing can be
quietly removed. Every half-formed reason an agent gave at three in the morning
is still there in the morning, in the same typeface as the good ones, attached
to whoever ran it. Most people who ask for an audit trail have not priced this
in. It is less a feature you add to a system than a thing you have to be willing
to look at.