Conversation History Compression Prompt for Handoff

This prompt is for orchestration engineers who need to compress a long conversation history into a dense, lossy summary before passing it to a downstream agent. It is designed for multi-agent pipelines where context window limits force a trade-off between completeness and token cost. Use this prompt when the upstream agent has accumulated more turns than the downstream agent can accept, and you need to preserve key decisions, user corrections, and unresolved questions while discarding filler, repetition, and resolved sub-tasks. The ideal user is an AI platform engineer or agent framework developer who controls the handoff contract between agents and needs a repeatable, testable compression step that fits within a defined token budget.

Do not use this prompt for audit-grade records, legal transcripts, or workflows where verbatim conversation fidelity is required. The compression is intentionally lossy—it prioritizes actionable signal over complete reproduction. If your downstream agent needs exact user phrasing, timestamps, or full turn-by-turn attribution, this prompt is the wrong tool. Similarly, avoid this prompt when the conversation contains sensitive decisions that require human review before summarization; compression can mask nuance that a human reviewer would catch. For regulated domains, always insert a human approval step between compression and downstream action, and log both the original conversation and the compressed summary for audit trails.

Before using this prompt, ensure you have defined: the maximum token budget for the compressed output, the list of information categories that must survive compression (e.g., user corrections, tool call results, unresolved questions), and the downstream agent's expected input format. Without these constraints, the model will produce a generic summary that may drop critical context. Wire the prompt into a validation step that checks for missing required fields, token budget violations, and semantic drift from the original conversation. Start with a small set of handoff scenarios and run eval checks comparing downstream agent performance with compressed versus full context before scaling to production.

This prompt template is designed to be dropped directly into your agent orchestration layer when one agent needs to pass a compressed conversation summary to another agent. It forces the model to extract decisions, user corrections, unresolved questions, and critical context while explicitly marking what was omitted. The square-bracket placeholders let you inject the raw conversation, your specific output schema, risk tolerance, and any domain-specific constraints without rewriting the core instruction.

textCopy
You are a conversation compression engine preparing a handoff summary for a downstream agent. Your output will be the only context the next agent receives about this conversation. You must preserve decision-critical information and explicitly mark what you are omitting.

## INPUT
Raw conversation history to compress:
[CONVERSATION_HISTORY]

## COMPRESSION RULES
1. Preserve every explicit user decision, preference, or correction. Do not paraphrase these into softer language.
2. Preserve every question the user asked that remains unresolved. Mark each as UNRESOLVED.
3. Preserve every commitment or promise made to the user. Mark each as PENDING_COMMITMENT.
4. Preserve factual claims the user made that affect downstream work (account details, dates, constraints, requirements).
5. Omit small talk, pleasantries, repeated information, and turns that were fully superseded by later corrections.
6. If the conversation contains contradictory information, preserve the most recent statement and note the contradiction.
7. If the conversation exceeds [MAX_OUTPUT_TOKENS] tokens when compressed, prioritize rules 1-4 and drop the lowest-priority items first, noting what was dropped.

## OUTPUT SCHEMA
Return valid JSON matching this schema exactly:
[OUTPUT_SCHEMA]

## CONSTRAINTS
- Risk level for this handoff: [RISK_LEVEL]
- Domain context: [DOMAIN]
- Maximum output tokens: [MAX_OUTPUT_TOKENS]
- If [RISK_LEVEL] is "high", include a confidence score (0.0-1.0) for each preserved item and flag any item below [CONFIDENCE_THRESHOLD] for human review.
- Do not invent information not present in the conversation.
- Do not resolve unresolved questions by guessing.

## OMISSION DISCLOSURE
After the JSON output, include an "omissions" field listing what categories of information were dropped and why.

Adapting this template: Replace [CONVERSATION_HISTORY] with the raw transcript or message array. Define [OUTPUT_SCHEMA] as a concrete JSON Schema object with fields like decisions, unresolved_questions, pending_commitments, key_facts, and contradictions. Set [RISK_LEVEL] to "low", "medium", or "high" to control whether confidence scores and human-review flags are required. Set [DOMAIN] to a short label like "customer_support" or "healthcare_intake" to help the model apply domain-appropriate judgment about what counts as critical. Set [MAX_OUTPUT_TOKENS] based on the downstream agent's context window budget. Set [CONFIDENCE_THRESHOLD] to a float like 0.7 for high-risk workflows. Before deploying, run this prompt against a golden dataset of conversations where you know exactly which items must survive compression, and measure recall of those items in the output.

This prompt is designed to sit at the boundary between two agents or between an agent and a human reviewer. It should be invoked when the raw conversation history exceeds the downstream agent's context window budget or when you need a structured, lossy summary that preserves decisions, corrections, and unresolved questions. The implementation harness must treat this prompt as a state transformation function: it takes a full conversation transcript and a compression target (token budget, priority schema) and returns a compressed payload that the downstream agent can consume without re-reading the entire history.

Wire the prompt into your orchestration layer as a pre-handoff step. Before calling the prompt, assemble the [FULL_CONVERSATION_HISTORY] with speaker labels, timestamps, and tool-call results inline. Pass [COMPRESSION_TARGET_TOKENS] as a hard budget (e.g., 2000 tokens) and [PRIORITY_SCHEMA] as a structured list of what must be preserved: decisions, user corrections, unresolved questions, action items, and critical context. After the model returns the compressed summary, run two validation passes: (1) a schema check that the output contains the required sections (decisions, corrections, open questions, action items), and (2) a semantic coverage eval using a separate judge prompt that compares the compressed output against the original history for missing critical facts. If either validation fails, retry with a more explicit [PRIORITY_SCHEMA] or escalate to a human reviewer with the raw history attached.

For production reliability, implement idempotency key generation based on a hash of the conversation history and the compression parameters. This prevents duplicate compression calls when handoff retries occur. Log every compression attempt with the input token count, output token count, validation scores, and the idempotency key. If the compression ratio exceeds 10:1, flag the result for human review—extreme compression often indicates information loss. Choose a model with strong instruction-following and long-context handling (e.g., Claude 3.5 Sonnet or GPT-4o) for the compression step, but use a smaller, faster model for the schema validation pass to keep latency low. Never send the compressed summary to the downstream agent without running the coverage eval first; silent information loss in handoff is the most common failure mode in multi-agent pipelines.