Proposal: Context Summary for Orchestrator Sub-tasks

[HadesArchitect]

Original: https://discord.com/channels/1349288496988160052/1388009729497890888

TL;DR: summarize context that orchestrator has and pass it to subtasks. (like the condensing summary)

Scope Document: Agentic Middleware for Context Handoff

1. Problem Statement

The current agent architecture suffers from context-loss inefficiency. When the Orchestrator creates a sub-task for a specialist agent (e.g., Architect, Builder), the new agent starts with a blank slate. It must re-discover the environment, re-read files, and lacks the nuanced understanding accumulated by its parent. This leads to redundant operations, increased token usage, and potentially sub-optimal performance.

Similarly, when a sub-task completes and returns to the Orchestrator, the full context of its work (new files created, APIs implemented, problems solved) is not automatically and concisely injected back into the Orchestrator's context, forcing it to potentially re-read the sub-task's outputs.

2. Proposed Solution: The "Context Handoff" Middleware

We will implement a middleware layer that acts as a "context summarization agent." This layer will be invoked during two critical phases of the agent lifecycle:

1. Task Delegation (Orchestrator -> Sub-agent): Before a new sub-task is created, the middleware will summarize the Orchestrator's extensive context, tailoring the summary to be highly relevant to the sub-task's specific prompt. This distilled summary is then injected into the sub-agent's initial context.

2. Task Completion (Sub-agent -> Orchestrator): Upon completing its work, the sub-agent will use the middleware to generate a "boomerang" summary. This summary will encapsulate the key outcomes, artifacts, and learnings from the sub-task, providing a concise and potent update to the Orchestrator.

This creates an intelligent "context pipeline" that ensures low-token, high-relevance information flows between hierarchical agents.

3. Technical Implementation Details

3.1. New Core Logic: generateHandoffSummary

The heart of this feature will be a new function, likely residing alongside the existing summarization logic in /src/core/condense/index.ts.

// Proposed location: ../kilocode/src/core/condense/index.ts

/**
 * A new, specialized prompt for generating handoff context.
 */
const TASK_HANDOFF_PROMPT = `
You are a 'middleware agent' responsible for knowledge transfer between a parent agent (Orchestrator) and a child agent (Specialist).

Your task is to create a concise but comprehensive "handoff document" for the Specialist. This document must summarize the Orchestrator's vast knowledge, but *only* the parts relevant to the Specialist's upcoming task.

**INPUTS:**
1.  **Orchestrator's Context:** A detailed history of the entire project so far.
2.  **Specialist's Prompt:** The specific instructions for the new sub-task.

**YOUR GOAL:**
Analyze the Specialist's prompt. Then, extract and synthesize information from the Orchestrator's context that is directly necessary for the Specialist to begin its work efficiently. Do not include irrelevant history.

**OUTPUT STRUCTURE:**
Your summary must follow this exact format:

1.  **Primary Objective:**
    *   A one-sentence summary of what this sub-task needs to accomplish.

2.  **Essential Background & Key Decisions:**
    *   [Provide 2-3 bullet points of the most critical context from the parent that led to this sub-task's creation. E.g., "User approved the proposed system architecture," "The backend API for 'todos' was just completed."]

3.  **Relevant Files & Artifacts:**
    *   [List the specific files the Specialist will likely need to read or modify. Explain *why* each is relevant to the new prompt. E.g., "- \`src/api/routes.ts\`: Contains the main API router where the new endpoint will be added."]

4.  **Technical Environment & Constraints:**
    *   [Summarize the key technologies, libraries, and versions the Specialist *must* adhere to. E.g., "- Tech Stack: Node.js v18, Express, Prisma ORM.", "- Database: PostgreSQL on localhost."]

5.  **Immediate Next Steps:**
    *   [Outline the first 1-2 actions the Specialist should take based on its prompt.]

Focus on precision and relevance. The Specialist should be able to start work immediately with this document without needing to ask the Orchestrator for clarification.
`;

/**
 * Generates a targeted context summary for a new sub-task.
 * @param orchestratorHistory The full ApiMessage history of the parent task.
 * @param subtaskPrompt The prompt/instructions for the new sub-task.
 * @param apiHandler The API handler to use.
 * @returns A string containing the distilled context summary.
 */
