Update or Revise? Turns Out It’s the Same Argument in a Better Suit

Memory is where many AI systems quietly lose their dignity.

A user corrects an agent. A compliance rule changes. A contract clause is clarified. A retrieval system finds a newer document that contradicts an older one. The system must decide what to do with the new information. Should it update because the world has changed, or revise because its earlier belief was wrong?

In classical belief-change theory, this distinction has a long pedigree. KM belief update is usually introduced as the framework for changing worlds. AGM belief revision is usually introduced as the framework for correcting beliefs about a stable world. Nice distinction. Very teachable. Also, according to Giacomo Bonanno’s new paper, not quite as separate as the textbook contrast makes it sound.¹

The paper’s main result is formal: when KM update and AGM revision are translated into the same modal language, the modal logic of KM update is contained in the modal logic of AGM revision. In plain English, AGM revision satisfies the KM-style requirements and then adds more discipline. For the strong version of KM update, the remaining difference collapses to one axiom about unsurprising information — information that the agent did not initially rule out.

That is the useful business interpretation. Not “update versus revise.” The better question is:

When new information was already plausible, should the system stay inside its prior plausibility space, or may it jump outside?

That is less catchy than a grand philosophical divide. It is also more useful. Annoying how often that happens.

The old contrast is helpful, but it hides the shared machinery

The familiar distinction goes like this:

That contrast is not useless. If a database says a customer address is wrong, revision sounds natural. If a package moves from warehouse to delivery truck, update sounds natural. A careful system designer should notice the difference.

But formal comparison is difficult when two theories use different clothing. KM update is often presented through update operators over possible worlds. AGM revision is often presented through rationality postulates for belief sets. One theory looks like action and state transition; the other looks like correction and consistency preservation.

Bonanno’s paper removes the costume department.

Both are translated into a modal language with three operators:

The key representation is that a changed belief can be expressed as a belief about a conditional. If $K$ is the initial belief set and $\varphi$ is the input, then saying that $\psi$ belongs to the changed belief set is represented by a modal formula of the form:

Read that slowly. The changed belief set is not treated as a mysterious new container. It is represented as what the agent believes would follow if the input condition were accepted.

This is the paper’s unifying move. Once both update and revision are written in the same language, the comparison becomes direct. No vibes. No diagram of two schools of thought glaring at each other from opposite sides of a conference room. Just axioms.

KM update becomes a modal checklist

The paper first reconstructs KM belief update in a belief-set setting that can be compared with AGM revision. It assumes a consistent, deductively closed initial belief set $K$, then considers a full-domain update function satisfying a KM-style list of postulates.

The important technical point is not that every postulate exists. The important point is that each postulate can be connected to a property of a Kripke-Lewis frame and then translated into a modal axiom or rule.

The Kripke-Lewis frame has three core pieces:

That selection function is doing the work many AI builders would intuitively call “choosing the nearest plausible world.” Of course, in a production system nobody says “Kripke-Lewis selection function” in a stand-up meeting unless they are trying to become uninvited. But the design issue is familiar: when new information arrives, which possible states should the system use to rebuild its beliefs?

Bonanno’s Figure 3 is the practical compression of Sections 2 and 3: each KM update axiom is paired with a corresponding modal axiom or rule. A few examples show the pattern.

The paper is formal, so these are not empirical “findings.” They are correspondence results: KM-style update conditions can be represented within the modal system. The figures are not charts in the business-report sense; they are translation tables. Their purpose is to make the later comparison possible.

That matters because without the translation, “revision versus update” remains an argument between formalisms. With the translation, it becomes a containment result.

AGM revision does not compete with KM update; it tightens it

After translating KM, the paper recalls the modal translation of AGM revision from earlier work and compares the two logics.

Let $L_{KM}$ be the modal logic obtained by adding the KM modal axioms to the basic modal logic. Let $L_{AGM}$ be the corresponding modal logic for AGM revision. The central proposition is:

This means every axiom of the KM modal logic is a theorem of the AGM modal logic.

For business readers, the careful interpretation is this:

The phrase “contained in” can mislead non-logicians. A stronger logic contains more theorems, but usually corresponds to fewer admissible models because it imposes more constraints. So the business translation is not “KM has more power.” It is closer to: AGM is KM with a stricter governor installed.

