Why your multi-agent system answers the same question differently in step 3 than in step 1

Loss of shared conversation history is not a memory quirk. It is a coordination failure that produces inconsistent behavior across a single workflow.

B

Balagei G Nagarajan

3 MIN READ


Abstract: a single conversation thread fragmenting into parallel diverging timelines, each coloring differently
Each agent starts with a snapshot of the world at the moment it was instantiated.
— from “Why your multi-agent system answers the same question differently in step 3 than in step 1”

Key facts.

  • MINJA showed that adversarial injection of just 5 memory entries into an agent's memory store significantly degrades planning and action quality, demonstrating how fragile shared memory is to even small inconsistencies (arXiv 2503.03704, 2025) (MINJA, arXiv 2503.03704).
  • Lost-in-the-Middle research showed that models routinely fail to use information placed in the middle of long contexts, in a multi-agent workflow where early session history appears in the middle of later agents' contexts, the early context is systematically underweighted (Liu et al., arXiv 2307.03172).
  • Barnett's RAG failure taxonomy identifies "outdated or stale information in context" as a distinct failure point, the same category applies when an agent's view of the shared conversation is stale relative to another agent's view (Barnett et al., arXiv 2401.05856).

How the inconsistency emerges without any obvious failure

At step 1, the orchestrator receives a full session context and determines the customer's account tier is "Enterprise." At step 3, a second agent receives a summarized handoff that describes the customer as "a large account", the tier label was dropped in the summary. That agent applies standard pricing. The customer expected Enterprise pricing. Both agents were correct given their context. The context was inconsistent.

This pattern appears constantly in workflows where the conversation history is maintained per-agent rather than in a shared store. Each agent starts with a snapshot of the world at the moment it was instantiated. If the shared world changes, or if the snapshot was incomplete, subsequent agents operate on a different version of history. There is no error. The workflow completes. The output is inconsistent.

Timeline: shared session with branching agent views per step, showing where each agent's context diverges from the canonical history

Architectural patterns that prevent context divergence

DivergesStays consistent
Context passed as free-text summary per agentContext maintained in typed, versioned shared store
Each agent summarizes for the nextEach agent reads from canonical store, writes delta
History truncated to fit context windowHistory indexed; agents query what they need
No consistency check between agentsReconciliation step when agents' facts conflict

Divergent memory makes step 3 differ from step 1 as a class; a newer model inherits it, with no canonical version until rework. (arXiv:2503.03704)

VibeModel detects context divergence as a pattern: when two agents in the same workflow make claims about the same entity that contradict each other, the Pattern Intelligence Layer flags it before those claims drive conflicting actions. Consistent context is not an LLM problem, it is an architecture problem. The solution is an architecture, not a better prompt.

Frequently asked questions

Should every agent in the workflow have access to the full session history?
Selective access works better than full access. Full history overwhelms context windows and introduces Lost-in-the-Middle degradation. Structure the shared store so each agent queries only the fields relevant to its task, and always receives the canonical value for those fields rather than a summary of earlier conversation about them.

What if agents are running in parallel?
Parallel agents need a merge step before any of their outputs are consumed by a downstream agent. The merge step reconciles their views of any shared facts and produces a single canonical record. Without the merge, parallel execution guarantees context divergence.


Share this post

Join the discussion

Have a take, a war story, or a question? Sign in with GitHub to comment and react. Comments are powered by GitHub Discussions, ad-free and yours to moderate.

Continue Reading

Find where your agent breaks, before you build it

Faultmap maps where your agent will fail from the goal and your data, then hands you the first test suite it has to pass.