export async function generateHandoffSummary(
    orchestratorHistory: ApiMessage[],
    subtaskPrompt: string,
    apiHandler: ApiHandler,
): Promise<string> {
    const handoffRequest: Anthropic.MessageParam = {
        role: "user",
        content: `
            <orchestrator_context>
                ${JSON.stringify(orchestratorHistory)}
            </orchestrator_context>
            <subtask_prompt>
                ${subtaskPrompt}
            </subtask_prompt>
        `,
    };

    // This re-uses the existing `summarizeConversation` infrastructure but with our new, specialized prompt.
    // We can extract the core LLM call from summarizeConversation into a helper to make this cleaner.
    const response = await summarizeConversation(
        [...orchestratorHistory, handoffRequest],
        apiHandler,
        TASK_HANDOFF_PROMPT, // IMPORTANT: Using the new prompt
        /* other params */
    );

    return response.summary;
}

3.2. Modifying the Orchestration Flow in Task.ts

The Task class will need modification in how it creates new tasks. We'll intercept the creation process to inject our middleware.

// Proposed modifications in ../kilocode/src/core/task/Task.ts

// In a method responsible for creating a new task, e.g., a hypothetical `spawnSubTask`
public async spawnSubTask(mode: string, prompt: string): Promise<Task> {
    
    // --- 1. Middleware Invocation ---
    // Generate the distilled context before creating the sub-task.
    const handoffContext = await generateHandoffSummary(
        this.apiConversationHistory, // The orchestrator's history
        prompt,                     // The prompt for the new sub-task
        this.api                    // The orchestrator's API handler
    );

    // --- 2. Constructing the Injected Prompt ---
    // Prepend the distilled context to the original prompt.
    const injectedPrompt = `
        <handoff_context>
        ${handoffContext}
        </handoff_context>

        <original_task>
        ${prompt}
        </original_task>
    `;

    // --- 3. Creating the Sub-Task with Injected Context ---
    const subTask = new Task({
        // ... existing options
        task: injectedPrompt, // Use the new, context-rich prompt
        parentTask: this,
    });
    
    // ... rest of the task creation logic

    return subTask;
}

3.3. The "Boomerang" Context Handoff

For the return journey, we need to ensure the sub-task's summary is properly injected into the parent's context:

// Proposed modifications in ../kilocode/src/core/task/Task.ts

/**
 * Enhanced version of resumePausedTask that properly injects sub-task results
 */
public async resumePausedTask(lastMessage: string): Promise<void> {
    // Release this Cline instance from paused state.
    this.isPaused = false;
    this.emit("taskUnpaused");

    // Display the sub-task's result in the chat UI
    await this.say("subtask_result", lastMessage);
    
    // --- NEW: Context Injection ---
    // Inject the sub-task's summary into the parent's API conversation history
    const injectedContextMessage = `[SUB-TASK COMPLETED]
The sub-agent has completed its task with the following outcomes:
<subagent_summary>
${lastMessage}
</subagent_summary>`;

    await this.addToApiConversationHistory({
        role: "user",
        content: [{ type: "text", text: injectedContextMessage }],
    });
    
    console.log(`[subtasks] Injected completion summary from sub-task into parent ${this.taskId}.`);
}

4. Impact Analysis

• Files to Modify:

  • /src/core/condense/index.ts: To add the TASK_HANDOFF_PROMPT and the generateHandoffSummary function.
  • /src/core/task/Task.ts: To modify the sub-task creation and completion logic to invoke the new middleware.

• Benefits:

  • Drastically Reduced Token Cost: Sub-tasks start with a small, highly relevant context instead of a blank slate, eliminating redundant discovery steps.
  • Improved Performance: Sub-tasks can begin their core work immediately, leading to faster completion times.
  • Enhanced Accuracy: By providing targeted context, the sub-agents are less likely to make incorrect assumptions or ask for redundant information.
  • Better Orchestration: The "boomerang" summary allows the Orchestrator to maintain a more accurate and concise state of the overall project without needing to parse large outputs.

[CacTye]

Love this. Hope it gets implemented.

[waiyan91]

Good idea. I still think the ai models are capable with little contexts but I would like to see the difference made