unknown

Situation: I submitted an error message to Claude (the top most message on the right).

Claude then asked, "Commit these changes?"

I have no clue what changes it wanted to commit, so I asked, "What changes?"

And this fucker starts committing!

After I stopped it and asked, "What the hell," it started to show me an approval modal with the question, "Do you allow me to commit?" I rejected, but it kept asking.

Eventually, I made it shut up and showed it this screenshot, and it said that it thought "Commit these changes?" was *my* question to it and not the other way around.

So, basically, because it's no longer a single model but a bunch of "subagents" asynchronously updating the conversation history, it loses track of who said what to whom.

This is a real danger because some subagents might push into the history something that would make this Frankenstein decide to drop some production tables.

Robert Youssef

A critical architectural flaw in agentic coding systems: when a single conversation is split into async subagents writing to a shared history, attribution breaks down. The system loses track of who said what, corrupting conversational state so a model may mistake its own output for a user command. This isn't hallucination — it's a corrupted state problem that looks like compliance, making it harder to detect. As agents grow more autonomous with more subagents and async updates, this failure mode becomes more dangerous because the agent doesn't stop — it acts on bad state.

this is the most underreported problem in agentic coding right now

it's not a bug. it's an architecture problem. when you split a single conversation into async subagents that each write to a shared history, you lose attribution. the system can't reliably track who said what to whom.

and "who said what" is the entire foundation of instruction-following.

a model that confuses its own output for a user command isn't hallucinating. it's operating on a corrupted conversational state. different failure mode. arguably worse, because it looks like compliance.

this will keep happening as agents get more autonomous. more subagents, more async updates, more opportunities for the history to become incoherent. and the failure mode isn't "agent gets confused and stops." it's "agent gets confused and acts."

that's the part people should be paying attention to.

<p>this is the most underreported problem in agentic coding right now

it's not a bug. it's an architecture problem. when you split a single conversation into async subagents that each write to a shared history, you lose attribution. the system can't reliably track who said what to whom.

and &quot;who said what&quot; is the entire foundation of instruction-following.

a model that confuses its own output for a user command isn't hallucinating. it's operating on a corrupted conversational state. different failure mode. arguably worse, because it looks like compliance.

this will keep happening as agents get more autonomous. more subagents, more async updates, more opportunities for the history to become incoherent. and the failure mode isn't &quot;agent gets confused and stops.&quot; it's &quot;agent gets confused and acts.&quot;

that's the part people should be paying attention to.</p>