What the orchestrator doesn't share is what the next agent gets wrong

Specialized agents are only as good as the context they receive. When critical knowledge fails to propagate across a workflow, each agent operates on a partial picture.

B

Balagei G Nagarajan

3 MIN READ


Abstract: a chain of vessels each passing a progressively smaller amount of liquid to the next

Key facts.

  • Lost-in-the-Middle research showed that language models dramatically underperform on information placed in the middle of long input contexts, even when that information is present and accurate, the same failure degrades every agent that receives a compressed summary of a previous agent's work (Liu et al., arXiv 2307.03172).
  • Barnett's seven failure points in RAG and agentic systems include "incomplete context assembly" as a distinct failure category, the retrieval succeeds, but the assembled context omits what the generation step needs (Barnett et al., arXiv 2401.05856).
  • NoLiMa benchmarked context faithfulness under compression and found that when documents are condensed to fit context windows, models miss relevant facts at significantly higher rates than when processing the full document, a direct analog to what happens when one agent summarizes for another (NoLiMa, arXiv 2502.05167).

Why orchestrators compress and why that's a problem

In a well-designed multi-agent workflow, the orchestrator receives the raw output from a research agent and passes it to a writing agent. In practice, raw output is often long, expensive to pass directly, and prone to overwhelming a downstream agent's context window. So the orchestrator summarizes. The summary omits the three exception cases the research agent found, because they didn't fit the main narrative. The writing agent produces a clean document. The document misses the exceptions. A customer relies on that document. The exceptions matter.

this is knowledge propagation failure: the information existed, was correctly identified, and was then stripped out before it reached the agent that needed it. No hallucination occurred. No tool call failed. The architecture did exactly what it was built to do. The design was wrong.

Funnel: full knowledge base at top, narrowing through Summarization, Handoff Compression, and Agent Context at bottom with labeled loss points

What propagates vs. what gets lost

Reliably propagatedTypically lost
Main narrative and primary conclusionEdge cases and exceptions
High-confidence findingsLow-confidence caveats and uncertainty signals
Structured data (tables, lists)Contextual qualifications and conditions
The most recent informationHistorical context referenced earlier in the session

VibeModel treats knowledge propagation as a first-class monitoring dimension. The Pattern Intelligence Layer checks whether the information required by each downstream agent is present in the context it receives, before that agent acts. The pattern that fails here's always the same: the wrong summary, passed confidently, at the wrong moment. That pattern is detectable before it becomes an incident.

Frequently asked questions

Should I just pass the full context instead of summarizing?
Where token budgets allow, yes. Where they don't, structure the handoff explicitly: instead of a free-text summary, pass a structured object that includes a main findings field, an exceptions field, a confidence level, and an "action required" flag. The downstream agent can skip what it doesn't need, but it can't act on what it never received.

How do I know what each downstream agent actually needs?
Design the handoff contract first, before you write either agent. Define the required fields, the optional fields, and the failure behavior when required fields are missing. this is the same discipline you would apply to any API contract, applied to inter-agent communication.


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.