Session Handoff State Summary Prompt Template

This prompt is designed for a single, critical job: transferring a complete and accurate mental model of an agent's session from one agent to another, or from an agent to a human operator. The ideal user is an AI application developer or platform engineer building a multi-agent system, a human-in-the-loop workflow, or any long-running process where an agent's context cannot be directly shared. The required context is the full, raw execution trace of the handing-off agent, including its original goal, completed actions, tool call results, current state variables, and any unresolved items. Without this raw trace, the prompt will produce a hollow summary that omits critical failure modes and assumptions.

You should use this prompt when an agent is being decommissioned, a task is being escalated, or a specialized agent is handing work back to an orchestrator. It is not a general-purpose conversation summarizer. Do not use it for simple chat history compression or for generating user-facing progress updates. The prompt's value is in its structured, machine-readable output and its explicit completeness checks for the receiving agent. It forces the handing-off agent to declare what it doesn't know, what it assumes, and what it has not yet verified, which prevents the receiving agent from confidently repeating work or ignoring a silent failure.

Before implementing this prompt, ensure your system can capture the raw agent trace in a structured format. The prompt's effectiveness is directly tied to the quality of its input. A handoff summary built from incomplete logs will produce a false sense of security. After generating the handoff package, the receiving agent should run a validation step to confirm it can parse all fields, understands the open items, and can identify any missing information before taking action. The next step is to pair this prompt with a 'State Integrity Validation' check on the receiving side to catch corruption during the transfer.

This prompt template produces a dense, machine-readable handoff summary designed for multi-agent systems, shift changes, and human escalation workflows. The output captures the current goal, completed work, open items, assumptions, risk flags, and a completeness declaration so the receiving agent can resume without replaying the full session history. Use this when one agent must transfer context to another and the receiving agent needs enough structured state to begin work immediately, not just a prose summary.

textCopy
You are generating a session handoff state summary for transfer to another agent or human operator. The receiving agent will use this summary as its sole context to resume work. Produce a structured handoff package that is complete, honest about uncertainty, and immediately actionable.

## INPUTS
- Current Goal: [CURRENT_GOAL]
- Completed Subtasks: [COMPLETED_SUBTASKS]
- In-Progress Subtasks: [IN_PROGRESS_SUBTASKS]
- Pending Subtasks: [PENDING_SUBTASKS]
- Recent Actions and Observations: [RECENT_ACTIONS_AND_OBSERVATIONS]
- Active Assumptions: [ACTIVE_ASSUMPTIONS]
- Known Blockers or Risks: [KNOWN_BLOCKERS_OR_RISKS]
- Tool Availability: [TOOL_AVAILABILITY]
- Session Metadata: [SESSION_METADATA]

## OUTPUT SCHEMA
Return a JSON object with these fields:
{
  "handoff_version": "1.0",
  "session_id": "string",
  "timestamp": "ISO 8601",
  "current_goal": {
    "description": "string",
    "success_criteria": ["string"],
    "priority": "critical | high | medium | low"
  },
  "completed_work": [
    {
      "subtask_id": "string",
      "description": "string",
      "outcome": "success | partial | failed",
      "evidence": "string or null",
      "completed_at": "ISO 8601 or null"
    }
  ],
  "in_progress_work": [
    {
      "subtask_id": "string",
      "description": "string",
      "current_state": "string",
      "next_action": "string",
      "blocker": "string or null"
    }
  ],
  "pending_work": [
    {
      "subtask_id": "string",
      "description": "string",
      "prerequisites": ["string"],
      "estimated_effort": "string or null"
    }
  ],
  "active_assumptions": [
    {
      "assumption": "string",
      "confidence": "high | medium | low",
      "validation_needed": true | false,
      "impact_if_wrong": "string"
    }
  ],
  "risk_flags": [
    {
      "risk": "string",
      "severity": "critical | high | medium | low",
      "affected_subtasks": ["string"],
      "mitigation_suggestion": "string or null"
    }
  ],
  "tool_state": {
    "available_tools": ["string"],
    "unavailable_tools": ["string"],
    "tool_failures": ["string or null"]
  },
  "completeness_declaration": {
    "missing_information": ["string"],
    "stale_state_fields": ["string"],
    "receiving_agent_should_verify": ["string"],
    "ready_for_handoff": true | false
  },
  "handoff_notes": "string"
}

## CONSTRAINTS
- Do not omit fields. Use null or empty arrays when no data exists.
- For every assumption, state your confidence level honestly. Do not mark low-confidence assumptions as high.
- Flag any state that may be stale due to time elapsed since last observation.
- If ready_for_handoff is false, explain why in handoff_notes and list what must happen before handoff.
- Do not invent completed work. Only report what the evidence supports.
- If tool failures occurred, document them in tool_state.tool_failures.
- Prioritize risks that could cause the receiving agent to take incorrect actions.

Adapt this template by replacing each square-bracket placeholder with data from your agent runtime. The [COMPLETED_SUBTASKS], [IN_PROGRESS_SUBTASKS], and [PENDING_SUBTASKS] fields should be populated from your task tracker or execution log. The [ACTIVE_ASSUMPTIONS] field is critical for handoff quality: if your agent runtime does not track assumptions explicitly, extract them from recent reasoning traces or require the agent to declare them before handoff. For high-risk domains, add a human review step before the receiving agent acts on the handoff summary. Validate the output against the JSON schema before passing it to the next agent, and log the handoff payload for auditability.

The session handoff prompt is not a standalone utility; it is a critical state-transfer mechanism in multi-agent systems and human-in-the-loop workflows. When one agent exhausts its scope, hits a tool boundary, or escalates to a human operator, the handoff summary becomes the receiving party's sole context. A missing or corrupted handoff forces the receiver to re-derive state from raw logs, wasting tokens and time. The implementation harness must therefore treat this prompt as a transactional boundary: the sending agent must not terminate or release resources until the handoff payload is validated and acknowledged.

Wire this prompt into your agent runtime as a pre-handoff hook. Before transferring control, the sending agent invokes the prompt with its current state object, action log, and unresolved items. The output must be validated against a strict schema—reject any handoff that omits required fields such as current_goal, completed_items, open_items, assumptions, or risk_flags. Implement a retry loop with a maximum of three attempts, using a repair prompt that feeds validation errors back to the model. If validation continues to fail, escalate the raw state to a human operator rather than forwarding a partial handoff. Log every handoff attempt, including the raw prompt, the validated output, and any repair iterations, to an append-only audit store. This log is essential for debugging agent loops, stale-state propagation, and handoff-induced failures.

Model choice matters here. Use a model with strong instruction-following and structured output support—GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate. Avoid smaller or older models that may drop fields or hallucinate completion status. Set temperature to 0 or near-zero to maximize determinism. If your system uses tool-augmented agents, ensure the handoff prompt has access to the full tool-call history and any tool outputs, not just the agent's internal summary. For human handoffs, render the structured output into a readable format but preserve the machine-readable version as the authoritative record. Never allow a receiving agent to act on a handoff that failed schema validation or completeness checks—this is the most common failure mode in production handoff pipelines.