Back to blog
Context layer

What Happens When Two Coding Agents Get Different Answers

Agent A read the doc. Agent B read the ticket. Both were right once. Here's why neither one knows it's now wrong.


One agent proposes a change based on the spec doc. Another agent, working the same afternoon on a related piece of the same feature, proposes something that contradicts it, based on the ticket. Both outputs are confident, well-reasoned, and internally consistent. They just don’t agree with each other, and neither agent has any way of knowing that.

Two agents reading two different sources, a stale doc and a fresh Slack thread, will confidently produce two different, both-sound-reasonable answers, with no built-in way to know one of them is wrong. Neither agent has a signal that it’s out of sync with the other. That’s a distinct failure mode from a single agent being wrong, and it’s worth naming precisely, because it’s becoming more common exactly as teams run more agents at once.

What happens when two coding agents get different answers to the same question?

Both proceed with confidence, because each is being internally consistent with whatever it read, and neither has a mechanism for detecting that the other agent read something different. Agent A reads a spec document and produces output consistent with it. Agent B reads a ticket, updated more recently by someone in a meeting, and produces output consistent with that instead. Both agents did their job correctly relative to their own input. The disagreement isn’t a bug in either agent’s reasoning, it’s a consequence of the fact that they were never reading from the same place, and nothing in the system flagged that gap before both outputs shipped.

That’s worth sitting with precisely: this isn’t one agent hallucinating and one agent being right. Both are working correctly from real information. The information itself just diverged before either agent touched it, and each agent inherited only one side of that divergence.

Why is this worse than a single agent being wrong?

Because it produces two confidently different outputs at once, with no signal from either agent that something’s off, whereas a single wrong agent at least produces one output a reviewer can check against reality. When one agent is wrong, a person reviewing its output has a chance to notice the mismatch between what it produced and what’s actually true. When two agents disagree, a reviewer sees two internally consistent, well-reasoned outputs pointing in different directions, and nothing about either output on its own reveals which one, if either, reflects the current, correct answer. The reviewer now has to do the reconciliation work the system should have done before either agent acted, at the point where the disagreement is hardest to spot: after the fact, comparing two finished pieces of work instead of catching one divergent source before anything got built on it.

This is a documented, named failure pattern in multi-agent systems specifically, not a hypothetical worry. Research analyzing why multi-agent LLM systems fail in production has identified contradictory outputs, agents producing inconsistent results from what should be shared premises, as one of the recurring, categorized failure modes, distinct from a single agent simply being wrong. It shows up often enough, and costs enough to untangle, that it’s been named and studied as its own category rather than treated as a variant of ordinary agent error.

Where does this show up in practice?

In two common, concrete shapes: one agent proposing a fix that’s already been reverted somewhere else, or two agents building against two different versions of the same spec at the same time. The first shows up when an agent picks up a stale document describing a problem that’s already been solved a different way; it proposes a fix for something that no longer needs fixing, or proposes the original, already-superseded approach. The second shows up on parallel work: two agents touching related parts of the same feature, one reading the spec as written last week, the other reading a Slack thread that updated the requirement two days ago, each building a piece that’s internally correct and mutually incompatible with the other.

One feature, two agents, two sources

Take a concrete version. A team is adding a new export format to a reporting feature. The original spec, written two weeks ago, says exports should be capped at 10,000 rows for performance reasons. Since then, in a Slack thread, the team revised that: after testing, they raised the cap to 50,000 rows, because the performance concern turned out to be smaller than expected. Nobody updated the spec document.

Agent A, working on the export logic itself, reads the spec and implements the 10,000-row cap, exactly as written. Agent B, working on a related validation function that checks export size before allowing a download, reads the more recent Slack thread through a different context channel and implements validation against the 50,000-row cap. Both agents ship correct, well-tested code relative to what they each read. Together, the feature is now internally contradictory: the export logic truncates at 10,000 rows with no error raised, while the validation logic approves requests up to 50,000, meaning some approved exports come back incomplete and nothing in either system flags it.

Neither agent did anything wrong by its own lights. The contradiction exists entirely because they never shared the same source, and nothing about either agent’s process was built to check whether the other one might be working from something different.

Reading from separate sources Reading from one shared, checked source
Agent A reads the spec (10,000-row cap, two weeks old) Both agents read the same reconciled answer: 50,000, sourced to the Slack decision that updated it
Agent B reads the Slack thread (50,000-row cap, current) The divergence never gets a chance to exist, because there was only ever one answer to read
Both outputs are internally correct and mutually incompatible Both outputs agree, because they were built from the same starting fact

What actually changes with a shared, checked source?

The divergence gets removed at the root, before either agent acts, instead of getting reconciled after the fact by a person comparing two finished, contradictory outputs. If both agents in the export example had read the same current answer, “the cap is 50,000 rows, per the Slack decision on this date, superseding the original spec,” there would have been nothing to disagree about, because there was only ever one fact for either of them to read. That’s a fundamentally different fix than catching the contradiction in review. Catching it after the fact still costs real time: someone has to notice the mismatch, figure out which value is actually current, and get both pieces of code corrected. Removing the divergence at the source means that cost never gets paid, because the disagreement never had a chance to form.

Isn’t the real fix just running fewer agents so this can’t happen?

No, because teams run multiple agents and tools by design, for real reasons, not by accident, and reducing agent count doesn’t address what actually caused the disagreement. A team running two agents on related parts of the same feature is doing that deliberately, to parallelize real work. The fix for two agents disagreeing isn’t “run one agent instead,” which just trades a coordination problem for a throughput problem. The actual fix is making sure whichever agents are running, however many there are, read from the same current, reconciled source, so the number of agents stops being the variable that determines whether they agree with each other.

Does a shared source remove the need for a human gate?

No, it changes what the human gate is checking, not whether one exists. Even with both agents reading the same sourced answer, a person still confirms anything that creates a real commitment before either agent’s proposal becomes official. What a shared source removes is the specific failure this post has described, contradiction from divergent inputs. It doesn’t remove the broader need for a person to review and approve real changes, which is a separate, standing requirement regardless of how well-synced the agents’ inputs are. Giving coding agents real, current context closes the divergence problem. It doesn’t, and shouldn’t, replace the approval step that follows.

FAQ

Is this the same problem as one agent hallucinating?

No. Hallucination is a model generating something that was never true. This is two models each correctly reflecting a real but different source, with no mechanism telling either one that the other’s source has since diverged.

Would better prompting fix this?

No, because the problem isn’t in how either agent reasons about its input, it’s that the two inputs disagreed before either agent started. Better prompting doesn’t reconcile two genuinely different source documents.

How would a team even notice this is happening?

Usually only when the two pieces of work meet, in integration, in a review, or worse, in production, and someone notices the outputs don’t agree. That’s a late, expensive point to catch it compared to removing the divergence before either agent acted.

Does this only happen with two different agents, or can it happen with the same agent across sessions?

It can happen either way. The root cause is the same regardless: whatever’s being read has diverged from itself across two points in time or two agents, and nothing marked that it had.

Does a shared source make agents redundant with each other?

No. Multiple agents working from the same current answer can still do genuinely different, parallel work. What changes is that their outputs agree on the underlying facts, not that there’s less work to split between them.

See how your agents work from one checked answer instead of a stale ticket. Try Thor free.

Related Posts