Agent Output Synthesis from Conflicting Sources Prompt Template

This prompt is designed for system designers and orchestration engineers who must produce one coherent, trustworthy output from multiple specialized agents that have produced conflicting results. The core job-to-be-done is synthesis: you have already run a conflict detection step and now need a single response that preserves areas of agreement, explicitly surfaces contested points, and attributes every claim to its source agent. The ideal user is building a production multi-agent pipeline where downstream consumers—whether they are other agents, an API response, or a human reviewer—cannot act on raw disagreement. You should use this prompt when you have agent outputs, agent identifiers, and a shared evidence context ready to inject as [AGENT_OUTPUTS], [AGENT_IDS], and [SHARED_EVIDENCE].

Do not use this prompt when agents have not yet produced their individual outputs, when a single agent is authoritative by design, or when the disagreement is purely about formatting rather than substance. This prompt is also inappropriate for real-time arbitration where latency is critical and a simpler majority-vote or confidence-weighted selection would suffice. The prompt assumes that conflict detection has already identified a substantive disagreement; if you skip that step, the synthesis will attempt to reconcile outputs that may not actually conflict, wasting tokens and potentially introducing confusion. Before wiring this into your pipeline, confirm that you have a structured conflict report or at minimum a set of divergent agent outputs with clear identifiers. If your agents produce outputs in incompatible schemas, run the Agent Output Normalization Before Arbitration prompt first to align fields, units, and terminology.

The primary risk in synthesis is misrepresentation: the synthesizer may falsely claim agreement where disagreement exists, attribute a claim to the wrong agent, or introduce new information not present in any source output. To mitigate this, the prompt template includes explicit instructions to preserve disagreement, attribute every claim, and abstain when evidence is insufficient. In high-stakes domains such as healthcare, finance, or legal review, you must pair this prompt with a human review step and log the synthesis output alongside the original agent outputs for audit. The next section provides the copy-ready prompt template with placeholders you can adapt to your agent identities, output formats, and evidence context.

This template is the core instruction set for an LLM acting as a synthesis engine. It receives the original user query, the outputs from all participating agents, and a shared evidence payload. The prompt forces the model to produce a structured output that does not silently drop disagreements. Use it when you have two or more agent outputs that conflict on facts, structure, or conclusions and you need a single, auditable response for a downstream system or human reviewer.

textCopy
You are an output synthesis engine. Your job is to produce a single, coherent response from multiple agent outputs that may conflict.

## INPUTS
- Original User Query: [USER_QUERY]
- Agent Outputs (with agent identifiers): [AGENT_OUTPUTS]
- Shared Evidence (source documents or data all agents had access to): [SHARED_EVIDENCE]

## OUTPUT SCHEMA
Return a valid JSON object with the following structure:
{
  "synthesized_answer": "string (the best coherent answer you can construct)",
  "areas_of_agreement": ["string (points all agents agree on)"],
  "contested_points": [
    {
      "point": "string (the specific claim or value in dispute)",
      "positions": {
        "[AGENT_ID]": "string (that agent's position)"
      },
      "evidence_alignment": "string (which position is best supported by shared evidence, or 'no clear support')",
      "synthesis_choice": "string (which position was used in the synthesized answer and why)"
    }
  ],
  "unresolved_differences": ["string (disagreements that could not be resolved and were excluded from the synthesized answer)"],
  "confidence": "high|medium|low (your confidence in the synthesized answer)",
  "escalation_recommended": true|false
}

## CONSTRAINTS
1. Never fabricate agreement. If agents disagree, record the disagreement in `contested_points`.
2. Attribute every position to its source agent using the agent identifiers provided in [AGENT_OUTPUTS].
3. Prefer positions supported by [SHARED_EVIDENCE]. If evidence is absent or ambiguous, state that explicitly.
4. If no synthesis is possible without misrepresenting an agent, set `synthesized_answer` to an explanation of the deadlock and set `escalation_recommended` to true.
5. Do not introduce new facts, data, or claims not present in [AGENT_OUTPUTS] or [SHARED_EVIDENCE].
6. If [RISK_LEVEL] is 'high', set `escalation_recommended` to true for any unresolved factual dispute.

## RISK LEVEL
[RISK_LEVEL]

Adapt this template by replacing the square-bracket placeholders with your application's runtime values. [AGENT_OUTPUTS] should be a structured object mapping agent identifiers to their full output strings. [SHARED_EVIDENCE] is the common ground truth all agents received—this is critical for evidence alignment checks. [RISK_LEVEL] should be set to 'high' for regulated, financial, clinical, or safety-critical workflows, which will force escalation on any unresolved factual dispute. Before deploying, validate that the output JSON conforms to the schema using a programmatic validator. Run eval checks for hallucinated agreement (where the model claims consensus that doesn't exist in the inputs) and misattribution (where a position is assigned to the wrong agent). For high-risk domains, route any output with escalation_recommended: true or confidence: low to a human review queue with the full synthesis payload.

The synthesis prompt is not a standalone artifact; it is a component inside a larger arbitration pipeline. The typical wiring pattern places this prompt after a conflict detection step and before a human review or escalation step. The application layer is responsible for collecting the conflicting agent outputs, normalizing them into the [AGENT_OUTPUTS] placeholder format, injecting the shared evidence context into [SHARED_EVIDENCE], and enforcing the [OUTPUT_SCHEMA] contract. Do not pass raw, unnormalized agent responses directly into this prompt—schema mismatches between agent outputs will cause the synthesizer to hallucinate structure rather than flag it.

Validation and retry loop: The synthesized output must be validated against the expected schema before it is accepted. At minimum, validate that every claim in the agreed_facts and contested_points arrays includes a non-empty source_agents list and that no agent is cited for a claim it did not make. If validation fails, retry the prompt once with the validation error appended to [CONSTRAINTS]. If the second attempt also fails, escalate to a human reviewer with the raw agent outputs and the failed synthesis attempts. For high-risk domains, add a hallucination detection check: extract all factual claims from the synthesis and verify each against [SHARED_EVIDENCE] using a separate fact-checking prompt. Claims not grounded in evidence should be removed or flagged before the synthesis reaches a downstream consumer.

Model choice and latency: This prompt benefits from models with strong reasoning and instruction-following capabilities. For production pipelines, prefer GPT-4o, Claude 3.5 Sonnet, or equivalent. Avoid smaller or faster models for arbitration tasks—the cost of a wrong synthesis (misrepresenting agent agreement, fabricating consensus) is far higher than the latency savings. If latency is critical, consider running the synthesis prompt in parallel with a lightweight agreement check that can short-circuit the pipeline when all agents produce identical outputs. Logging and audit: Every synthesis run should produce an audit record containing the input agent outputs, the shared evidence, the synthesized result, the validation outcome, and the retry count. This audit trail is essential for debugging misrepresentations and for governance reviews.

Integration with agent frameworks: When wiring this into LangGraph, CrewAI, or custom orchestrators, treat the synthesis step as a dedicated node with explicit input and output schemas. The node should receive a typed ConflictReport from the upstream conflict detector and emit a typed SynthesisResult. Downstream nodes should only consume the SynthesisResult, never the raw agent outputs, to prevent accidental bypass of the arbitration layer. If the synthesis node fails or escalates, the orchestrator must halt the pipeline—do not fall back to a single agent's output silently. That pattern creates the illusion of resolution while hiding unresolved conflicts from users.