Agent Working Memory Summarization Prompt

This prompt is for agent developers and platform engineers who need to compress an agent's active working memory into a compact summary that fits within a constrained context window. The job-to-be-done is lossy but task-preserving compression: you must reduce token usage while retaining the goals, decisions, partial results, and open questions the agent needs to continue its work without repeating steps or losing critical context. The ideal user is building a multi-agent system, a long-running autonomous agent, or any loop where the agent's internal scratchpad grows too large for the model's context limit and must be summarized before the next reasoning step.

Use this prompt when an agent's working memory—its current plan, recent observations, tool outputs, and pending actions—exceeds a defined token budget and you need a structured summary that preserves task-critical information. The prompt expects a structured input containing the agent's current goal, recent memory entries, and a list of information categories that must be preserved. It produces a compressed summary with importance scores, explicit loss markers for discarded information, and a confidence estimate. Do not use this prompt for summarizing final outputs to users, for compressing immutable system instructions, or for long-term memory consolidation. It is specifically designed for the working memory buffer that sits between the agent's reasoning steps.

Before deploying this prompt, define your token budget, your task-critical information categories, and your evaluation criteria for information retention. The prompt includes a structured output schema that forces the model to declare what it kept, what it dropped, and why. Wire this into your agent loop with a pre-summary token check, a post-summary validation step that verifies the output schema, and an eval harness that tests whether the agent can still complete its task after summarization. The most common failure mode is dropping a constraint, a partial result, or an open question that the agent needs later—your eval must catch this before it compounds across multiple summarization cycles.

This template is designed to be dropped into an agent's context management loop when the working memory buffer exceeds a token threshold. It instructs the model to act as a memory compressor, producing a lossy but task-preserving summary. The prompt forces explicit importance scoring and requires the model to justify what it retains and what it discards, which is critical for downstream debugging and eval. Use this template when you need a structured, auditable summary rather than a generic conversation summarization.

textCopy
You are an agent memory compression module. Your task is to compress the provided [WORKING_MEMORY] into a compact summary that preserves all information critical to completing the current [TASK_GOAL].

## Input
[WORKING_MEMORY]

## Task Goal
[TASK_GOAL]

## Constraints
- Maximum output length: [MAX_TOKENS] tokens.
- Prioritize facts, decisions, unresolved questions, and active constraints over conversational filler.
- Preserve exact values for identifiers, error codes, file paths, and configuration parameters.
- If a piece of information is directly required by [TASK_GOAL], it must be retained.

## Output Schema
Return a JSON object with the following structure:
{
  "summary": "A dense, factual narrative of the compressed memory.",
  "retained_items": [
    {
      "item": "The specific fact, decision, or context retained.",
      "importance_score": 0.0-1.0,
      "relevance_to_goal": "Why this item is critical for [TASK_GOAL]."
    }
  ],
  "discarded_items": [
    {
      "item": "A brief description of what was removed.",
      "discard_reason": "Why this item is not relevant to [TASK_GOAL] or is redundant."
    }
  ],
  "unresolved_questions": [
    "Any open questions that must be answered to complete [TASK_GOAL]."
  ]
}

## Risk Level
[RISK_LEVEL]

If [RISK_LEVEL] is "high", you must flag any discarded item that could potentially be relevant under a broader interpretation of [TASK_GOAL] in a `flagged_for_review` field within each discarded item.

To adapt this template, start by defining a clear, narrow [TASK_GOAL]. A vague goal like "fix the bug" will cause the compressor to retain too much or too little. Instead, use a specific goal such as "Resolve the NullPointerException in UserService.createUser() by identifying the root cause and applying a fix." Set [MAX_TOKENS] based on your model's context window budget for memory—typically 20-40% of the total window. For [RISK_LEVEL], use "high" for production debugging, security incidents, or financial operations where information loss is costly; use "low" for exploratory or conversational agent sessions. After generation, validate the output JSON against the schema and run an eval that checks whether all items with an importance_score above 0.8 are actually present in the summary text. If the summary fails this consistency check, retry with a lower [MAX_TOKENS] or a more explicit [TASK_GOAL].

This prompt is designed to be called inside an agent's context management loop, typically when the working memory buffer exceeds a token threshold or a fixed number of turns. The application layer should track the current working memory entries, their timestamps, and any associated importance scores before invoking the summarization prompt. The prompt expects a structured list of memory entries as [WORKING_MEMORY_ENTRIES], each containing at minimum a content field and optionally timestamp, source, and importance fields. The application is responsible for assembling this list from the agent's runtime state store before each call.

Wire the prompt into a dedicated summarization step within the agent's orchestration code. Before calling the model, validate that the input payload is not empty and that the total token count of [WORKING_MEMORY_ENTRIES] exceeds your configured compression threshold. After receiving the model response, parse the JSON output and validate it against the expected schema: a list of summary objects, each with summary, retained_facts, discarded_details, and importance_score fields. If validation fails, implement a single retry with the validation error message appended to the prompt as additional [CONSTRAINTS]. Log both the original and retry attempts for observability. For high-stakes agent workflows where information loss could cause incorrect actions, route summaries with importance_score below a configurable threshold (e.g., 0.7) to a human review queue before the agent acts on the compressed memory.

Model choice matters here. Use a model with strong instruction-following and JSON output capabilities, such as Claude 3.5 Sonnet or GPT-4o, and enable structured output mode if available. Set temperature to 0 or a low value (0.1–0.2) to maximize consistency across repeated summarization calls. The prompt should be treated as a cached system instruction prefix where possible to reduce latency and cost on repeated calls. Store the output summary alongside the original memory entries with a version marker and timestamp, enabling audit trails and rollback if the agent later exhibits behavior that suggests critical information was lost during compression. Integrate the eval rubric from this playbook into your CI pipeline: run the prompt against a golden set of memory entries and verify that retained_facts preserves all task-critical items defined in your test cases before deploying any prompt changes.