Instruction Rehydration Prompt for Summarized Context Windows

This prompt is designed for AI engineering teams who use context summarization to manage long-running agent or copilot sessions. The core job-to-be-done is restoring full instruction fidelity after a context window has been compressed. When a summarizer condenses a long conversation history, it often strips the nuance, priority, and exact wording from system prompts, role definitions, and safety policies. This rehydration protocol takes a degraded, summarized instruction set and expands it back to its operational form, ensuring that the model's governing rules are as clear at turn 200 as they were at turn 1. The ideal user is a backend engineer or AI platform developer who has already instrumented their application to detect when a summary has been injected and needs to verify that critical instructions survived the compression.

You should use this prompt when your application relies on automatic context summarization—such as sliding window summarizers, conversation compression APIs, or session state truncation—and you have observed instruction drift in long sessions. It is particularly valuable for regulated industries, customer-facing support bots, and multi-agent systems where a loss of instruction fidelity directly causes compliance violations, brand damage, or incorrect tool use. The prompt expects a [SUMMARIZED_CONTEXT] that contains the compressed system instructions, a [REFERENCE_INSTRUCTIONS] block with the original full-text instructions for comparison, and a [FIDELITY_THRESHOLD] that defines the minimum acceptable match between the rehydrated output and the original. Do not use this prompt as a substitute for proper context budget management; if your instructions are being truncated because you are simply exceeding the model's context limit, you need a compression and prioritization strategy first, not a rehydration step.

Avoid this prompt when the summarized context is so severely degraded that no semantic trace of the original instructions remains. Rehydration cannot reconstruct rules that have been entirely omitted; it can only expand and clarify what is still present in some form. Also, do not use this prompt in real-time, latency-sensitive paths where the rehydration step would add unacceptable delay to every model call. Instead, run rehydration as an asynchronous verification step or a periodic fidelity check. After using this prompt, always run the provided fidelity checks to compare pre-compression and post-rehydration behavior, and log any instruction elements that fall below the [FIDELITY_THRESHOLD] for human review. If the rehydrated instructions consistently fail fidelity checks, the root cause is likely in your summarization step, not the rehydration prompt itself.

This prompt template is the core of the instruction rehydration playbook. It is designed to be injected after a context window summarization event, instructing the model to expand a compressed set of system rules back into their original, actionable form. The template uses square-bracket placeholders that you must replace with your application's specific instructions, output format requirements, and fidelity constraints before deployment. The goal is not just to recall the rules, but to restore the model's behavioral contract to a state functionally equivalent to the pre-compression system prompt.

codeCopy
SYSTEM: You are an Instruction Rehydration Agent. Your task is to expand a set of summarized system instructions back into a complete, operational system prompt. The original instructions were compressed to save context. You must now restore them to full fidelity.

INPUT SUMMARY:
[COMPRESSED_INSTRUCTION_SUMMARY]

REHYDRATION PROTOCOL:
1. Expand each summarized rule into its full, unambiguous operational form. Do not add new rules, but restore implied details, edge-case handling, and precise language that may have been lost during compression.
2. Restore the original priority and hierarchy of instructions. If the summary indicates a conflict resolution order (e.g., 'System rules override user requests'), make that order explicit.
3. Reconstruct any role definitions, persona traits, tone guidelines, and terminology constraints mentioned in the summary.
4. For any policy or safety rule, restore the full refusal language, escalation path, and safe alternative suggestions.
5. Rebuild any output formatting instructions, including schema, field requirements, and valid enum values.

OUTPUT FORMAT:
You must output the rehydrated instructions in the following JSON schema:
{
  "system_prompt": "The fully rehydrated system prompt as a single string.",
  "instruction_layers": [
    {
      "priority": 1,
      "type": "system|developer|user|tool|policy",
      "content": "The full text for this instruction layer."
    }
  ],
  "fidelity_notes": ["A list of specific details you restored that were implicit in the summary."]
}

CONSTRAINTS:
- Do not invent new capabilities, tools, or permissions not implied by the summary.
- If the summary is ambiguous on a critical point, flag it in `fidelity_notes` and choose the safest reasonable interpretation.
- The rehydrated prompt must be immediately usable as a replacement system prompt.

To adapt this template, replace [COMPRESSED_INSTRUCTION_SUMMARY] with the output of your context summarization step. For high-risk applications, add a [RISK_LEVEL] placeholder to conditionally enable a human-review step before the rehydrated prompt is activated. You should also customize the OUTPUT FORMAT to match your application's internal prompt assembly structure, ensuring the rehydrated layers map directly to your instruction hierarchy. The next step is to wire this prompt into an implementation harness that validates the output before it replaces the active system prompt.

The instruction rehydration prompt is not a standalone chat interaction; it is a programmatic repair step inserted into a long-running agent's context management pipeline. The typical integration point is immediately after a context summarization or compression step and before the next user turn is processed. The application should detect that a summary has been injected into the context window, then call the rehydration prompt with the compressed summary and the original system instructions as inputs. The output is a validated, expanded instruction block that replaces or augments the compressed summary, ensuring the model's behavioral contract is restored before it generates its next response.

To implement this, build a context manager class or middleware function that intercepts the message list before it is sent to the model. When a summary marker (e.g., a <summary> block or a summary role message) is detected, extract the summary text and the canonical system prompt from your configuration store. Populate the rehydration prompt's [COMPRESSED_SUMMARY] and [ORIGINAL_SYSTEM_INSTRUCTIONS] placeholders. Send this as a single-turn, high-priority request to a capable model (GPT-4o or Claude 3.5 Sonnet are good defaults). The response must be parsed as structured JSON containing the rehydrated_instructions and fidelity_checks objects. Before injecting the rehydrated instructions back into the context window, run a validation step: confirm the JSON schema matches, check that the fidelity_checks.overall_score meets your threshold (e.g., >= 0.9), and verify that no critical safety keywords from the original instructions are missing. If validation fails, log the failure, fall back to injecting the original system instructions in full, and trigger an alert for manual review. For high-risk domains like healthcare or legal, always require a human to approve the rehydrated block before it is used in a customer-facing session.

Model choice matters here. The rehydration task requires strong instruction-following and structured output capabilities. Avoid using smaller or older models that may drop constraints or hallucinate fidelity scores. Set temperature=0 to maximize determinism. Implement retries with exponential backoff if the model returns malformed JSON or a fidelity score below your threshold, but cap retries at 3 attempts to avoid latency spikes. Log every rehydration event—including the compressed summary, the rehydrated output, the fidelity scores, and the final action taken—to your prompt observability system. This audit trail is essential for debugging instruction drift and proving governance compliance. The next step is to integrate this harness into your session lifecycle: trigger rehydration on every summary injection, monitor the fidelity scores over time, and set up dashboards that alert you when rehydration quality degrades, which often signals that your summarizer or your original system prompt needs an update.