Tool Output Context Window Budget Check Prompt

This prompt is for agent infrastructure developers who need to prevent context window overflow when tool responses are too large to fit safely into the remaining token budget. It acts as a pre-insertion gate: given a raw tool output, a maximum token limit, and a priority-ordered list of fields to preserve, the prompt returns a budget-compliant payload with explicit truncation decisions. Use this when tool outputs are unpredictable in size, when multiple tool calls compete for context space, or when you need auditable truncation decisions rather than silent drops.

The ideal user is building a production agent loop where a model may call several tools in sequence, and each tool's response must be inserted into the context before the next reasoning step. Without a budget check, a single oversized response from a database query, API call, or file read can silently push critical instructions, earlier results, or conversation history out of the context window. This prompt solves that by making truncation an explicit, logged decision with field-level priority rather than relying on the model's implicit summarization or the platform's silent mid-window truncation. It is designed for structured outputs—JSON, XML, tabular data, or key-value records—where preserving specific fields matters more than maintaining prose fluency.

Do not use this prompt as a general summarizer for long-form text, articles, or conversational transcripts. It is not designed for semantic compression of prose and will produce poor results if asked to 'summarize' a narrative document while preserving its argument structure. For those cases, use a dedicated summarization prompt with instruction-level control over length, style, and fact density. Similarly, if your tool outputs are consistently small and predictable, a static truncation rule in application code is simpler, faster, and cheaper than an LLM call. Reserve this prompt for situations where the size variance is high, the field priority is non-obvious, or you need an audit trail of what was kept and what was dropped. When deploying in regulated or high-stakes domains, always log the full original output alongside the truncated version and require human review of the truncation decisions before they become part of a permanent record.

This prompt acts as a context-window gatekeeper. It receives the raw output from a tool call, a defined token budget, and a priority-ordered list of fields or sections that must be preserved. The model is instructed to measure the output size, decide whether truncation or summarization is required, and return a structured payload containing the processed content, size estimates, and an explicit record of what was kept, compressed, or dropped. Use this template before tool outputs are appended to the agent's message history to prevent silent context overflow, mid-turn amnesia, and runaway token costs.

textCopy
You are a context-window budget controller for an AI agent system. Your job is to inspect the output of a tool call and ensure it fits within a strict token budget before the output is added to the agent's ongoing context.

## INPUT

[TOOL_OUTPUT]

## PARAMETERS

- **Token Budget:** [MAX_TOKENS]
- **Priority Fields (ordered):** [PRIORITY_FIELDS]
- **Truncation Strategy:** [TRUNCATION_STRATEGY]  // Options: "summarize", "drop-low-priority", "head-only"
- **Output Schema:** [OUTPUT_SCHEMA]

## INSTRUCTIONS

1. Estimate the token count of the raw [TOOL_OUTPUT]. Use a conservative estimate: roughly 1 token per 4 characters for English text, or use the provided tokenizer estimate if available.
2. If the estimated token count is less than or equal to [MAX_TOKENS], return the output unchanged with `truncation_applied: false`.
3. If the estimated token count exceeds [MAX_TOKENS], apply the [TRUNCATION_STRATEGY]:
   - **summarize:** Compress the content while preserving all information in [PRIORITY_FIELDS]. Summarize or drop non-priority content.
   - **drop-low-priority:** Keep [PRIORITY_FIELDS] intact and drop all other fields or sections entirely.
   - **head-only:** Keep only the first portion of the output that fits within [MAX_TOKENS], preserving [PRIORITY_FIELDS] if they appear in that portion.
4. After processing, re-estimate the token count of the final output.
5. Return a JSON object conforming to [OUTPUT_SCHEMA] that includes the processed content, size estimates, and a clear record of what was kept, compressed, or removed.

## CONSTRAINTS

- Never fabricate data to fill gaps created by truncation.
- If a priority field cannot be preserved within the budget, flag it in `missing_critical_fields`.
- Preserve the original meaning of priority fields; do not alter factual claims.
- If the entire output must be dropped, return an empty content field with `truncation_applied: true` and a clear explanation.

