Multi-Agent Instruction Conflict Arbitration Prompt

This prompt is for multi-agent system architects who need a deterministic, auditable process to resolve conflicts when two or more specialized agents receive contradictory instructions. The core job-to-be-done is producing a structured arbitration decision that declares which agent's instruction wins, justifies the decision based on a predefined authority hierarchy, and specifies safe handoff rules so the system does not silently execute conflicting directives. The ideal user is an AI platform engineer or technical lead responsible for agent coordination logic in a production system where agents have overlapping capabilities but different policy scopes—for example, a customer-facing agent that must prioritize safety policy over a backend data agent that prioritizes data freshness.

Use this prompt when you have a known agent authority hierarchy, a clear conflict to resolve, and a need for a machine-readable arbitration record that can be logged, audited, and fed into downstream execution logic. It is appropriate for systems where agent roles are stable and the conflict is between instructions, not between ambiguous user intents. Do not use this prompt for real-time user-facing clarification dialogs, for resolving conflicts between user requests and system policy (use the User Override vs System Policy Conflict Resolution Prompt instead), or for detecting hidden conflicts in system prompts before deployment (use the System Prompt Conflict Audit Prompt). This prompt assumes the conflict has already been detected and surfaced; it does not perform conflict discovery.

The prompt requires several structured inputs: an agent authority hierarchy with explicit precedence rules, the conflicting instructions from each agent, the context in which the conflict arose, and any relevant tool outputs or evidence. The output is a strict JSON arbitration record containing the winning instruction, a justification traceable to the hierarchy, handoff constraints, and a confidence score. Before shipping this prompt into production, you must validate that the output JSON conforms to the expected schema, test it against known conflict scenarios where the correct winner is unambiguous, and log every arbitration decision for audit review. In high-risk domains such as healthcare or finance, every arbitration decision must be routed to a human approval queue before execution, and the justification field must cite specific hierarchy rules rather than relying on model-generated rationalization.

This prompt template acts as a central arbiter in a multi-agent system. Its job is to receive a set of conflicting instructions from different specialized agents, evaluate them against a defined authority hierarchy and the system's core policies, and produce a binding arbitration decision. The template is designed to be wrapped in an API endpoint where a coordinator agent can submit conflicts and receive structured resolutions that downstream agents or orchestrators can execute. Before using this template, you must define your agent authority hierarchy, your non-negotiable safety and compliance policies, and the expected output schema for your arbitration decisions.

codeCopy
SYSTEM:
You are the Instruction Conflict Arbiter for a multi-agent system. Your sole function is to resolve contradictory instructions received from specialized agents. You do not execute tasks; you only decide which instruction takes precedence.

## ARBITRATION PROTOCOL
1.  **Receive Conflict Report:** You will be given a [CONFLICT_DESCRIPTION] containing the contradictory instructions and the IDs of the agents that issued them.
2.  **Consult Authority Hierarchy:** Resolve the conflict by strictly applying the following agent authority hierarchy. A higher-ranked agent's instruction always overrides a lower-ranked agent's instruction on its subject matter domain.
    [AGENT_AUTHORITY_HIERARCHY]
3.  **Apply Non-Negotiable Policies:** Regardless of the hierarchy, any instruction that violates one of the following core policies is automatically invalid. If all instructions violate policy, the default safe action is [DEFAULT_SAFE_ACTION].
    [NON_NEGOTIABLE_POLICIES]
4.  **Generate Arbitration Decision:** Produce a final decision in the specified [OUTPUT_SCHEMA] format.

## CONSTRAINTS
- Never fabricate an agent's authority. If an agent is not in the hierarchy, its instructions are ranked lowest.
- If the conflict is outside the domain of any specialized agent, flag it for [HUMAN_ESCALATION_QUEUE].
- Your reasoning must be traceable to a specific rule in the hierarchy or a specific non-negotiable policy.

USER:
**Conflict Report:**
[CONFLICT_DESCRIPTION]

**Output Schema:**
Generate your response strictly according to this JSON schema:
[OUTPUT_SCHEMA]

To adapt this template, start by replacing the [AGENT_AUTHORITY_HIERARCHY] placeholder with a concrete, ranked list of your agents and their scoped domains of authority (e.g., '1. SafetyAgent: authority over all PII redaction and content safety. 2. FinanceAgent: authority over transaction execution and refund policies.'). Next, populate [NON_NEGOTIABLE_POLICIES] with clear, binary rules that cannot be overridden by any agent (e.g., 'Never expose a user's full social security number.'). The [DEFAULT_SAFE_ACTION] should be a single, safe fallback instruction like 'Escalate to human operator and halt the workflow.' Finally, define a strict [OUTPUT_SCHEMA] for your application to parse, including fields like winning_agent_id, final_instruction, justification, and escalation_required. For high-risk deployments, always log the full [CONFLICT_DESCRIPTION] and the arbiter's output for audit and evaluation purposes.

The Multi-Agent Instruction Conflict Arbitration Prompt is not a standalone chat interface; it is a decision function inside an agent orchestration runtime. Wire it into your application as a synchronous or asynchronous call that fires when a conflict detector flags contradictory instructions between two or more specialized agents. The harness must supply the conflicting agent instructions, the current task context, the agent authority hierarchy, and any relevant tool outputs or user overrides. The prompt returns a structured arbitration decision—typically JSON—that the orchestrator uses to resolve the conflict, route work, or escalate to a human reviewer. Do not rely on the model to detect conflicts on its own; implement a separate conflict detection step (see the Multi-Directive Conflict Detection Prompt playbook) that triggers this arbitration prompt only when a collision is confirmed.

Build the harness with these concrete components: Input validation—reject calls where the agent authority hierarchy is missing, circular, or ambiguous. The hierarchy must be a strict partial order (e.g., safety_agent > compliance_agent > task_agent > user_override). Output validation—parse the model's JSON response and verify it contains required fields: arbitration_decision (which agent wins), justification, handoff_instructions, and escalation_flag. If the output fails schema validation, retry once with the validation error injected into the retry prompt. Retry logic—use exponential backoff with a maximum of two retries. On the second failure, log the full input-output pair and escalate to a human review queue. Logging—capture every arbitration call with a unique conflict_id, the agent instructions involved, the model's decision, the confidence score, and whether the decision was auto-applied or escalated. This log becomes your audit trail for governance reviews and priority inversion debugging. Model choice—use a model with strong instruction-following and structured output capabilities (e.g., GPT-4o, Claude 3.5 Sonnet). Avoid smaller or older models that may collapse the priority hierarchy under complex multi-agent scenarios. Tool use—this prompt does not call tools directly; it produces a decision that the orchestrator executes. However, the harness should expose the arbitration decision to downstream tool authorization checks so that a winning agent does not exceed its tool-use boundaries.

Before deploying, build a regression test harness that replays known conflict scenarios and verifies the arbitration decision matches expected precedence. Include adversarial cases where two agents claim equal authority, where a user override contradicts a safety policy, and where tool outputs disagree with system instructions. Measure decision consistency across multiple runs—if the model flips its arbitration more than 5% of the time on identical inputs, the prompt or the hierarchy needs tightening. Wire the escalation flag into your incident management system so that high-severity conflicts (e.g., safety vs. user intent) trigger immediate human review. Finally, version your agent authority hierarchy alongside your system prompts; a change in agent roles or precedence rules must trigger a re-evaluation of all arbitration test cases. Do not treat this prompt as fire-and-forget—it is a runtime policy enforcement point that requires the same operational rigor as your authorization and routing infrastructure.