Most "audit trails" are just log files
When a vendor tells you their AI automation has an "audit trail," they usually mean it writes a log file — a list of what happened and when, stored in a database table. That's useful for debugging. It is not an audit trail in the sense an auditor means, because of one fatal flaw: anyone with access to that database can open it and change a row. Edit a number, delete a line, move a timestamp — and there's no sign anything happened. A log you can silently rewrite proves nothing about the past. It only proves what the database says right now.
A real audit trail solves exactly that problem. It is built so that if anyone changes even a single character of the record after the fact, the change is detectable. That property has a name: tamper-evident — meaning you can't alter the record without leaving an obvious, mathematical trace. Note the word: tamper-evident, not tamper-proof. You can't stop someone with full access from trying to change a record; what you can do is make any change impossible to hide.
How a real audit trail is built — without the jargon
Two ideas do the heavy lifting. I'll define each the first time it shows up.
A hash chain is the first. A "hash" is a short fingerprint that a computer calculates from a chunk of data — change the data by one character and the fingerprint changes completely. A hash chain means each new record includes the fingerprint of the record before it, like links welded together. Record 2 carries Record 1's fingerprint; Record 3 carries Record 2's; and so on. If someone edits Record 1, its fingerprint changes — which means Record 2's stored copy of that fingerprint no longer matches, and so does every record after it. One quiet edit near the start breaks the whole chain downstream. That's the "break-a-byte" idea: change a single byte and verification fails.
A signed log is the second. "Signing" here means stamping each record with a cryptographic signature — a mathematical seal that only the system holding a secret key can produce, but anyone holding the matching public key can check. If the record is altered, the seal no longer verifies. Combine the two — a hash chain so records can't be reordered or quietly edited, and signatures so the records can't be forged — and you have a record that survives scrutiny.
The break-a-byte test: Take a real audit trail, change one character anywhere in it, and run the verifier. It fails — loudly. Do the same to an ordinary log file and nothing happens at all. That difference is the entire point.
Real audit trail vs. ordinary log file
Here's the side-by-side. When a vendor says "we log everything," these are the rows that tell you whether the log would actually hold up.
| Question an auditor asks | Real audit trail | Ordinary log file |
|---|---|---|
| Who can edit it? | No one can change a past record without the chain and signatures breaking | Anyone with database access can edit or delete a row |
| Can you detect tampering? | Yes — a single changed byte fails verification | No — edits leave no trace |
| Does it hold up to "who approved this?" | Yes — the approver and timestamp are sealed into the record | Only if no one altered the row in the meantime — which you can't prove |
| Can records be reordered or backdated? | No — the chain locks each record to the one before it | Yes — timestamps are just editable fields |
| Does it survive an auditor? | Yes — verification is reproducible and independent | It survives only as long as no one questions it |
Why does a tamper-evident audit trail matter for AI specifically?
When a human approves a payment, you can ask them what they were thinking. When AI is in the loop, the record is the only witness. If your AI coded an invoice, flagged a fraud risk, and a person approved the exception, the audit trail is the entire story of that decision. If that story lives in a log file anyone can edit, you don't have a defense — you have a document that's only as trustworthy as your most disgruntled employee with database access. A tamper-evident trail turns "trust us" into "verify it yourself."
A log file tells you what the database says today. A real audit trail tells you what actually happened — and lets anyone prove no one rewrote it since. In finance, only the second one is worth anything.