Agent Handoff Summary Generation Prompt for Delegated Tasks

This prompt is for orchestration engineers who need a structured, machine-readable summary when a sub-agent completes a delegated task. The core job-to-be-done is to force the model to extract results, confidence, unresolved items, assumptions, and next-step recommendations into a single, validated payload. This summary must be consumable by downstream agents, a supervisor agent, or a human reviewer without replaying the entire execution trace. Use this prompt inside an orchestrator's handoff pipeline: after a sub-agent returns its final output, before that output is merged into the parent workflow.

The ideal user is an AI platform engineer or workflow builder integrating multiple specialized agents. Required context includes the original delegated task, the sub-agent's complete raw output, and any execution metadata like tool-call logs or error traces. The prompt is designed for asynchronous, structured handoffs where the receiving system needs to programmatically decide the next step—whether to merge the result, escalate for human review, or trigger a re-decomposition. It is not suitable for live conversation summarization, user-facing chat history, or tasks where the sub-agent's raw output is already a complete final answer for an end user.

Do not use this prompt when the sub-agent's output is a final, user-ready artifact that requires no further processing. Avoid it in low-latency, real-time chat systems where the overhead of generating a structured handoff payload adds unacceptable delay. It is also inappropriate for tasks where the sub-agent's internal reasoning trace is the primary artifact needed for debugging; in those cases, use a trace logging prompt instead. Before implementing, ensure your orchestration framework can parse and act on the structured output schema, and plan for validation failures by defining a retry or fallback path.

This template produces a structured handoff payload that downstream agents or human reviewers can consume without replaying the entire sub-task execution. It forces the model to report results, confidence, unresolved items, assumptions, and next-step recommendations in a consistent shape. Use this prompt in your orchestrator's handoff generation step after a sub-agent returns its raw output but before that output is passed to the next agent in the chain.

textCopy
You are generating a structured handoff summary for a completed sub-task. Your output will be consumed by another agent or a human reviewer who needs to understand what happened, what was produced, what remains unresolved, and what should happen next.

## INPUT
Sub-task ID: [SUB_TASK_ID]
Sub-task Description: [SUB_TASK_DESCRIPTION]
Assigned Agent Role: [AGENT_ROLE]
Original Input Contract: [INPUT_CONTRACT]
Expected Output Contract: [OUTPUT_CONTRACT]
Raw Agent Output: [RAW_AGENT_OUTPUT]
Execution Metadata (tool calls, duration, retries): [EXECUTION_METADATA]

## CONSTRAINTS
- Do not omit any section of the output schema.
- If a field has no value, use null or an empty array as appropriate, but never drop the field.
- Confidence scores must be between 0.0 and 1.0 with a brief justification.
- Unresolved items must include a severity level: blocker, high, medium, or low.
- Assumptions must be stated explicitly; do not bury them in narrative text.
- Next-step recommendations must include a recommended action type: retry, escalate, handoff, complete, or await_input.

## OUTPUT_SCHEMA
{
  "handoff_summary": {
    "sub_task_id": "string",
    "status": "completed | partial | failed | timed_out",
    "result": {
      "output": "object | null",
      "matches_contract": "boolean",
      "contract_violations": ["string"]
    },
    "confidence": {
      "score": "number",
      "justification": "string"
    },
    "unresolved_items": [
      {
        "item": "string",
        "severity": "blocker | high | medium | low",
        "impact_on_downstream": "string"
      }
    ],
    "assumptions_made": ["string"],
    "evidence_citations": ["string"],
    "next_steps": [
      {
        "action": "string",
        "action_type": "retry | escalate | handoff | complete | await_input",
        "target_agent_or_role": "string | null",
        "rationale": "string"
      }
    ],
    "information_loss_risk": "none | low | medium | high",
    "information_loss_details": "string | null"
  }
}

## INSTRUCTIONS
1. Compare the raw agent output against the expected output contract. Flag any missing fields, type mismatches, or schema violations.
2. Extract explicit assumptions the agent made during execution. If the agent did not state assumptions, inspect the output for implicit ones and surface them.
3. Identify any items the agent flagged as unresolved, uncertain, or requiring further input. Assign a severity based on whether the unresolved item blocks downstream work.
4. Assess whether information was lost during the sub-task execution (e.g., truncated context, omitted details, compressed summaries). Rate the risk and explain.
5. Recommend concrete next steps. If the output is complete and valid, recommend handoff to the next agent. If incomplete, recommend retry with specific adjustments or escalation to a human.
6. Output only valid JSON. No markdown fences, no commentary outside the JSON object.

Adapt this template by adjusting the output schema fields to match your agent framework's handoff contract. If your orchestrator expects additional fields such as latency metrics, cost breakdowns, or tool-call traces, add them to the schema and update the instructions accordingly. For high-risk domains such as healthcare or finance, add a requires_human_review boolean field and set it to true whenever confidence is below 0.85 or unresolved items include a blocker. Always validate the generated JSON against your schema before passing it to the next agent; malformed handoff payloads are the most common cause of silent failures in multi-agent pipelines.

This prompt is designed to be called by an orchestrator immediately after a delegated sub-task completes. The orchestrator should pass the sub-agent's raw output, the original task contract, and any execution metadata into the prompt's [SUB_TASK_OUTPUT], [ORIGINAL_TASK_CONTRACT], and [EXECUTION_METADATA] placeholders. The resulting handoff payload becomes the canonical record consumed by downstream agents, human reviewers, or audit systems. Do not treat this as an optional logging step—it is the interface contract between agents in a multi-agent pipeline.

Wire the prompt into your agent framework as a post-execution hook that fires before the orchestrator marks a sub-task as complete. Implement a validation gate that checks the output against the [OUTPUT_SCHEMA] before accepting it: confirm all required fields are present, confidence scores fall within 0.0–1.0, unresolved items are explicitly listed (even if empty), and next-step recommendations are actionable. If validation fails, retry once with the validation errors injected into [CONSTRAINTS] as explicit fix instructions. After a second failure, escalate to a human reviewer with the raw sub-agent output and both failed handoff attempts attached. Log every handoff payload—accepted or rejected—with a trace ID that links back to the original task decomposition so you can reconstruct the full agent decision chain during post-mortems or audits.

For model choice, prefer a model with strong instruction-following and structured output capabilities (GPT-4o, Claude 3.5 Sonnet, or equivalent). Set temperature to 0 or near-zero to maximize schema adherence. If your orchestrator supports tool calling, define the handoff schema as a structured tool and require the model to call it rather than relying on free-text JSON generation—this dramatically reduces parsing failures. When the sub-task domain is high-risk (healthcare, finance, legal), add a human review flag to the handoff payload that triggers mandatory approval before downstream agents can consume the result. Never allow an unvalidated handoff payload to flow into the next agent in the chain.

Common failure modes to instrument for: the model omits unresolved items because the sub-agent claimed full success, confidence scores don't match the actual output quality, assumptions are listed vaguely ('made reasonable assumptions'), and next-step recommendations are generic ('proceed to next step'). Add eval assertions that check for specific, falsifiable statements in each field. Track information loss by comparing the sub-agent's raw output token count to the handoff summary token count—if the compression ratio exceeds 10:1 without explicit justification, flag for review. Wire these metrics into your observability stack so you can detect handoff degradation before it corrupts downstream agent behavior.