When two agents disagree about a fact

One agent reads the contract and records that the renewal price is one number. A second agent reads the email thread where that price was renegotiated last week and records a different one. Both are now in the company’s memory. Both look equally true. The next time anyone, a person or a third agent, asks “what’s the renewal price?”, the system has two answers and no idea which one to give.

That’s not a bug in either agent. Both did their job correctly. The bug is that nobody decided what happens when two correct readings of the world point in opposite directions.

Truth in a multi-agent system is a protocol, not an assumption. The whole job is deciding how the system resolves a conflict before it ever has one, and “pick whichever was written last” is not a decision, it’s a coin flip wearing a timestamp.

This post is about that protocol: why disagreement is the normal state, not the broken one, and what a reconciliation rule actually has to weigh.

The naive version: last write wins

The first time you build shared memory for a fleet of agents, you build the simplest thing that could possibly work. Every agent writes what it learns into one store. When two writes touch the same fact, the newer one overwrites the older one. Last write wins.

It works beautifully right up until two agents are doing real work at the same time.

Here’s the failure, concretely. Imagine an agent reading a signed contract, a slow, careful read of an authoritative document, that finishes at 9:02 and records the renewal price. Meanwhile a faster agent skims an internal chat where someone guessed at the price from memory, and it finishes at 9:04. Last-write-wins now believes the guess, because the guess arrived two minutes later. The system didn’t pick the better source. It picked the later clock.

Last write wins doesn’t resolve conflicts. It hides them under a timestamp.

And the timestamp is the worst possible tiebreaker, because recency and reliability are uncorrelated. The most recent thing an agent saw is frequently the least trustworthy thing, a Slack aside, a stale cached page, a draft someone never sent. By the time you notice the wrong number is in memory, three other agents have already read it, acted on it, and written their conclusions on top of it. The error doesn’t sit still. It propagates.

So the naive store gives you a memory that is confidently, silently wrong, and gets more wrong the busier you are. The fix is not a better clock. The fix is to stop pretending the clock was ever the answer.

Why disagreement is the normal state

Before we build the rule, we have to correct the instinct that conflict is rare. It isn’t. In a system where many agents read many sources, conflict is the expected output, and a system that’s surprised by it is a system that will lose to it.

Think about where facts come from. The same fact, a price, a date, a person’s title, a status, lives in a contract, an email, a chat, a CRM field, a meeting transcript, and three people’s heads. Those sources were never consistent with each other. They disagree right now, in your company, before any agent touches them. The CRM says one thing because nobody updated it. The email says another because that’s where the real decision happened. The agents didn’t create the disagreement. They surfaced it.

A single human knowledge-worker resolves these conflicts constantly without naming it. You read the chat, then you remember “but the contract says otherwise,” and you trust the contract. You hear two versions of a date and you trust the one from the person who owns the calendar. You’re running a reconciliation rule in your head, source authority, confidence, recency, all weighed in a fraction of a second, and you’ve done it so long you forgot it’s a skill.

The naive store has none of that skill. It treats every write as equally true and keeps the last one. So the first real job isn’t storing facts. It’s giving the system the judgment a human applies for free: when two truths collide, which one wins, and why.

The reconciliation rule has three inputs, not one

Last-write-wins fails because it uses exactly one input, time, and uses it as the whole answer. A real reconciliation rule uses time as one input among several, and never the deciding one on its own.

Three inputs carry most of the weight.

Source authority, where did the fact come from? A signed contract outranks a forwarded email. A system of record outranks a hallway guess. A primary document outranks a summary of it. This is the input humans lean on hardest and the one last-write-wins ignores completely. The first question is never “when was this written?” It’s “what is this a reading of?” A fact inherits the trustworthiness of its source, and that ordering is something you can decide in advance: contracts above CRM fields above chat above an agent’s own inference.

Confidence, how sure was the agent when it wrote this? Not every read is equal even from the same source. An agent that extracted a date from a clean, explicit line (“renews on the 14th”) should write that with high confidence. An agent that inferred a date from context it had to stitch together should write it with low confidence and say so. When two facts collide, the one the writer was sure about beats the one it half-guessed, but only if the agent recorded its confidence in the first place. A fact with no confidence attached is a fact you can’t reconcile.

