Escalation Context Packaging Prompt for Human Handoff

This prompt is designed for operations teams and platform engineers who need to convert raw agent logs, tool outputs, and partial results into a structured, human-readable escalation brief. The core job-to-be-done is producing a decision-ready package—not a raw dump of agent state—when an autonomous agent hits a confidence threshold, capability boundary, policy trigger, or explicit human-approval gate and must hand off to a human reviewer. The ideal user is an SRE, support operations lead, compliance analyst, or platform engineer responsible for designing the handoff surface between autonomous agents and human review queues. Required context includes the agent's original task, actions taken, tool outputs, evidence collected, confidence scores, and the specific decision or approval being requested from the human reviewer.

Use this prompt in workflows where the human reviewer lacks full session context and needs a structured brief to make a fast, accurate decision. Concrete examples include: a customer support agent escalating a billing dispute that exceeds its refund authority, a code-review agent flagging a security-sensitive change that requires human sign-off, an incident response agent handing off to an on-call engineer after exhausting its automated remediation playbook, and a compliance agent surfacing a regulatory flag that needs documented human review. In each case, the prompt produces a package with a problem summary, agent actions taken, evidence collected, pending decisions, and recommended next steps. The output should be validated for clarity (can a human understand the situation in under 60 seconds?), completeness (are all required decision inputs present?), and actionable framing (does the human know exactly what they are being asked to do?).

Do not use this prompt for real-time chat where latency is critical and the human already has full context—adding a structured brief in that scenario slows down the interaction without improving decision quality. Similarly, avoid this prompt for low-stakes tasks where the cost of structuring the handoff exceeds the cost of a wrong decision, or for fully automated retry loops where the agent should self-correct rather than escalate. If the escalation involves regulated or high-risk domains such as healthcare, finance, or safety-critical infrastructure, the prompt output must include explicit source grounding, uncertainty language, and a mandatory human approval step with an audit trail. Before deploying, test the prompt against a golden set of escalation scenarios and measure whether human reviewers make faster and more accurate decisions with the structured brief than with raw agent logs.

This prompt template is designed to be pasted directly into your orchestration layer when an agent determines it must escalate to a human operator. It takes raw agent state—conversation history, tool outputs, partial results, and confidence scores—and compresses it into a structured brief that a human can act on within seconds. The template uses square-bracket placeholders that your runtime must populate before calling the model. Do not ship this prompt with unresolved placeholders; every bracket must be replaced by live data from your agent execution context.

codeCopy
SYSTEM:
You are an escalation context packager. Your job is to convert raw agent execution data into a concise, actionable human handoff brief. Follow these rules strictly:

1. Write for a skilled human operator who has 30 seconds to understand the situation.
2. Lead with the decision the human needs to make, not a chronological narrative.
3. Include only information the human cannot get from other systems.
4. Mark any claim you are uncertain about with [CONFIDENCE: LOW/MEDIUM/HIGH].
5. If the agent took actions that modified external state, list them in reverse chronological order.
6. Never recommend an action that exceeds the operator's authority or violates [POLICY_DOCUMENT].

OUTPUT_SCHEMA:
{
  "escalation_id": "string, the idempotency key for this escalation",
  "urgency": "low | medium | high | critical",
  "decision_required": "string, one sentence describing the decision the human must make",
  "deadline": "string or null, ISO 8601 timestamp if time-sensitive",
  "summary": "string, 2-3 sentence summary of what happened and why escalation is needed",
  "agent_actions_taken": [
    {
      "timestamp": "ISO 8601",
      "action": "string, what the agent did",
      "result": "string, outcome or state change",
      "confidence": "low | medium | high"
    }
  ],
  "evidence_collected": [
    {
      "source": "string, where the evidence came from",
      "finding": "string, what the evidence shows",
      "relevance": "string, why this matters for the decision"
    }
  ],
  "pending_items": ["string, things the agent could not resolve"],
  "recommended_next_steps": [
    {
      "step": "string, what the human should consider doing",
      "rationale": "string, why this step is recommended",
      "risk_if_skipped": "string, consequence of not taking this step"
    }
  ],
  "context_snapshot": {
    "user_id": "string",
    "session_id": "string",
    "agent_id": "string",
    "agent_capabilities_used": ["string"],
    "agent_capabilities_exhausted": ["string"]
  }
}

