How do you build an agent that plans well with incomplete or conflicting information?

Real inputs are partial, stale, and contradictory. An agent that assumes clean information plans confidently off the wrong facts. The reliable one plans for the mess.

B

Balagei G Nagarajan

3 MIN READ


An agent planning over fragmented and conflicting information shards, resolving them before acting

Key facts.

  • ConflictBank assembles 7,453,853 claim-evidence pairs and 553,117 QA pairs to study knowledge conflicts across misinformation, temporal and semantic types, a major and rarely-studied source of hallucination. source
  • Conflicts arise both in retrieved information and within the model's own encoded knowledge and the two can interact. source
  • An agent with no conflict-handling logic silently resolves contradictions by internal weighting you cannot see or control. source
  • ConflictBank shows knowledge conflict is a top failure source; a stronger model acts more fluently on the fact it weighted, the retry yours. (arXiv:2408.12076)

Why does conflicting information break planning so quietly?

Because the agent resolves the conflict without telling you and usually without knowing it did. When two facts disagree, a stale value and a current one, a source that says yes and one that says no, the model does not stop and flag the contradiction. It blends or picks, weighting by familiarity or recency or nothing in particular and then plans confidently off the result. ConflictBank's scale makes the point that this is not rare: misinformation conflicts, temporal conflicts where the data aged and semantic conflicts where sources mean different things by the same words are pervasive in real inputs. The agent meets them constantly, resolves them invisibly and builds a plan on a fact it chose by accident.

Incomplete information fails the same quiet way. The agent does not register a gap as a gap. It fills it with a plausible assumption and proceeds, so a missing fact becomes an invented one and the plan is built on a number nobody supplied. In both cases the failure is that the agent treated messy input as clean and never surfaced the mess.

Three conflict types feeding a resolution gate that flags, prioritizes, or escalates before planning

What does graceful handling look like?

Make the agent treat its inputs as possibly partial and contradictory and handle that explicitly. Detect when sources conflict and resolve by an explicit rule, prefer the authoritative source, prefer the current value or escalate when the conflict is material and unresolvable. Detect when a required fact is missing and ask or flag rather than invent. Where information changes mid-task, re-check it rather than trusting the first read. The agent does not need perfect data. It needs to know when its data is imperfect and a defined way to act on that, instead of plastering over the gaps and contradictions with confidence.

Input handlingOn conflict or gap
Assume clean inputsSilently picks or invents, plans on it
Detect and resolve explicitlyFlags, prioritizes by rule or escalates

Modeling those resolution patterns is part of what VibeModel does as the Pattern Intelligence Layer. We model the patterns of conflicting and incomplete information and how a reliable plan resolves them, so the agent surfaces the mess and acts on it deliberately instead of hiding it inside a confident plan.

Frequently asked questions

Can't retrieval just give the agent clean facts?
No. ConflictBank shows conflicts arise in retrieved information and in the model's own knowledge and the two interact. Clean retrieval is not enough.

How should the agent resolve a conflict?
By an explicit rule you set: authoritative source, most recent value or escalation when material. Not by invisible internal weighting.

What about missing information?
Detect the gap and ask or flag. The failure is filling it with a confident assumption nobody supplied.


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.