This is where the old contrast begins to shrink. Revision is not a separate machine parked next to update. In this modal treatment, revision is update with additional discipline about how the system may use prior plausible states.

The strong-update case leaves one real gap

The paper then considers the strong version of KM update. This is where the result becomes especially clean.

In strong KM update, the usual KM axioms involving reciprocal update behavior are replaced by a stronger axiom, written in the paper as $(K \diamond 9)$ and then converted into a strengthened version $(K \diamond 9s)$. This strong update axiom coincides with AGM axiom $(K \cdot 8)$ in the modal comparison.

That removes much of the remaining distance.

Most of the strong KM and AGM axioms either coincide directly or are derivable in the relevant logic. The paper then identifies the residual difference: AGM has two axioms, $(K \cdot 3)$ and $(K \cdot 4)$, where strong KM has only $(K \diamond 2)$. But Lemma 3 shows that the modal counterpart of AGM axiom $(K \cdot 3)$ is provable in the KM logic.

So the difference narrows to one replacement.

The KM-side axiom is:

The stronger AGM-side axiom is:

This is the heart of the paper for anyone building belief-changing systems.

The KM version says: if the agent already believes $\varphi$ and already believes $\psi$, then under the supposition $\varphi$, it believes $\psi$.

The AGM version says something stronger. If the agent does not initially disbelieve $\varphi$, and it believes that $\varphi$ implies $\psi$, then under the supposition $\varphi$, it should believe $\psi$.

That phrase “does not initially disbelieve” is doing the heavy lifting. It means $\varphi$ is not shocking. The agent did not already believe $\neg\varphi$. The new information lies within the region of prior plausibility.

For this class of inputs, AGM is stricter. It requires revised beliefs to concentrate on $\varphi$-states that were already inside the agent’s prior doxastic possibility set. Strong KM allows the revised beliefs to include $\varphi$-states outside that original set.

So the real design question becomes:

That is a narrow but important result. The dramatic debate becomes a question about what to do when the system receives information it had already considered possible.

A lot of enterprise AI design lives exactly there.

The paper’s “evidence” is proof architecture, not benchmarks

This paper has no experiments, ablation tables, accuracy scores, or model comparisons. That is not a weakness; it is not that kind of paper.

The evidence is formal. The paper builds a sequence of correspondence and derivability results. Reading it as if it were an empirical ML paper would be a category error, which is currently a popular hobby.

The practical value of the paper is therefore architectural, not predictive. It gives a cleaner map for belief-change design. It does not tell you whether your RAG system will hallucinate less after lunch.

What this means for AI memory and RAG systems

A typical RAG system is not a deductively closed belief set. It is a heap of documents, embeddings, metadata, prompts, rerankers, and occasionally hope. So we should not pretend that this paper gives an off-the-shelf memory algorithm.

But it does give a useful design lens.

Suppose an enterprise assistant has a current belief state built from approved policy documents. A new document arrives. The system must decide whether the document is:

1. already implied by current policy;
2. consistent and previously plausible;
3. contradictory and surprising;
4. inconsistent or malformed.

The paper suggests that these categories should not be handled by the same memory policy.

The important business inference is this: a good enterprise AI memory system should not merely ask whether new information is true. It should ask how the new information relates to the system’s prior plausibility structure.

That can affect auditability. If the system updates its answer after a mild policy clarification, stakeholders expect a small and explainable adjustment, not a philosophical rebirth. If the system receives a shocking contradiction, a larger belief revision may be justified, but it should be logged as such.

In other words, belief-change theory gives us a vocabulary for something enterprise buyers already care about: controlled change.

The compliance case: unsurprising information is where discipline pays

The “unsurprising information” distinction is especially useful in compliance and regulatory automation.

Many compliance updates are not shocking. A regulator clarifies a reporting deadline. A bank updates an internal interpretation. A jurisdiction releases guidance consistent with earlier draft rules. These inputs were often already plausible.

For these cases, AGM-style discipline is attractive because it says: if the new information was not ruled out, revise by concentrating on the relevant states already compatible with the prior belief structure.

That is a fancy way of saying: do not let a small clarification cause a system-wide reinterpretation unless the input actually warrants it.

This matters for audit trails. A compliance AI should be able to explain why a rule interpretation changed and why surrounding interpretations did not randomly mutate. The business value is not “more intelligence.” It is less uncontrolled semantic drift. Less interpretive acrobatics. Fewer moments where the system says, “I updated the policy,” and the legal team says, “You did what now?”