Recency, which reading is about the more current state of the world? Recency isn’t worthless. It’s just last in line, not first. When two facts come from sources of equal authority and equal confidence, two emails, both authoritative, both certain, then yes, the newer one usually reflects the more current truth. Recency is the tiebreaker after the other two have spoken, not the opening argument. The renegotiated price beats the original price because the renegotiation came later AND came from an equally authoritative source, not because of the clock alone.

The rule, stated plainly: rank by source authority first, break ties by confidence, break remaining ties by recency. Three dials, applied in order. Last-write-wins was that same rule with the first two dials snapped off.

There’s a fourth thing the rule has to do, and it’s the one people forget: when the inputs genuinely tie, equal authority, equal confidence, conflicting values, the rule must not pick. It must mark the fact as disputed and surface it, because a confident wrong answer is worse than an honest “these two sources disagree, which is right?” The willingness to say I have two answers and can’t choose is part of the protocol, not a failure of it.

Ours: the conflict becomes a first-class event

Here’s the shift that makes the whole thing work. In the naive store, a conflict is an accident that overwrites silently. In a real system, a conflict is an event, something the memory layer notices, records, and resolves on purpose, leaving a trail of why.

When a new fact arrives that contradicts one already in memory, the system doesn’t just compare timestamps and move on. It runs the rule. It checks the authority of both sources, the confidence of both writes, and only then the recency. It keeps the winner as the live answer, and it keeps the loser too, not as truth, but as history: here’s what we used to believe, here’s the source that overturned it, here’s the rule that decided. The fact that lost the argument isn’t deleted. It’s the receipt that proves the system didn’t flip a coin.

That trail is what turns memory from a guess into something you can trust. When a third agent reads “the renewal price is X,” it isn’t reading a value that happened to be written last. It’s reading a value that won, that beat a competing reading by a stated rule, with the loser still on file. If the answer turns out wrong, you don’t shrug at a black box. You read the trail, find the dial that was set wrong, maybe a source ranked too high, maybe an agent too confident, and you fix the rule, not just the one fact.

And the disputed case earns its keep. Say two equally authoritative sources flatly contradict each other and the rule honestly can’t choose. The system doesn’t pretend. It marks the fact disputed and raises it, to a person, or to an agent whose job is to go find the tiebreaker by reading one more source. A disagreement the system knows it has is a small, fixable thing. A disagreement it doesn’t know it has is the wrong number propagating through every decision downstream.

The naive store optimizes for never having to think about conflict. The real system optimizes for handling conflict well, because it knows conflict is coming.

The turn: every company is already a reconciliation engine

Step back from the agents and you’ll recognize this problem, because your company has been running this protocol by hand for years.

Somewhere in your organization, two people believe two different things about the same fact right now. One has last quarter’s number, the other has this quarter’s. One read the contract, the other remembers the call. Most of the time it doesn’t blow up, because eventually someone with enough context and authority says “no, this is the real number, here’s why”, and everyone updates. That person is your reconciliation rule. They’re weighing source, certainty, and recency in their head, and the company runs on their judgment.

The problem is that this judgment lives in a few overloaded people, fires only when a conflict happens to surface, and leaves no trail when it does. When that person is busy, the wrong number wins by default, exactly like last-write-wins. When they leave, the rule leaves with them. The company’s most important skill, deciding which version of a fact to believe, is undocumented, unevenly applied, and invisible until it fails.

What we’re building is a memory that runs that judgment out in the open, every time, with the reasons written down. Not an agent that’s never wrong, that doesn’t exist. A system where, when two agents disagree about a fact, there’s a rule that decides, a record of why it decided, and an honest flag when it can’t. Truth in a multi-agent system is a protocol, not an assumption, and the companies that win the next decade will be the ones that wrote the protocol down instead of leaving it in one tired person’s head.

---

That’s part of what we’re building at Apollo Space: a company brain where many agents read many sources, disagree constantly, and resolve it by a rule you can inspect, not a coin flip wearing a timestamp. If your company has ever made a decision on a number that turned out to be the wrong version, you already know the conflict was never the danger. The silence around it was.