Sub-Task Context Packaging Prompt for Handoff

This prompt is for orchestration engineers and agent framework developers who need to prepare a minimal, self-contained context package for a sub-agent before dispatching a delegated task. The job-to-be-done is preventing context pollution: a sub-agent should receive exactly the information required to execute its contract—relevant inputs, constraints, session snippets, and explicit exclusions—without carrying forward the entire history, irrelevant state, or data from parallel branches that could confuse its reasoning or waste its context window. The ideal user is someone building a multi-agent pipeline where handoff quality directly determines whether the system outperforms a single-agent approach.

Use this prompt when you have decomposed a complex request into sub-tasks with clear input/output contracts and you are about to dispatch work to a specialized agent. It is appropriate when the orchestrator has access to a larger session context, but the sub-agent should operate on a tightly scoped subset. Do not use this prompt for trivial tasks where the full context is already small enough, or when the sub-agent is designed to explore and retrieve its own context from shared memory stores. It is also not a replacement for a shared blackboard architecture—this prompt is for explicit, point-in-time context packaging at the moment of handoff.

Before using this prompt, ensure you have defined the sub-task's required inputs, the relevant session excerpts, any constraints or policies that apply, and a list of what the sub-agent should explicitly ignore. After generating the context package, run the companion context leakage tests and completeness verification checks described in the evaluation section. If the sub-task operates in a regulated domain or involves high-risk actions, route the packaged context through a human review step before dispatch.

This prompt template is designed for orchestration engineers who need to prepare a minimal, self-contained context package before handing a sub-task to a specialized agent. The goal is to prevent context leakage, reduce token waste, and ensure the receiving agent has exactly what it needs—no more, no less. Use this template inside your orchestrator's pre-handoff logic, where you assemble the package and then inject it into the sub-agent's system or user prompt.

textCopy
You are a context packaging assistant. Your job is to prepare a minimal, self-contained context package for a sub-agent that will execute the following task.

## Task Definition
[SUB_TASK_DESCRIPTION]

## Available Context
Below is the full session context, including prior agent outputs, user messages, tool results, and state variables. Your job is to extract only what is relevant.

[FULL_SESSION_CONTEXT]

## Packaging Rules
1. Include only information that is directly required to complete the task.
2. Exclude any information that is irrelevant, redundant, or already implied by the task definition.
3. If the task requires outputs from prior sub-tasks, include those outputs verbatim with source attribution.
4. If the task requires user intent or constraints from earlier in the session, include only the relevant excerpts.
5. Do not include internal orchestrator state, agent-to-agent negotiation logs, or debugging information.
6. If a piece of context might be relevant but you are uncertain, mark it as [OPTIONAL] and explain why.

## Output Schema
Return a JSON object with the following structure:
{
  "task": "[SUB_TASK_DESCRIPTION]",
  "required_inputs": {
    "prior_outputs": [
      {
        "source_agent": "agent_name",
        "output": "relevant output excerpt",
        "relevance": "why this is needed"
      }
    ],
    "user_context": [
      {
        "excerpt": "relevant user message or constraint",
        "relevance": "why this is needed"
      }
    ],
    "session_variables": [
      {
        "key": "variable_name",
        "value": "variable_value",
        "relevance": "why this is needed"
      }
    ]
  },
  "explicit_exclusions": [
    {
      "item": "description of excluded context",
      "reason": "why it was excluded"
    }
  ],
  "constraints": ["list of constraints the sub-agent must follow"],
  "completeness_check": {
    "can_execute": true,
    "missing_information": ["list of missing items, if any"],
    "assumptions": ["list of assumptions made during packaging"]
  }
}

## Constraints
- Do not fabricate information. If something is missing, report it in completeness_check.
- Do not summarize or paraphrase prior outputs unless the task explicitly requires summarization.
- Preserve exact values, identifiers, and references from the source context.

After copying this template, replace the square-bracket placeholders with your actual task description and full session context. The output is a structured JSON package that you can pass directly to the sub-agent's prompt as its [CONTEXT] block. For high-stakes workflows, add a validation step that checks the completeness_check.can_execute field before dispatching. If can_execute is false, route the package to a human reviewer or trigger a re-decomposition of the parent task. Avoid the temptation to skip the explicit exclusions list—it is your primary defense against context leakage and the most common source of sub-agent confusion in production.

This prompt operates as a pre-dispatch gate inside an orchestrator. Before a sub-task is sent to a specialized agent, the orchestrator calls this prompt with the full session state, the sub-task contract, and the target agent's capability profile. The output is a pruned context package that the orchestrator attaches to the sub-agent's request payload. The prompt should run synchronously in the dispatch path—if it fails or times out, the orchestrator must not forward the raw session state to the sub-agent, because that defeats the purpose of context isolation.

Integration pattern: Place this prompt between the task decomposition step and the agent dispatch step. The orchestrator should call it once per sub-task, passing [FULL_SESSION_CONTEXT] (the complete conversation, tool outputs, and prior agent results), [SUB_TASK_CONTRACT] (the input/output schema, completion criteria, and role assignment from the decomposition prompt), and [TARGET_AGENT_PROFILE] (the agent's capability description, tool list, and known context preferences). The prompt returns a [CONTEXT_PACKAGE] containing relevant_inputs, constraints, session_snippets, and explicit_exclusions. The orchestrator then constructs the sub-agent call using only this package plus the sub-task instruction. Validation step: Before dispatch, run a schema check on the output—relevant_inputs must be a non-empty array, explicit_exclusions must list at least one item the sub-agent should ignore, and session_snippets must not exceed a configurable token budget (e.g., 2,000 tokens). If validation fails, retry once with a stricter [CONSTRAINTS] value like "Reduce snippet length by 50% and ensure exclusions are explicit."

Model choice and cost: This prompt benefits from a model with strong instruction-following and extraction precision. GPT-4o or Claude 3.5 Sonnet are good defaults. For high-throughput pipelines, consider a smaller fine-tuned model if you have labeled context-package pairs from production traces. Observability: Log the input token count (full session), output token count (context package), and the compression ratio. Track context leakage events—cases where the sub-agent references information that was in the full session but not in the context package. These events are your primary quality signal. Failure modes: The most common failure is the prompt including too much context (defeating the purpose) or excluding a critical piece of information the sub-agent needs. Mitigate the first with token budget enforcement; mitigate the second by running a periodic completeness audit where a human or a judge model compares sub-agent outputs against a baseline that received the full context. If completeness drops below a threshold, adjust the prompt's [CONSTRAINTS] to be less aggressive about exclusion.

Human review trigger: For high-risk domains (healthcare, legal, finance), flag any context package where explicit_exclusions contains items that overlap with the sub-task's required inputs as defined in the contract. Route those to a human reviewer before dispatch. Next step after integration: Build a regression test suite using 20–30 recorded sessions where you know the correct context package. Run this suite on every prompt change and flag any diff in relevant_inputs or explicit_exclusions that changes the sub-agent's output. Treat context packaging as a product-critical component—a silent context leak can produce correct-looking but ungrounded outputs that are hard to catch downstream.