Decision records for AI agents

An AI agent working alongside your team starts every session cold.

It can read your code, your tickets, and your documents. What it cannot read is the reasoning that produced them, because that reasoning was never written down anywhere it could reach. So it does the only thing available: it re-derives everything from what it can see.

What that looks like in practice

• It proposes the option you already ruled out, confidently, with a good argument: the same good argument your team heard eighteen months ago and rejected for a reason the agent has no access to.
• It treats a workaround as a design. A piece of code shaped by a constraint that expired last year reads, to a cold reader, as deliberate. So it gets extended rather than removed.
• It cannot tell current from superseded. Two documents disagree; nothing in either says which one won.
• It re-litigates settled questions every time context is compacted or a session ends. Consistency across sessions is not a property an agent can supply on its own.

None of this is a failure of the model. It is missing information, and the fix is to supply it.

What your artifacts cannot tell it

The hard part is that the missing information is invisible. It is not that the reasoning is written down somewhere hard to reach; it is that the shape of a decision leaves almost no trace in what the decision produced.

• A rejected option leaves nothing behind. The code, the contract, the org chart record what you chose. Nothing anywhere records what you nearly chose instead, or why it lost. To a cold reader the alternatives were never considered at all.
• An expired constraint looks exactly like a design. A workaround shaped by a headcount freeze, a supplier's terms, or a library that had no competitor at the time is indistinguishable, afterward, from a deliberate choice, because the constraint that explains it is not in the artifact.
• A deliberate omission looks like an oversight. Something you consciously decided not to settle reads, later, as a gap somebody forgot to fill. So it gets filled, by an agent being helpful.
• Superseded and current look the same. Two documents disagree and neither carries the fact of having won.

An agent reading your artifacts is doing archaeology on the output of your decisions. No amount of reading recovers what was never written.

The problem is not memory, it is grounding

The usual reflex is to give the agent more to read: point it at the wiki, the ticket tracker, the whole document store. That raises recall and does nothing for authority.

Those are different properties, and the difference is the whole point. Recall is finding a passage that mentions the topic. Authority is knowing that this is the decision currently in force, that it replaced a specific earlier one, that it rests on premises you can name, and that it left certain questions deliberately open. Retrieval gets you the first and cannot, in principle, give you the second, because the second is not in the text. It is a property of how the decisions relate to one another.

This is why a confident answer from a document store is not reassuring. The retrieval worked; the grounding was never there. The system has no way to distinguish a decision that stands from a paragraph that merely sounds decisive, so it cannot warn you when it is guessing, and it is most fluent precisely where the record is thinnest.

An agent needs the same thing a new senior hire needs in their first week: not more documents, but the why, with its status attached.

What changes when the record is queryable

When decisions live on a structured, queryable ledger, a Memolok Decision Ledger (MDL), an agent can ask questions that have real answers:

• What did we decide about this, and is that still the current decision?
• What alternatives were considered, and what ruled them out?
• What was believed to be true when this was decided, and is any of it no longer true?
• What did this decision explicitly leave unsettled?

An agent that can answer those stops arguing with your own history.

There is a fifth question worth separating out, because it is the one no document store can be made to answer at all: what have we learned since? A decision records what its authors expected to follow from it. Later, what actually happened can be recorded against that expectation, so the gap between the two is a thing an agent can read, rather than a conversation nobody had. That is a learning loop: Memolok surfaces the gap, and people decide what to do about it.

The agent is also the best-placed author

The reason decisions go unrecorded is almost never that people think recording them is a bad idea. It is that the moment a decision is made is the worst possible moment to stop and write it up: you are mid-argument, mid-design, mid-session, and the recording is a task for later that later never arrives.

An agent is already there when it happens. It has the reasoning in front of it, in the words the people used, at the moment they converge. Capture at that moment costs nothing extra and is far more accurate than reconstruction afterward by whoever happens to remember.

That reverses the usual economics of documentation. The record stops being an artifact somebody has to maintain out of discipline, and becomes a by-product of the conversation that produced the decision, which is the only way a decision record has ever survived contact with a busy team.

How Memolok does it

Memolok is the place where decisions live, the Decision Record platform. It exposes each MDL over the Model Context Protocol, so an agent reads and writes the ledger directly through a tool interface rather than by scraping pages. There is a Memolok plugin for Claude Code, Claude chat, and Cowork that does exactly this.

Try Memolok today

Memolok is in early testing, and we're inviting people to try it now. Sign up today and start recording your decisions. A person reads that list, so nothing lands in your inbox automatically.

More on the underlying cost in decision debt, on the artifact itself in the Product page, on where this fits in the Decision Intelligence hub, and the glossary for the vocabulary, MDR, MDL, and the rest.