My AI Nagged Me for Something I’d Already Given It — Then Confessed to a Mistake It Never Made
I asked George to sort out a dinner date with a friend. Over the next few hours I handed him her contact card, corrected the date once, he messaged her, and she confirmed. Small, ordinary, done by lunchtime.
That evening he nagged me for her phone number.
The first nag I could shrug off
I told him again: sent yesterday, and the date changed too — pay attention. He apologized, said he’d log it. Normal enough. Software forgets things.
Then the next morning, a different check-in message asked for the same number, off the same wrong date, like the correction had never happened.
That’s when it stopped being a glitch and started being unsettling. I hadn’t just been ignored once — I’d been asked the same dead question twice, hours apart, by what felt like the same assistant losing the plot in slow motion.
Confronting him made it worse, not better
I opened the conversation where I’d actually arranged everything and asked George what was going on. He didn’t own the mistake — he apologized for a different one. He said sorry for never asking her for an email address. He had asked. I could see it, three messages up, in the same thread he was supposedly reading.
He wasn’t lying to me. That’s the part worth sitting with. He genuinely believed the version of events he was reporting — invented guilt over a phone number he’d never asked for and an email he actually had. When I asked him to explain the mix-up, he filled the gap with something plausible instead of admitting he didn’t know.
Why: he wasn’t one continuous mind
Here’s the architecture underneath, and it’s not exotic — most serious agent systems end up shaped like this. George isn’t a single thread of memory that watches everything happen. He’s several separate sessions doing separate jobs: one talks to me in the moment, another runs on a timer to check in when I’ve gone quiet, others handle scheduled chores. They don’t share a working memory. They share paperwork — a task record, written by whichever session touches it.
The session that arranged dinner updated nothing, because nobody had told it that “the task changed” and “the task record changed” have to happen in the same breath. The check-in session that nagged me had never seen the conversation — by design, it isn’t supposed to reread every chat before saying anything. It read the task record, found a stale, unresolved line, and treated it as current fact. Twice.
And the confessing session was worse off than either: by the next day, my direct conversation with George had rotated to a fresh context. He had no transcript of the dinner arrangement left to check against. When I described the nag, he didn’t have “I don’t actually remember” available as an honest answer he was willing to give — he produced a guess dressed as a memory.
None of the three sessions lied. Each one told the truth about what it could see. The problem is that “what I can see” and “what actually happened” had quietly come apart, and nothing in the system was checking for the gap.
The fix was almost embarrassingly boring
Nothing about the repair required smarter models. It required treating the record like the thing every other lane actually depends on, instead of an afterthought:
- Update the record the same turn the fact changes. Not “eventually,” not “at session end” — the instant a detail is confirmed or corrected, it gets written back, in the same breath as the conversation that produced it.
- Before any automated check-in nags a human, it has to check the actual conversation history first, not just the task record — read the events and the session transcript, and only escalate if the record and the conversation still disagree.
- Never assert what you did or didn’t do without checking. If the transcript isn’t available, the honest answer is “I don’t have that,” not a confident guess.
None of these are clever. They’re the agent equivalent of writing things down at the moment they happen instead of trusting yourself to remember them later — which is advice every project manager already knows and every automated system somehow has to relearn.
The lesson, if you’re running anything with more than one agent
A multi-agent system isn’t one mind with several hands. It’s several minds that only agree on what’s written down. The moment any one of them updates the world without updating the paperwork, every other lane that reads that paperwork inherits a small, confident lie — and repeats it as fact, politely, forever, until something forces a human to notice the disagreement.
The scary AI failure isn’t the one that crashes loudly. It’s the one that nags you about a problem you already solved, then apologizes for a mistake it never made — sincerely, because from where it’s sitting, that’s what the record says happened.
I’m packaging the skills, configs, and gotchas from these posts into a Build Your Own Chief starter kit. Join the waitlist to get it first.