One model, two isolated contexts. The raw, lengthy data lives only in the Executor's temporary space.

Task: You're preparing an investor pitch for a new delivery service. You need data on 4 questions: the size of the US delivery market in 2024, competitors' average order value, the most-requested features in reviews, and logistics trends. Each search returns 3,000+ tokens of articles, reviews and reports.

Prompt for the Planner (main chat):

Workflow: 1. The Planner outputs a list of subtasks 2. For each subtask, you open a new chat (the Executor):

3. The Executor runs the search → gets long articles → summarizes 4. **You copy only the short summary** into the main chat for the Planner 5. Repeat for the remaining subtasks 6. The Planner sees only 4 compact summaries → assembles the final answer **Result:** Planner context: ~500 tokens (4 short summaries of 100 tokens each). Without CoDA it would be ~12,000+ tokens (4 subtasks × 3,000 tokens of raw data) → the model would drown, lose focus and mix up facts. --- ## Why It Works LLMs **degrade on long contexts** not because of the window limit but because of **"lost in the middle"**: information in the middle of a long sequence becomes unavailable for reasoning. After 3-4 tool calls (3,000 tokens each), the context balloons to 10,000-12,000 tokens, critical facts get lost, and the model hallucinates or ignores key data. LLMs are **excellent at focused summarization**: give them one document + a clear task → you get a dense summary. And they're excellent at **planning** in a compact space: give them a task + short facts → they'll build a strategy. CoDA gets **strength through separation**: the Executor works with a narrow focus (one subtask, one chunk of data, one summary), and its context never exceeds 4,000-5,000 tokens. The Planner works in a clean strategic space (short summaries only), and its context grows linearly and slowly (100 tokens per subtask vs. 3,000 in a monolithic agent). **Control knobs:** - **Result compression level**: ask the Executor for "2-3 sentences" to save tokens or a "detailed paragraph" for complex subtasks - **Summarization criteria**: specify exactly what to extract (numbers, facts, opinions) → the Executor filters out the noise - **Number of subtasks**: don't split simple tasks; use it for 3+ step processes where each step generates lots of data - **Explicit isolation**: give the Executor the phrase "ignore everything except this subtask" → sharpens focus --- ## Prompt Template ### For the Planner (main chat): **What to fill in:** - `{task}`: your complex multi-step task (analysis, research, data gathering) --- ### For the Executor (a separate chat for each subtask): **What to fill in:** - `{subtask}`: one subtask from the Planner's list --- ### Workflow: 1. Run the Planner → get the list of subtasks 2. For each subtask: new chat → Executor prompt → short summary 3. Copy the summary into the Planner's chat: `RESULT 1: [summary]` 4. Repeat for every subtask 5. The Planner assembles the final answer --- 🚀 **Quick start**: paste this into the chat: The LLM will ask about the specifics of your task (how many steps, what data to collect, what output format), because it needs to tune the level of detail in the results and the summarization criteria to your context. It'll take the context-isolation pattern and adapt it to your specific task. --- ## Limitations > ⚠️ **Workflow overhead:** It requires switching between chats and **discipline**: you have to copy only the short results and never mix contexts. For simple tasks (1-2 steps) it's overkill and the overhead doesn't pay off. > ⚠️ **Summarization is critical:** If the Executor summarizes poorly (drops a key fact), the Planner will make decisions on incomplete data. You need to state explicitly **what** to extract from the raw data. > ⚠️ **Not for tasks with cumulative context:** If each next step critically depends on **all the details** of the previous ones (for example, writing code step by step where each line affects the next), isolation hurts. CoDA is for tasks you can **decompose**, where subtask results are **independent or loosely coupled**. --- ## How They Studied It A team from Alibaba and Georgia Tech ran into a classic problem: LLM agents do great on simple tasks but **break on complex multi-hop questions** that need 4-5 rounds of search and reasoning. The hypothesis was simple: the issue isn't the model's ability to reason, it's that **the context fills up with junk**. They trained CoDA with **reinforcement learning (PECO)**, a technique where the model learns from outcomes: right answer → reward, wrong answer → penalty. The key training trick: **one reward for the whole trajectory** (Planner + all Executor calls), but **the gradient is computed separately** for each mode based on its isolated context. It's like teaching one person to be both a strategist and an executor, but training each skill in its own conditions. They compared CoDA against monolithic agents (the whole history in one context) on the **HotpotQA** and **2WikiMultihopQA** benchmarks, datasets with complex questions like "Who directed the movie starring the actor born in the same city as...". Result: **+6% accuracy** over the best baselines. But the most interesting part is the **long-context stress test**. The researchers artificially inflated each search output (adding irrelevant text) from 1,000 to 4,000-6,000 tokens. The monolithic agents **collapsed**: accuracy dropped from ~70% to ~30-40%. CoDA **stayed stable**, dipping only 2-3%. Why? Because the Executor summarized even the bloated documents into a short result, and the Planner **never saw** that junk. The researchers' conclusion: the problem isn't the size of the context window (even 128K-token models break); the problem is **architecture**. If you pile everything up, the model loses the ability to focus. **Context isolation** isn't a crutch; it's a fundamental principle for complex tasks. --- ## Adaptations and Extrapolations ### 🔧 Technique: Single-Responsibility Contexts → sharper focus You can strengthen the CoDA principle with an **explicit role constraint** in each chat: This strengthens isolation: the model **explicitly knows the boundaries** of its role, so there's less temptation to mix levels of abstraction. --- ### 🔧 Technique: Template-Based Results → standardized data handoff When there are many subtasks (5-7 steps), it's easier for the Planner if the results are **structured**: The template **lowers the cognitive load** on the Planner: the data is easy to scan, compare and use. --- ### 🔧 Extrapolation: CoDA + Chain-of-Thought for the Executor If a subtask is **complex** (for example, competitor analysis with conclusions), give the Executor **room to reason**:

This is a hybrid setup: inside the Executor you get full reasoning (CoT for quality), and only the distillate goes to the Planner (clean context). The best of both worlds.