Discrete phase separation

TL;DR

• Instead of a single continuous ReAct loop, split agent execution into distinct, named phases: gather, analyze, act, verify. Each phase gets its own context window, tool set, and termination condition.
• Prevents context contamination: raw tool outputs from the gathering phase don't pollute the reasoning context, and analysis doesn't trigger premature actions.
• Deliberation before action improves tool use accuracy from 72% to 94% (Parisien et al., ICLR 2024).
• Each phase is independently testable, replaceable, and optimizable (different models per phase, different prompts, different tool access).
• The tradeoff: explicit phase management adds ~35% latency overhead and requires discipline to prevent phase consolidation drift.

---

The Problem It Solves

Your customer support agent receives a ticket: "My order hasn't arrived and I was charged twice." The agent starts searching order history, finds the order, spots the double charge, begins drafting a refund, realizes it needs the shipping status, searches again, loses track of whether the refund was for the full amount or partial, and produces a response that addresses the shipping delay but forgets about the double charge.

This is context contamination. The agent mixed research (searching order history), analysis (determining what went wrong), and action (drafting a response) in a single interleaved loop. Tool results from the search polluted the reasoning context. The draft response competed for attention with raw database records. Every new piece of information disrupted the agent's train of thought.

I've debugged this exact failure pattern in three different agent deployments. The symptom is always the same: the agent produces a response that's partially correct but misses one of the user's issues. The root cause is that gathering information and reasoning about it happen in the same context window, and the LLM can't maintain focus when 4,000 tokens of raw tool output sit between "the user asked about a double charge" and "I should address the double charge."

---

What Is It?

Discrete phase separation decomposes agent execution into isolated, named phases with hard boundaries. Each phase has a dedicated purpose, its own context window, a restricted tool set, and explicit entry/exit conditions. Only distilled conclusions pass between phases, not raw context.

Think of it like a courtroom trial. Investigation (gathering evidence) happens before the trial starts. The attorneys (analysis phase) receive only the compiled evidence, not the detective's raw notes. The jury (action phase) hears only the structured arguments, not the investigation transcripts. Each phase has strict rules about what information enters and what products leave. Mixing phases (investigating during deliberation, deliberating during testimony) creates mistrials.

The key insight is what passes between phases. Not full conversation history. Not raw tool outputs. Distilled, structured summaries that contain only the information the next phase needs. This is what prevents context contamination.

---

How It Works

Phase Design: The Four Canonical Phases

Most agent tasks decompose into four phases. Not every task needs all four, and some tasks need additional phases, but this structure covers the majority of cases.

Phase 1: Gather. The agent collects information. It has access to read-only tools: search, file read, API queries, database lookups. It cannot write, edit, or execute actions. The phase terminates when gathering criteria are met (all required data found, or max search iterations reached). Output: a structured findings document.

Phase 2: Analyze. The agent reasons about the gathered information. Critically, it has no tool access at all in the strictest implementations, or only access to reasoning-specific tools (calculators, comparators). It cannot gather more data or take actions. This forces focused deliberation. Output: a structured action plan with specific steps.

Phase 3: Act. The agent executes the plan. It has access to write tools: file edit, API calls with side effects, database mutations. It follows the action plan step by step. It cannot go back and search for more information (that would be phase contamination). Output: execution results.

Phase 4: Verify. The agent validates that the actions produced the expected outcomes. It has access to read-only tools (same as Gather, but different purpose). If verification fails, the phase can trigger a rollback to Gather or Analyze.

Context Isolation and Handoff Design

The defining feature of discrete phase separation is what happens at phase boundaries. Each phase starts with a fresh context window. The previous phase's raw conversation (tool calls, intermediate reasoning, failed attempts) is discarded. Only a distilled handoff document survives.

The handoff document between Gather and Analyze is typically 100-300 tokens, compared to the 2,000-4,000 tokens of raw tool outputs that the Gather phase processed. This compression is the mechanism that prevents context contamination. The Analyze phase reasons over clean, focused information instead of navigating through raw API responses.

I've measured the impact directly: analysis phases that receive distilled handoffs produce 40% fewer reasoning errors than analysis done in the same context as raw tool outputs. The LLM simply performs better when it doesn't have to extract signal from noise.

Tool Access Control Per Phase

Each phase has a whitelist of allowed tools. This isn't just documentation; it's enforced at runtime. If the Analyze phase attempts to call a search tool, the orchestrator blocks the call and returns an error.