Orchestrating Agentic Swarms: Decoupling Orchestration from Context via Claude Code Workflows

The primary bottleneck in long-running LLM interactions has historically not been the absolute size of the context window, but rather the "context bloat" generated by iterative tool use, MCP (Model Context Protocol) outputs, and extended reasoning traces. Even with a 1-million-token ceiling, the accumulation of intermediate state, tool logs, and unstructured conversational history creates a high-entropy environment that degrades model performance and increases latency.

The recent release of Claude Code Workflows introduces a paradigm shift in how we manage agentic complexity. By moving the orchestration layer from the LLM's conversational context to a deterministic, programmatic execution environment, Claude Code allows for the deployment of massive, multi-stage agentic swarms that maintain high precision without polluting the primary session.

The Sub-Agent Architecture: Context Isolation

At the core of the Workflow feature is the concept of the sub-agent. In a standard Claude session, every tool call and response is appended to the main conversation history. As the session progresses, the "noise" of previous iterations consumes the effective reasoning capacity of the model.

Sub-agents solve this through context isolation. When a workflow is invoked, the system spawns a fresh Claude Code session with its own independent context window. This allows the sub-agent to perform high-token-density tasks—such as deep web crawling, large-scale code analysis, or complex data extraction—without ever injecting that intermediate "junk" into the main window.

Consider a practical token-reduction metric: a sub-agent might process a 60,000-token task involving multiple tool calls and web fetches, but only return a synthesized 500-token summary to the primary orchestrator. This prevents the need for frequent context compaction and preserves the high-signal integrity of the main session.

From LLM-as-Manager to Script-as-Orchestrator

Traditionally, agentic orchestration has relied on the LLM itself to act as the "manager." In this model, the LLM must track the state of every sub-agent, manage the queue of requests, and handle the results of each task. As the number of agents increases, the manager's context window becomes overburdened with the intermediate state of the entire swarm, leading to a breakdown in orchestration logic.

Claude Code Workflows replaces this LLM-centric manager with a deterministic orchestration layer powered by a workflow.js script. In this new architecture:

1. State Management: The state is held within JavaScript variables and a persistent journal, rather than within the LLM's conversational history.
2. Deterministic Loops: The logic for iterating through tasks, handling retries, and managing concurrency is defined programmatically.
3. The Journaling System: The inclusion of a journal allows for the state of a workflow to be paused and resumed. This is critical for long-running tasks that may exceed a single session's duration or require human intervention.

At runtime, the workflow.js file executes as a separate process. It loads the logic, spawns the required agents, and manages the lifecycle of the swarm. Notably, while the agents themselves possess tool-use capabilities (including shell and file system access), the workflow.js script itself does not have direct file system or shell access, providing a layer of structural separation between the orchestration logic and the execution environment.

Multi-Stage Adversarial Workflows: A Case Study

The true power of this architecture is visible in complex, multi-stage "Deep Research" workflows. A sophisticated workflow can be structured into distinct, specialized phases:

• Phase effectively: Scope: The initial agent breaks down a high-level query into specific research angles.
• Phase: Fetch: Parallel agents execute web searches and extract data, performing URL deduplication and claim extraction.
• Phase: Verify (Adversarial Pattern): This is the most computationally expensive stage. Using an adversarial verification pattern, the system spawns multiple independent agents to act as "critics." For every claim extracted, a three-agent vote is conducted. A claim is only accepted if it achieves a 2/3 consensus, effectively mitigating hallucinations through distributed consensus.
• Phase: Synthesize: A final agent aggregates the verified data into a coherent report.

In a recent demonstration, a single research task involving 105 agents consumed over 3.1 million tokens within 15 minutes. While the token cost is significant, the depth of the resulting research—driven by the ability to fan out across hundreds of parallel verification agents—is unattainable through standard single-session prompting.

Model Heterogeneity and Tiered Execution

Claude Code Workflows enables model-tiering, allowing developers to optimize for both cost and intelligence by assigning different models to different phases of the workflow.

A highly efficient workflow might utilize a tiered approach:

1. Discovery/Brainstorming: Use Claude 3 Haiku to rapidly generate a high volume of candidates or initial search queries.
2. Critique/Analysis: Use Claude 3.5 Sonnet to score, analyze, or perform complex reasoning on the generated data.
3. Synthesis/Final Output: Use Claude 3 Opus to write the final, high-fidelity report or complex code implementation.

By programmatically defining the model parameter for each agent call within the workflow.js file, developers can build pipelines that are both economically viable and intellectually robust.

Technical Constraints and Scalability

While the potential for scaling is massive, there are current architectural constraints to consider:

• Concurrency Limit: There is a hard limit of 16 concurrent agents per workflow.
• Total Agent Capacity: A single workflow run can manage up to 1,000 total agents.
• Environment: Currently, workflows are most effective when running via the Claude Code desktop app or the terminal-based IDE interface; VS Code extension support for this specific orchestration layer is still evolving.

Conclusion: The Future of Agentic Engineering

Claude Code Workflows represents a transition from "Chat-based AI" to "Agentic Engineering." By treating LLM orchestration as a software engineering problem—using scripts, variables, and deterministic loops—we can move beyond the limitations of the context window. For developers, this opens the door to massive-scale bug sweeps, automated PR reviews, and complex, multi-stage research pipelines that operate with the reliability of traditional software while leveraging the reasoning power of the Claude model family.