Back to Blog
Designed to Be Audited
A system can have logs and dashboards and still fail the reconstruction test. Auditability has to be designed into the decision path itself.
Logs, observability, and auditability get used as synonyms, and they describe three different properties. Logs record that events occurred. Observability lets operators interrogate a running system about how it is behaving now. Auditability is the stricter one: a person who was absent when a decision was made, working from the record alone, can reconstruct that decision and judge whether it was made properly.
Most automated systems have the first two, and their owners assume the third comes along for free. It rarely does. The fastest way to check for it is to hand the record to an outsider and watch what happens.
The reconstruction drill
There’s a drill worth running that engineers find mildly uncomfortable. Pick a routine, deliberately boring decision from an automated system and hand the record to someone who had nothing to do with building the component behind it. Their job is to reconstruct the decision from the trail alone: what did the system see, what did it weigh, why did it act, and why did it leave the alternatives alone? They can’t ask the engineer or read the code. They have the record.
Run it and watch the trail fall apart. The reviewer can establish that the system evaluated a routine request and stood down, because one log line says so. Everything past that line becomes archaeology. Which checks ran? What data did they use at that moment? Was the stand-down a rule firing, a missing input, or a configured boundary? The information may exist, scattered across services in formats built for machines. Reconstructing one small decision consumes hours, and the writeup comes back full of qualifiers.
That system has logs and dashboards and still fails the test.
Three words, three different promises
-
Logs
Raw material: an append-only pile of facts, this happened and then this happened. They answer “what events occurred” and make no promise that the events, read together, explain anything.
-
Observability
Lets you ask questions of a running system through dashboards and traces. It is built for operators and points at the present: whether the system is healthy, where it is struggling. It answers “how is the system behaving.”
-
Auditability
A promise to someone outside the system, possibly outside the company, possibly years from now: any consequential decision this system made can be reconstructed and judged by a person who wasn’t there. It answers “was this specific decision made properly,” and it has to answer without the original engineers in the room.
Audit questions are decision-shaped: what did the system know at the moment it decided, which rules applied and in what sequence, what would have changed the outcome? Logs and dashboards were never built for those questions, so mostly they can’t answer them.
What reconstruction demands
Take the drill seriously as a test and it starts dictating architecture.
Decisions need identity. A decision has to exist as a nameable event before it can leave a trail. Something has to own it, and the record has to say who. Everything else in the trail hangs on that. A decision smeared across several services as a side effect belongs to no one and explains nothing.
Inputs get frozen at decision time. Reconstruct a decision next quarter by querying the systems that fed it and you get the world as it exists next quarter. Data gets corrected and overwritten in the meantime. The trail has to capture what the system saw, exactly when it saw it.
The negative space gets recorded. The biggest gap in weak reconstruction drills is silence about roads never taken. “System acted” appears everywhere; “System considered this and declined, for this stated reason” appears almost nowhere. Abstention is a decision, and a check that passed is evidence. When the trail only speaks when something happens, much of every reconstruction is guesswork.
Lineage gets stamped. Which version of which logic, under which configuration, made this call? Automated systems evolve constantly, and a trail that can’t say which incarnation of the system decided can’t tell anyone who or what answers for the outcome.
Why you can’t bolt this on
Every one of those requirements reaches into the design itself. Freezing inputs at decision time means the decision path writes its own record, synchronously, as part of doing the work; a reporting pipeline added later reconstructs from the outside and inherits every gap. Recording the negative space means the paths for declining get instrumented as thoroughly as the paths for acting, which forces declining to become an explicit path in the first place.
This is why HAL, the AlphaFlux memory and context layer, takes an event-sourced posture. HAL: Memory, Context, and Narrative Compression for Real-Time AI describes it as preserving the sequence of what happened and deriving current state from it, so the system can reconstruct what context existed at a prior moment and whether a decision rested on information available at the time. That is auditability designed in rather than reported on afterward: when someone asks what happened, the answer is already written down.
The test worth running
“Hours and guesses: the system is logged. Minutes and citations: it’s auditable.”
The test result
You need zero technical background to apply this. Ask whoever operates an automated system on your behalf to pick one routine decision the system made recently and have someone who didn’t build it explain that decision to you from the record alone. Then count two things: how long it took, and how many times they guessed. Hours and guesses: the system is logged. Minutes and citations: it’s auditable.
The reason to demand this is scale. A person making a questionable call gets noticed by the people around them. An automated system can repeat the same flawed decision again and again, politely and consistently, and the trail is how the institution notices. The trail also outlives the team: engineers move on and vendors change, and the record is the memory that stays.
What a passing trail looks like
A mature trail can be walked in minutes, start to finish, like a narrative. A sample record, invented for illustration:
A routine request was evaluated. Inputs were captured as the system saw them at decision time. Checks ran in a recorded sequence, and all but one passed. The remaining check required information that was absent. Outcome: declined, with the reason stated. Logic version and configuration are stamped on the record.
Sample record
The stated reason in a record like that is blunt: required information was missing, so the system stopped. No default quietly substituted, no workaround smoothing the gap. Getting to that bluntness is often contentious, because it means finding every place a system silently papers over uncertainty and removing it.
Treat reconstruction as part of the specification. If a stranger can’t walk a consequential decision from the record alone, the work is unfinished, however healthy the dashboards look.
Disclosure note
The reconstruction drill and the sample record above are illustrative and describe no real AlphaFlux decision, event, or record. HAL’s event-sourced posture is discussed in the terms of the live HAL article only; nothing here describes storage mechanics, retention, replay details, or the content of any real trail, and nothing here is a claim about outcomes or performance.
Public-safety boundary

Joshua Goldfein
other articles
Why Markets Break Naive Machine Learning
Joshua Goldfein
Oct 7, 2026
The System That Argues With Itself
Joshua Goldfein
Oct 6, 2026
Listening to Yesterday
Joshua Goldfein
Oct 6, 2026
