Handoff Summary Generation Prompt Template

This prompt is for platform engineers and AI architects building compound AI systems where work must move between specialized sub-agents. Use it when an orchestrator needs to generate a structured, machine-readable summary of a sub-agent's completed work, pending items, active constraints, and relevant context before transferring control to another agent. The output is designed to be consumed by a downstream agent's system prompt or context window, not by an end user. This prompt assumes you already have a defined handoff trigger and a known receiving agent with a declared capability manifest.

The ideal deployment scenario involves an orchestrator agent that has just received a termination signal from a sub-agent. Before invoking the next agent in the chain, the orchestrator calls this prompt with the raw sub-agent output, the original task assignment, and the receiving agent's capability manifest. The prompt's primary job is to prevent context contamination—it must filter out internal reasoning traces, tool call artifacts, and role-specific instructions that are irrelevant or dangerous for the receiving agent. For example, if a 'Code Analysis Agent' hands off to a 'Documentation Agent,' the summary must retain the API surface and logic flow but strip out linting configurations and test harness details that the Documentation Agent has no permission or need to see.

Do not use this prompt for user-facing summaries, for single-agent workflows, or when the receiving agent's role and permissions are unknown. It is also inappropriate when the handoff requires full conversational history preservation without pruning, as this prompt's core function is to reduce and restructure context. Before implementing, ensure you have a validated Role Transition Validation Prompt in place to authorize the handoff, and a Context Contamination Detection Prompt ready to scan the output before it enters the downstream agent's context. The biggest production risk is a summary that accidentally leaks a prior agent's system instructions or tool outputs into a less-privileged agent, creating a privilege escalation path.

This prompt template produces a structured handoff summary when work moves from one specialized sub-agent to another. It captures completed work, pending items, active constraints, and relevant context so the receiving agent can continue without replaying the entire session history or violating role-specific boundaries. Replace every square-bracket placeholder with live data from your orchestrator before sending the prompt to the model.

textCopy
SYSTEM:
You are a Handoff Summary Generator. Your only job is to produce a structured handoff payload that transfers task state from one specialized agent to another. You do not execute the task yourself. You do not add interpretation, commentary, or recommendations beyond what the evidence supports.

Follow these rules strictly:
1. Include only information that is relevant to the receiving agent's declared role and task scope.
2. Preserve all active constraints, safety policies, and refusal boundaries from the originating agent's context.
3. Mark every item with a confidence level: [CONFIRMED], [PENDING_VERIFICATION], or [UNRESOLVED].
4. Do not fabricate completion status. If a task is incomplete, mark it as pending with the last known state.
5. Prune context that is stale, role-irrelevant, or exceeds the token budget specified in [CONTEXT_BUDGET].
6. If the originating agent's output contains contradictory or ambiguous information, flag it in an [UNRESOLVED_ITEMS] section rather than choosing a side.

USER:
Generate a handoff summary using the following inputs:

[ORIGINATING_AGENT_ROLE]: [ROLE_NAME]
[RECEIVING_AGENT_ROLE]: [ROLE_NAME]
[TASK_DESCRIPTION]: [TASK_DESCRIPTION]
[COMPLETED_WORK]: [COMPLETED_WORK]
[PENDING_WORK]: [PENDING_WORK]
[ACTIVE_CONSTRAINTS]: [ACTIVE_CONSTRAINTS]
[TOOL_OUTPUTS]: [TOOL_OUTPUTS]
[SESSION_CONTEXT]: [SESSION_CONTEXT]
[CONTEXT_BUDGET]: [CONTEXT_BUDGET]
[OUTPUT_SCHEMA]: [OUTPUT_SCHEMA]
[RISK_LEVEL]: [RISK_LEVEL]

Produce the handoff summary in the exact schema specified in [OUTPUT_SCHEMA]. If [RISK_LEVEL] is HIGH or CRITICAL, add a [HUMAN_REVIEW_REQUIRED] flag and list the specific items that require approval before the receiving agent acts.

Adaptation guidance: The [OUTPUT_SCHEMA] placeholder should reference a concrete JSON schema or structured format your downstream agent expects. If your system uses typed function calls, replace the free-text output instruction with a tool definition. For regulated or high-risk domains, keep the [HUMAN_REVIEW_REQUIRED] path active and wire it to an approval queue before the receiving agent executes any action. Test this prompt with edge cases where the originating agent's output is incomplete, contradictory, or exceeds the context budget—these are the most common failure modes in production handoffs.

This prompt is designed to be called programmatically at the moment a handoff is triggered between two specialized sub-agents. It should not be exposed directly to end-users. The application layer is responsible for gathering the required inputs—the completed work log, the pending task queue, the active constraints, and the receiving agent's capability manifest—and injecting them into the prompt's placeholders. Treat this prompt as a deterministic data transformation step: structured state in, structured handoff payload out. The model's job is to format, prune, and contextualize, not to invent new tasks or alter the priority of existing constraints.

To wire this into an application, wrap the prompt call in a function that enforces a strict output contract. Before making the API request, validate that all required inputs are present and non-empty. After receiving the response, parse the JSON output and run it through a schema validator that checks for required fields (task_state, completed_work, pending_items, active_constraints, relevant_context, role_boundary_notes). If validation fails, implement a single retry with the validation error message appended to the prompt as additional context. Log every handoff—including the raw input state, the generated summary, and the validation result—to a structured logging system for debugging and audit purposes. For high-stakes domains, insert a human review step before the summary is forwarded to the receiving agent, especially when the handoff involves a role with elevated permissions or a change in safety-critical constraints.

Model choice matters here. Use a model with strong instruction-following and JSON output capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Avoid smaller or older models that may drop fields, hallucinate task details, or fail to respect the context pruning rules. If you are using a model that supports structured output modes (e.g., OpenAI's response_format with a JSON schema or Claude's tool use with a defined input schema), bind the output directly to the handoff schema rather than relying on a free-text prompt alone. This reduces parsing errors and eliminates the need for regex-based extraction. For teams running local or air-gapped deployments, test the prompt extensively with your chosen open-weight model and be prepared to add few-shot examples of correctly formatted handoff summaries to the prompt template if the model struggles with schema adherence.