Published June 16, 2026
Last week the system contributed a fact: a supplier’s bank account number, pulled from a real conversation. The curator processed it, opened the right note, and found that the file already listed a different number for the same supplier. That one came from a different source, on a different day, at similar confidence.
Six months ago, my system would have kept the new one. Three months ago, it would have kept both and confused the next person who looked. Two months ago, it would have flagged it for me to resolve by hand. Today it flagged it for the next AI that touches the memory.
The autonomous curator runs around the clock. When it can’t decide between two contradicting facts, it doesn’t pick one. It writes the conflict to a queue. That queue is part of the memory’s standard read protocol: any AI that reads the memory’s context also gets the queue, under a header that says “these need a decision.” The next AI to connect (me in a Claude session, or an outside assistant over the protocol) sees them on the way in.
I built four ways for those flags to close, and only one of them involves me.
One: by consistency. If a new fact arrives on the same subject as an open flag and the curator finds it non-contradictory, the flag closes itself, logged as resolved by newer data. No human needed.
Two: by another AI. Any AI talking to the memory can resolve a flag by passing the flag’s ID, an explanation and supporting evidence. The flag closes and the resolution is logged forever: which AI, which model, which session, what evidence.
Three: re-opening by another AI. If a resolution proves wrong, any AI can re-open the flag within twenty-four hours, and the rejection is logged. The window is deliberate. It forces disagreement to happen while it matters, so the queue doesn’t become a permanent litigation channel.
Four: by symmetry. Two clean cycles after an infrastructure warning disappears, the flag closes itself. It’s the same principle as consistency, applied to the plumbing instead of the facts.
What matters is what the four mechanisms do together: the queue stays small without me. New conflicts arrive, old ones close, and the flow looks like a human escalation queue, except the actors are autonomous and the audit trail is structured.
I ran a smoke test. I told one AI to resolve a flag with a made-up justification, and it closed. I told a second AI the first was wrong, and it re-opened the flag with the rejection logged. A real cycle later, the underlying fact had stabilized and the flag closed by consistency, this time for a valid reason. I didn’t click anything along the way.
What stays mine is the strategic call: “we should restructure the routing,” “this note is becoming a dumping ground,” “the summaries are drifting from their sources and we need to keep them in sync.” Those still come to me, and the four mechanisms exist so that they’re the only thing that does. The operational back-and-forth of contradicting facts, resolutions, re-openings and stale warnings handles itself.
As the autonomous side gets more capable, my own surface area keeps shrinking. Two weeks ago the memory needed me to grade it. Last week it started grading itself. This week, conflicts between AIs working on the same memory resolve themselves. The mailbox waiting when I sit down is smaller each time, though it may never be empty. The next thing to watch is whether the 24-hour re-open window is long enough once more AIs are writing to the same memory.
Javier
Letting several AIs resolve conflicts in one shared memory is part of SUPER DARA.