Isolate Stage — Separating Context by Type So the Model Doesn't Confuse Instructions, Data, and History

The fourth and final stage, Isolating context, addresses a problem that can persist even after careful writing, selecting, and compressing: if everything relevant still ends up mixed together in one undifferentiated blob within a single context window, the model can struggle to keep straight what's an instruction versus what's retrieved data versus what's prior conversation history versus what's a tool's raw output — especially as that blob grows larger and more varied in origin.

Isolating context involves splitting it up to help an agent perform a task, rather than accepting one large mixed context as the only option. This course names three popular ways to do this: using multiple agents (or sub-agents), each with its own separately-scoped context rather than one shared context everyone reads from; using a sandbox environment specifically for code storage and execution, keeping code artifacts separate from the natural-language reasoning context; and using a state object, which structures different kinds of information (task status, tool results, conversation excerpts) into distinct fields rather than one flat block of text.

The multi-agent approach to isolation connects directly to the multi-agent orchestration patterns and the Level 4 agentic autonomy concept covered elsewhere in this curriculum: one of the real benefits of splitting a task across multiple specialized agents isn't just parallelism or specialization of skill — it's that each agent gets its OWN, smaller, more focused context, rather than one agent having to hold instructions, retrieved documents, tool outputs, and full conversation history all in the same undifferentiated space simultaneously.

Taken together, all four stages — Write, Select, Compress, Isolate — describe what it actually means to 'engineer a context pipeline,' as this course puts it: making sure the LLM gets to see the right information, in the right format, at the right time, rather than treating the context window as a single undifferentiated dumping ground for everything that might conceivably be relevant.

from dataclasses import dataclass, field

@dataclass
class IsolatedContext:
    """A state object that isolates context BY TYPE, instead of one
    flat block of mixed text — the model can't confuse an instruction
    for retrieved data if they live in clearly separate fields."""
    system_instructions: str
    retrieved_data: list[str] = field(default_factory=list)
    conversation_history: list[dict] = field(default_factory=list)
    tool_outputs: dict[str, str] = field(default_factory=dict)

    def to_prompt(self) -> str:
        # Assembled with clear boundaries — not silently mixed together
        return (
            f"### INSTRUCTIONS\n{self.system_instructions}\n\n"
            f"### RETRIEVED DATA\n" + "\n".join(self.retrieved_data) + "\n\n"
            f"### TOOL RESULTS\n" + "\n".join(f"{k}: {v}" for k, v in self.tool_outputs.items()) + "\n\n"
            f"### CONVERSATION HISTORY\n" + "\n".join(f"{m['role']}: {m['content']}" for m in self.conversation_history)
        )

ctx = IsolatedContext(
    system_instructions="You are a support assistant. Never invent order numbers.",
    retrieved_data=["Return policy: 30 days from purchase."],
    tool_outputs={"lookup_order": "Order #4471: shipped 2 days ago"},
)
print(ctx.to_prompt())  # instructions, data, and tool results stay clearly separate