Decisions Are Not Facts

Somewhere in every engineering organization there is a rule nobody can explain. The archetype is the Friday deploy freeze: no production changes after Thursday night, enforced with religious seriousness, sometimes wired into the CI config itself. Trace one back and you find an incident, years old, involving a system that has since been decommissioned. The constraint that justified the freeze is gone. The people who made the call are gone. The freeze outlives all of it, because somewhere along the way it stopped being a decision and became a fact.

Last week I toured the memory types agents write for themselves and claimed that one of them outranks the rest. This essay starts paying that claim off, because the transformation in that deploy freeze (a decision quietly becoming a fact) is one agents are about to industrialize. An agent that persists its own state writes down conclusions constantly: use the EU cluster for this customer, prefer the streaming API over polling, never retry this endpoint twice. Every one of those is a decision. And in almost every agent memory stack in circulation right now, the moment it gets written down, it is stored exactly the way a fact is stored: as text in an index, retrieved by similarity, served back with the same authority as "the customer is in Germany." The verdict survives. The trial is gone.

What a decision actually is

A fact makes a claim about the world. The customer is in Germany. The deploy finished at 14:32. A fact is falsified by the world changing, and (as I argued in the essay on time) the dangerous fact is the one that was true and quietly stopped being true.

A decision is a different kind of object. It does not claim the world is a certain way. It commits to an action, given alternatives that were considered, constraints that held at the time, and evidence that was available. A decision is not true or false. It is standing or it is not. And the conditions that decide whether it should stand are not in the decision. They are in its premises, and premises die.

That difference in kind means a decision has a shape that prose flattens:

What was chosen. The one part everyone stores.
What was rejected. The most information-dense part, and the first thing lost. "We chose Postgres" tells you almost nothing. "We chose Postgres over Dynamo because we needed transactional writes and had no scale pressure" tells you exactly when to reopen the question: the day scale pressure arrives.
What it was derived from. The evidence and prior memories the decision stands on. Not decoration. This is the load-bearing link, because it is the only way to find out that a decision's ground has moved.
Who or what made it. A human policy, an agent inference, and a passing preference deserve different authority, the same way testimony and verified facts do.
What would reopen it. Every real decision has an expiry condition, even when nobody writes it down. Especially when nobody writes it down.

Store the sentence "we decided to shard by region" in a vector index and every one of those fields evaporates at the door. What is left reads back as a fact about the world. It is not one. It is a commitment whose reasons are no longer on file.

Four ways the flattened decision fails

The laundered decision. Stored as prose, a decision gets retrieved like a fact and inherits fact-authority. "We chose X" quietly becomes "X is the right choice." This is the same laundering I described with episodic memory, where "the user said the subscription is cancelled" becomes "the subscription is cancelled," except worse, because a decision was never a claim about the world in the first place. There is nothing to check it against. It just sounds settled.

The zombie decision. The premises get superseded and the decision keeps standing, because nothing connects premises to decisions. The customer moved out of the EU. The fact updated, because the fact was challengeable. The routing decision derived from the old fact is still in the store, still confident, still being retrieved. My Friday deploy freeze, at machine speed. If decisions do not carry explicit links to what they were derived from, no amount of fact hygiene saves you, because you have no way to ask the one question that matters: which decisions are standing on ground that moved?

The shadowed conflict. Two decisions that contradict each other, made in different sessions under different conditions, both retrieved as context. The model resolves the conflict by accident: recency, similarity score, whichever landed closer in the prompt. Nobody chose the winner. Conflict between commitments is real signal (it usually means the world changed between them) and a flat store cannot even represent it, let alone surface it.

The relitigated decision. The mirror image of the zombie. With no decision record at all, the agent re-decides from scratch every session, and a model re-deriving a judgment call from partial context will not land in the same place every time. Monday it shards by region, Thursday by customer ID, each defensible in isolation. Users experience this as unreliability. It is actually amnesia about commitments, which no amount of factual memory fixes, because the missing state was never factual.

The type test

In the essay on the five memory types I gave the rule I keep coming back to: when a kind of memory has its own lifecycle and its own rules for aging and trust, it gets to be a type. Flatten it into "just text in the index" and you sign up to relearn its failure modes the hard way.

Decisions pass that test more sharply than anything else in the store. They have the richest lifecycle of any memory kind I know of: proposed, standing, reinforced, contradicted, superseded, retracted. They age by a mechanism no other type shares (challenge, not time, which is the subject of next week's essay). They carry their own trust semantics, because a policy a human placed, a choice an agent inferred, and a preference observed in passing are all "decisions" with entirely different authority. And they demand their own relationships: derived-from, supersedes, conflicts-with. None of those are similarity, and a flat index speaks only near.

This is why SmartMemory treats decisions as a first-class memory type rather than a metadata tag on prose. A decision is created with its evidence linked at write time, typed by what kind of commitment it is (an inference, a preference, a classification, a policy), carrying its own confidence and status. The graph keeps the derivation edges so the zombie question is answerable with a query instead of an archaeology project. Conflicts are detected and surfaced instead of being resolved by prompt position. The rejected alternatives and the reopening conditions live on the object, not in a sentence that embeds well.

None of that is exotic engineering. It is the same move databases made when they stopped storing dates as strings. The information was always there at write time. The type is what refuses to throw it away.

What to do if your agent makes decisions now

Which it does, whether or not you store them as such.

Separate decisions from facts at write time. If "the customer is in Germany" and "route this customer to the EU cluster" go into the same index with the same shape, the second has already been laundered into the first.
Record the rejected alternatives. They are the reopening conditions. A decision that does not know what it rejected cannot know when to reconsider.
Link every decision to its evidence. Derived-from edges are what make "which decisions does this stale fact invalidate?" a query. Without them, superseding a fact silently strands every commitment built on it.
Detect conflicts instead of letting the prompt resolve them. Two standing decisions that contradict each other are a fork in your agent's identity. Surface it.
Give decisions a status, not just a timestamp. Standing, superseded, retracted. An agent should never have to infer from prose whether a commitment is still in force.

The Friday deploy freeze is, in the end, mostly harmless. It costs some Friday afternoons. The agent version of it will not be harmless, because agents act on their memory without a human in the loop to squint at a rule and ask where it came from. A decision stored as a fact is a commitment that has stopped being accountable to its reasons. Your agent's memory is full of them right now.

Next week: how a decision ages. Facts rot quietly. Decisions age by challenge, and a memory system that understands the difference can tell you not just what your agent believes, but how contested that belief is.

I'm building SmartMemory, the expertise layer for AI agents: provenance-tagged, bi-temporal, graph-backed memory that knows not just what's true, but what to do, and when it stopped being true.

Try it: pip install smartmemory (docs) · hosted beta (private): smartmemory.ai/signup