An AI agent can gather more evidence than a person would usually open by hand. It can search a knowledge base, inspect a ticket history, compare policy pages, read logs, and bring back a tidy answer. That speed is useful, but it creates a quiet problem: the agent may find sources that disagree. A stale policy says one thing. A newer document says another. A customer record contradicts a support note. A code comment describes behavior that the tests no longer prove. A web page looks current but repeats an old claim.
Source conflict resolution is the discipline of deciding what the agent should do when evidence does not line up. The goal is not to force every source into a single confident answer. The goal is to keep disagreement visible long enough for the workflow to route it correctly.
This topic sits between AI Agent Knowledge Bases , AI Agent Source Provenance , and AI Agent Output Verification . A knowledge base helps the agent find trusted material. Provenance keeps evidence attached to the work. Verification checks the finished output. Conflict resolution handles the awkward middle, where the agent has found material but cannot honestly treat it as settled.
Disagreement is a signal, not a failure
Many weak agent workflows treat conflict as an inconvenience. The agent is asked for an answer, so it smooths the evidence into something that sounds reasonable. It may average positions, prefer the most recent-looking page, or write a vague sentence that hides the disagreement. The final result feels calm, but the calm is misleading.
A conflict often tells you something important about the workflow. It may reveal that the knowledge base has stale material. It may show that two teams use different definitions for the same term. It may expose a policy exception that was never folded back into the official source. It may show that a tool returns cached data while another returns live state. In software work, it may show that documentation and implementation have drifted apart.
The agent should be allowed to say that the evidence is not ready for action. That does not make the run useless. A clear conflict report may be the most valuable artifact the agent can produce. It tells the human owner where the system needs repair before more work can be delegated.
Authority should be named before the run
The easiest conflict to resolve is the one whose hierarchy is already known. If a current policy page outranks old training material, the agent should know that before it reads both. If a production record outranks a copied spreadsheet, the route should say so. If a signed approval record outranks a chat message, the tool contract should make that distinction visible.
Instruction hierarchy is not only about prompts. AI Agent Instruction Hierarchies explains how goals, policies, and evidence need different authority. Source conflict resolution applies the same habit to materials. The agent should not decide from vibes which source is official. It should receive source roles, freshness signals, owners, and stop conditions.
This matters because many sources look authoritative on the surface. A polished internal page can be abandoned. A spreadsheet can have the right column names and the wrong data. A vendor page can sound official while describing a product version the team does not use. A policy excerpt inside a ticket can be accurate for that ticket but not general enough for the next one.
Authority is operational, not decorative. It should answer a plain question: if these two sources disagree, which one may govern the result, and when must the agent ask instead of choosing?
Freshness is not the same as truth
Agents often lean on recency when resolving conflict. That instinct is useful but incomplete. A newer source may be a draft, a copied mistake, or a local exception. An older source may be the governing policy because it has not changed. A timestamp helps, but it does not settle authority by itself.
AI Agent Knowledge Freshness covers the broader maintenance problem. In a live run, the agent needs a practical freshness posture. It should notice effective dates, revision histories, source owners, and references to superseded material. It should also notice when those signals are missing.
Imagine a support agent reading a return policy, a regional exception note, and a recent ticket where a supervisor allowed something different. The recent ticket is real evidence, but it may not be policy. The agent can use it to explain uncertainty or ask for review, but it should not silently generalize it into a new rule. The same pattern appears in codebases. A recent workaround in one file does not necessarily define the architecture. It may be a local patch waiting for cleanup.
Good conflict handling keeps freshness and authority separate. It asks what is current, what is official, what is local, and what is merely nearby.
The agent needs a conflict artifact
When disagreement matters, the agent should leave a small artifact that preserves the shape of the conflict. It does not need to be a courtroom brief. It should identify the question, the sources read, the point of disagreement, the source roles, the likely governing source if one exists, and the reason the agent did or did not proceed.
This artifact is different from a final answer. A final answer tries to satisfy the request. A conflict artifact explains why the request cannot be safely satisfied yet, or why it can only be satisfied with a caveat. AI Agent Artifact Design is useful here because conflict artifacts are work products. They should be reviewable without forcing the human to replay the entire run.
The artifact should avoid dramatic language. Most conflicts are ordinary maintenance issues. A stale page, a missing owner, a partial record, or an ambiguous exception is not an incident by itself. The agent should preserve the evidence, name the uncertainty, and route the question to the right owner.
Some conflicts should stop action
Not every conflict deserves the same response. If two public sources disagree about a historical detail in a low-stakes summary, the agent may cite both or choose the better-supported one. If two internal sources disagree about whether a customer can receive a refund, the agent should not issue the refund alone. If documentation and tests disagree about a code path, the agent may prepare a patch, but it should make the mismatch visible in the handoff.
The stop condition depends on consequence. Conflicts around money, permissions, legal commitments, private data, external messages, production changes, or safety-sensitive claims should usually block autonomous action. Conflicts around phrasing, low-risk classification, or draft organization may only require a note.
This connects directly to AI Agent Approval Scopes . Approval is weaker when the reviewer cannot see that the source base was conflicted. A reviewer may approve a proposed action for one reason and reject it for another. The agent should not bury the disagreement inside a polished recommendation.
Tool outputs should keep source roles intact
Conflict resolution becomes harder when tools flatten evidence. A search tool that returns snippets without source type, date, owner, or confidence makes every result look similar. A record lookup that blends system data and user notes into one paragraph invites the agent to treat everything as equally authoritative. A browser tool that strips page metadata removes useful context.
AI Agent Tool Contracts should therefore support conflict handling. Tools can label sources as policy, draft, customer-provided, external, generated, archived, or live system state. They can return timestamps and source identifiers. They can distinguish not found from permission denied and stale cache from live response. These details feel boring until a conflict appears. Then they become the difference between a useful stop and a confident guess.
The agent should also be careful with untrusted material. A web page, email, ticket, or document can contain instructions that try to steer the run. AI Agent Prompt Injection explains the authority problem. Conflict resolution depends on the same boundary. Content can be evidence without becoming a command.
The mature habit
A strong agent system does not pretend all evidence will agree. It designs for disagreement. It names source roles, preserves provenance, separates freshness from authority, gives the agent a conflict artifact, and defines when conflict blocks action.
That habit makes the agent more useful, not less. Instead of producing a smooth answer that hides weak foundations, the agent can tell the team where the foundations need attention. It can still summarize, draft, compare, and recommend. But when the evidence disagrees, it keeps the disagreement in view long enough for the right person or rule to resolve it.