## OUTPUT_SCHEMA

Return ONLY valid JSON matching this structure:
{
  "original_token_estimate": number,
  "final_token_estimate": number,
  "truncation_applied": boolean,
  "strategy_used": "none" | "summarize" | "drop-low-priority" | "head-only",
  "content": "string or structured object containing the processed output",
  "preserved_fields": ["field1", "field2"],
  "dropped_fields": ["field3"],
  "summarized_fields": ["field4"],
  "missing_critical_fields": ["field5"],
  "truncation_notes": "Explanation of decisions made"
}

To adapt this template, replace the square-bracket placeholders with values from your agent harness. [TOOL_OUTPUT] should be the raw string or JSON response from the tool. [MAX_TOKENS] is the remaining context budget you've allocated for this tool's output—calculate this dynamically based on the current context window usage. [PRIORITY_FIELDS] is an ordered list of field names or section headers that must survive truncation; this list should be derived from your downstream task requirements. [TRUNCATION_STRATEGY] can be set statically per tool or chosen dynamically based on the output type. [OUTPUT_SCHEMA] can be tightened further for your specific needs, but the provided schema includes the essential fields for observability and debugging. Wire this prompt into your agent loop immediately after a tool returns and before the output is appended to the message list. Log the truncation_notes and missing_critical_fields fields so you can detect when important information is being lost to budget constraints.

Before deploying, test this prompt against tool outputs of varying sizes: outputs that fit comfortably, outputs that exceed the budget by a small margin, and outputs that are 10x the budget. Verify that priority fields survive in all cases where they are present. Check that missing_critical_fields is populated when a priority field cannot be preserved. If you observe hallucinated content filling gaps, add stronger language to the CONSTRAINTS section. If the token estimates are consistently off, consider passing a token count from your application layer instead of relying on the model's estimate. For high-stakes domains where information loss could cause harm, route outputs flagged with missing_critical_fields to a human review queue or trigger a fallback workflow that fetches the data through a narrower, more targeted tool call.

The Tool Output Context Window Budget Check Prompt is designed to sit as a middleware gate between tool execution and the agent's main reasoning loop. After a tool returns its raw output, this prompt intercepts the payload before it enters the agent's context window. The harness must calculate the current context window utilization, estimate the incoming payload size, and invoke the budget check prompt only when the combined size threatens to exceed the model's context limit or a predefined safety threshold (e.g., 80% of the context window). This gate prevents silent truncation by the model provider, which often drops middle or end content without warning, and avoids the latency and cost of processing oversized payloads in the reasoning step.

A production implementation requires three integration points: a pre-check calculator, the prompt execution layer, and a post-processing validator. The pre-check calculator uses the model's tokenizer (or a conservative character-count heuristic for cross-model compatibility) to measure current context size and the incoming tool output size. If current_tokens + incoming_tokens > [BUDGET_THRESHOLD], the harness invokes the budget check prompt with the full tool output, the remaining budget, and the priority field map. The prompt returns a truncated or summarized payload. The post-processing validator then confirms that all [CRITICAL_FIELDS] are present in the output, that the total size is under budget, and that the truncation metadata (e.g., fields_retained, fields_dropped, truncation_ratio) is well-formed. If validation fails, the harness should retry once with a stricter budget constraint before escalating to a human operator or logging the failure for offline analysis.

Observability is critical because silent information loss is the primary failure mode. Log the pre-check token counts, the prompt's truncation decisions, the post-validation result, and any dropped critical fields as structured trace spans. Set up an eval harness that replays known tool outputs with varying budget constraints and measures critical field preservation rate and information loss rate against a ground-truth summary. Run this eval on every prompt or model version change. For high-stakes domains (healthcare, finance, legal), route any output where truncation_ratio > 0.3 or where critical fields were dropped to a human review queue before the agent continues. Avoid wiring this prompt directly into the agent's reasoning step without the pre-check gate—invoking it on every tool call wastes latency and tokens on payloads that already fit comfortably within budget.