CONSTRAINTS:
- Do not include raw conversation transcripts. Summarize.
- Do not include PII unless it is required for the decision and permitted by [POLICY_DOCUMENT].
- If the agent's confidence in its own actions is below medium, flag the entire escalation as high urgency.
- If [RISK_LEVEL] is "high" or "critical", append a warning field to the output: {"warning": "string, specific risk the human must verify before acting"}.

USER:
Package the following agent execution context into the escalation brief:

[AGENT_EXECUTION_CONTEXT]

Where [AGENT_EXECUTION_CONTEXT] is a JSON object containing:
- conversation_summary: string
- tool_calls: array of {tool_name, input, output, timestamp, success}
- partial_results: object or null
- confidence_scores: object mapping action IDs to 0.0-1.0
- unresolved_items: array of strings
- agent_capabilities: array of strings
- session_metadata: {user_id, session_id, agent_id, start_time}
- policy_violations_flagged: array or null

Adaptation notes: Replace [POLICY_DOCUMENT] with a reference to your organization's escalation policy, or inline the relevant rules directly. Replace [RISK_LEVEL] with a value from your runtime risk classifier—if you don't have one, default to "medium" and add a human review gate. The [AGENT_EXECUTION_CONTEXT] placeholder expects a structured JSON blob; your orchestration layer must assemble this from agent logs, tool call records, and session state before invoking the prompt. If your agent framework doesn't produce confidence scores, populate the field with a default of 0.5 and flag the escalation for human review. Test this prompt with at least 10 real escalation scenarios before deploying, and validate that the output JSON parses correctly in your downstream ticketing or handoff system.

The escalation context packaging prompt is not a standalone artifact; it is a component inside a larger handoff pipeline. The prompt should be invoked only after an agent has determined that escalation is required—based on confidence thresholds, capability gaps, policy triggers, or explicit user requests. The orchestration layer must supply the prompt with a structured input payload containing the original user request, the agent's action log, tool outputs, collected evidence, and the specific reason for escalation. Without this structured input, the prompt will produce a vague summary that fails the human reviewer's need for actionable context.

Wire the prompt into a validation pipeline that checks the output before it reaches the human queue. At minimum, validate that the output contains all required sections: problem summary, actions taken, evidence collected, pending decisions, and recommended next steps. Use a schema validator or a secondary LLM call with a strict rubric to confirm that each section is populated and that the output does not exceed the maximum length for your review interface. If validation fails, retry the prompt once with the validation errors appended as feedback. If the second attempt also fails, route the raw agent log plus a system-generated stub summary to the human queue with a flag indicating incomplete packaging. Log every validation failure for prompt improvement cycles.

The human review queue should receive the packaged escalation context alongside metadata that enables prioritization and routing. Attach the escalation reason code, the originating agent ID, the session ID, a severity or urgency score, and a unique escalation ID. This metadata lets the queue system sort by urgency and route to the correct team. Do not rely on the prompt output alone to carry routing information; the orchestration layer should attach it as structured fields. For high-risk domains such as healthcare, finance, or security operations, require a human acknowledgment within a defined SLA and escalate again if no acknowledgment occurs. Store the full escalation payload—input, prompt version, output, validation results, and reviewer action—as an audit record for governance and prompt performance analysis.

Model choice matters here. The prompt requires strong instruction-following and structured output generation. Use a model with reliable JSON mode or function-calling support if you want the output in a machine-readable format for downstream processing. If the output is destined for a human-readable ticket or chat interface, a model with strong summarization and formatting capabilities is sufficient. Avoid small or quantized models for this task; incomplete or hallucinated summaries in an escalation context can cause the human reviewer to make decisions on incorrect information. Test the prompt against a golden dataset of known escalation scenarios and measure whether human reviewers can make correct decisions faster with the packaged context than without it.

The most common production failure mode is context omission: the prompt receives incomplete agent logs or missing tool outputs and produces a summary that looks plausible but lacks critical evidence. Mitigate this by validating the input payload before invoking the prompt. Check that required fields are present and that evidence references are not empty. If the input is incomplete, do not invoke the prompt; instead, send a partial-context escalation with explicit warnings about what is missing. The second failure mode is over-summarization, where the prompt compresses technical details that the human reviewer needs. Set explicit length and detail constraints in the prompt template, and tune these against reviewer feedback. Start with a minimum detail requirement per section rather than a maximum token limit.