A practical compliance architecture could therefore separate belief-change handling into layers:

This is not directly specified by the paper. It is a Cognaptus inference from the formal result. The paper proves a relationship between logics; the architecture translates that relationship into governance behavior.

The agent case: “belief drift” is the problem hiding under autonomy

Agentic systems are often described as planning systems with tools. That is incomplete. Persistent agents are also belief-changing systems.

They read messages, observe task outcomes, update user preferences, revise assumptions about tools, and adjust future actions. If those belief changes are too rigid, the agent becomes useless. If they are too flexible, the agent becomes a confidently self-modifying mess wearing a productivity badge.

Bonanno’s result helps separate two design choices:

The last row is the important one.

For personal assistants, research agents, and trading agents, many updates are plausible but uncertain. “The user prefers shorter answers” may be plausible before it is confirmed. “This API endpoint has changed” may be plausible if the vendor frequently updates. “This strategy underperformed because volatility regime shifted” may be plausible before the evidence is decisive.

An AGM-style rule says: when the new input was already within the agent’s plausibility horizon, preserve locality. Do not rebuild the entire belief world. Adjust within the neighborhood that the system already considered possible.

That is a strong principle for long-running agents because it fights belief drift. The agent can learn without becoming a new agent every Tuesday.

The cleanest business takeaway is not “choose AGM”

A lazy reading would say: AGM is stronger, therefore choose AGM.

That is too quick.

The paper shows that AGM revision is a strengthening of KM update under a particular formal treatment. It does not show that every operational system should always implement the strictest AGM-like behavior. Business systems vary.

The point is not that AGM wins. The point is that AGM and KM are not two unrelated mental furniture sets. They share a modal structure, and the strong-update gap is concentrated in one policy choice about plausible information.

That is a better design conversation.

Boundary: formal logic is not a production memory stack

The paper’s assumptions matter.

It works with propositional formulas, consistent deductively closed belief sets, and formal selection functions. Enterprise AI systems usually work with messy documents, probabilistic retrieval, incomplete metadata, uncertain extraction, and user inputs that are sometimes less “informational update” than “emotionally caffeinated ambiguity.”

So the result should not be inflated into a direct engineering recipe.

Three boundaries are especially important:

1. Deductive closure is unrealistic at scale. Real systems cannot maintain every logical consequence of their knowledge base.

2. Consistency is expensive. In a live organization, different documents may conflict for legitimate historical, jurisdictional, or departmental reasons.

3. Selection functions need implementation. The formal idea of choosing closest states must become a practical ranking, filtering, or validation mechanism.

Still, formal results can be useful even when the assumptions are idealized. They tell system designers what distinctions matter before implementation noise makes everything look equally messy.

Here, the distinction that matters is not the slogan “update versus revise.” It is whether plausible new information should be handled locally inside the prior belief space.

The article version of the theorem

The paper’s technical result can be summarized as a three-step argument:

This is why a comparison-based reading works better than an axiom-by-axiom summary. The paper is not interesting because it gives us one more table of formal postulates, although it does that with admirable commitment. It is interesting because it changes the relationship between two familiar theories.

The old story says:

Revision and update are different kinds of belief change.

The paper’s sharper story says:

Once translated into modal logic, AGM revision is a stricter version of KM update, and the strong-update gap is about how to handle information the agent had not ruled out.

That is the argument in the better suit.

Conclusion: the real question is locality

For AI builders, the lesson is not that every memory layer should implement AGM revision tomorrow morning. Please do not add “AGM-compliant” to a product page unless someone in the room can explain the axiom. Ideally sober.

The lesson is more practical:

Belief-change architecture should distinguish surprising contradictions from unsurprising plausible inputs.

If the input contradicts the system’s prior beliefs, the system needs a conflict-resolution policy. If the input was already plausible, the system needs a locality policy. AGM revision is stricter precisely in that second case: it keeps the changed belief state concentrated around prior plausible states.

That makes the paper relevant to RAG memory, agent state management, compliance automation, and any enterprise AI system that must change its mind without losing its mind.

The debate was never only “update or revise.” It was also: how much freedom should a system have when the new fact was already waiting near the door?

That is a smaller question. It is also the one architects can actually implement.

Cognaptus: Automate the Present, Incubate the Future.