How to engineer accountability into AI agents, and why decision traces are the missing infrastructure.
This last week, a helicopter bolt worth $8,000 went viral on Reddit.
The internet wasn’t fooled by the price tag. As one user pointed out, the manufacturing cost is likely pennies.
The bolt costs $8,000 because of everything wrapped around it: the certification, the inspection chain, the auditable paper trail from foundry to airframe. Someone signed their name on every step. If the bolt fails and people get hurt, there’s a clear, traceable line of accountability back to a specific human who approved a specific decision to a specific standard.
In other words, the bolt costs $8,000 because the chain of custody for blame is priced in.
I’ve been thinking about this a lot, because with the rise of AI, I am quickly becoming an $8,000 bolt myself. And so are you.
Let me explain.
Why AI Can’t Carry Accountability (Yet)
The usual framing goes something like this: “AI can’t be held accountable, so it can’t replace people who carry responsibility.”
That’s directionally right, but most people stop there without breaking apart why.
Accountability requires the capacity to bear consequences. In other words, AI has no skin in the game. It can’t get fired. It can’t get embarrassed in a meeting. It can’t lose political capital or take a reputational hit. None of these repercussion register in a way that changes what it does.
A lot of roles survive automation not because they’re complex, but because someone real has to be on the hook when things go sideways.
This dynamic gets stronger in bigger companies, where there are more layers and the accountability chain has more middlemen. Execution jobs sit closer to the ‘get shit done’ layer. The accountability pressure from above is several steps removed. If a development task doesn’t get done, the person who really has to answer for it usually isn’t the developer — it’s the PM, the EM, the middle manager.
So: accountability matters, AI can’t carry it, and a huge number of enterprise roles exist precisely to carry it. Does that mean humans are safe?
Not exactly. Because accountability has components that can be mapped: documentation, approval chains, traceability, and consequences. We know this because we already engineer it into physical systems every day. (To wit: $8,000 bolt.)
The bolt doesn’t exercise judgment. It just has a paper trail proving it was made to spec. So it follows, can we build the same kind of accountability infrastructure for AI-assisted decisions that we build for helicopter bolts?
The answer is yes. And the companies that figure this out first are going to own the next decade of enterprise software.
Decision traces: how to build better bolts (and bots)
A decision trace captures who approved what, when, under which policy, based on which precedent, using what context, and with what outcome.
Most enterprises have none of this today. Their systems of record store current state, i.e. what the opportunity looks like right now, not what it looked like when the decision was made. The context that justified a human’s judgment was never treated as data.
This is why AI agents keep hitting walls in real enterprise workflows. Agents run into the same ambiguity humans resolve every day with judgment and memory, but the inputs to those judgments aren’t stored anywhere durable.
Human-in-the-Loop Is the Feature
I’ve seen people frame human-in-the-loop as a temporary concession or a safety net we’ll remove once the AI gits gud.
I think this argument misunderstands where the value lies.
The $8,000 bolt doesn’t aspire to exist without inspectors. The inspection chain is the value. Remove it, and you have a $3 bolt that nobody will put in a helicopter.
The same principle applies to AI agents in enterprise workflows. The agent proposes, gathers context, routes approvals, and records the trace. The human reviews, approves, and their judgment gets captured as durable precedent. This enriches the accountability graph.
As similar cases repeat and the trace library grows, precedented decisions can be increasingly automated. Not always because the human got removed, but because their captured judgment now covers the pattern. The human stays in the loop for novel decisions: i.e. the ones where precedent doesn’t exist or the stakes demand fresh judgment.
This is a different architecture than ‘replace the human with an AI’. It’s more: make the human’s judgment traceable, replayable, and compounding.
Why Nobody’s Built This Yet
Salesforce knows what your opportunity looks like now. It doesn’t know what it looked like when the decision was made. Data warehouses have a time-based view, but they receive data via ETL after decisions happen. By the time data lands in Snowflake, the decision context is gone.
These companies aren’t structurally incapable of building a decision layer, but they’re definitely disincentivized to do so. Their entire business model is built around being the system of record, not the system of reasoning. Retrofitting that is closer to a ‘build a new product’ problem by moving up the value chain.
The structural advantage goes to whoever sits in the orchestration path: i.e. the layer where agents actually gather context, evaluate policies, route approvals, and commit actions. That’s where you capture traces at decision time, not after the fact.
Benedict Evans has talked about how enterprises need “a throat to choke”, usually in the form of a whipping boy vendor that carries accountability. In other words, the value is in the accountability layer that links data to action through traceable reasoning. The models that do this are fast becoming commodities.
The Playbook
If you’re building AI systems in an enterprise context, here’s the pragmatic way to take action and apply this thinking:
Start with human-in-the-loop, always. Don’t try to remove the human. Try to capture their judgment. Structure and store every approval, every override, every exception (without exception).
Instrument your agent orchestration to emit decision traces. Every time an agent runs, record: what context was gathered, what policy was evaluated, what precedent was referenced, who approved the action, and what the outcome was.
Store traces as a graph, not a log. Connect decisions to the entities they affect. Link precedents to the decisions they influence. Make the ‘why’ traversable.
Let the graph compound. Each captured decision makes the next one faster and more informed. Exceptions become searchable precedent. Tribal knowledge becomes institutional memory. The system gets smarter as the judgment library grows.
Use the graph for auditability. When something goes wrong you need to be able to trace backwards through the decision chain, just like you trace the $8,000 bolt from the crash site back to the foundry that made it.
An $8,000 Insight
The humble helicopter bolt teaches us something the AI industry keeps getting wrong.
AI’s value will come from the system that surrounds it: the decision traces, the accountability graphs, the clear chain of human judgment captured and made durable.
You are an $8,000 bolt. Your judgment, your approvals, your accountability are the things that actually keep the helicopter in the air.
So the question is whether someone will build a system that captures your judgment so it compounds, instead of evaporating into Slack threads.
That system is coming.