Architecting Agentic Workflows: Leveraging Hierarchical Multi-Agent Orchestration with Claude 3.5 Haiku and Opus
The paradigm of Large Language Model (LLM) utilization is shifting from single-prompt inference to complex, multi-agent orchestration. As the cost of high-reasoning models like Anthropic's Claude 3 Opus remains significant, a new architectural pattern has emerged: the "Brain and Hands" framework. By utilizing a high-parameter, high-reasoning model (the Brain) to manage a fleet of low-cost, high-throughput sub-agents (the Hands), developers can achieve massive parallelization and scale execution without the linear cost increases typically associated with complex tasks.
The Economic Arbitrage of Model Tiering
The core driver behind this architectural shift is the extreme delta in token pricing between model tiers. In the current ecosystem—specifically looking at the Claude 3.5 era—the price discrepancy between a flagship model like Opus and an efficient executor like Haiku is approximately 40x.
To quantify this, consider the following input/output cost metrics:
- Opus Tier: ~$4.00 per million input tokens / ~$20.00 per million output tokens.
- Haiku Tier: ~$0.10 per million input tokens / ~$0.50 per million output tokens.
By offloading the "heavy lifting"—the high-volume, repetitive execution of code or text generation—to Haiku sub-agents, you effectively pay for the cognitive planning at Opus prices while executing the bulk of the token-intensive work at a 97.5% discount. This allows for an agentic workflow where the primary model (Opum) acts as a director/planner, and the secondary models (Haiku) act as executors.
Case Study 1: The Interdependency Bottleneck (The 3D House)
A common pitfall in multi-agent orchestration is attempting to parallelize tasks that possess high structural interdependency. In an experiment involving the generation of a 3D house via Three.js from a hand-drawn floor plan, two setups were tested: a single Opus instance and an orchestrated cluster of one Opus model managing ten Haiku sub-agents.
The Results:
- Opus Alone: ~18 minutes, $3.84 cost, 2.45M tokens.
- Orchestrated (Opus + 10 Haiku): ~19 minutes, ~$4.84 cost, ~8M tokens.
In this instance, the sub-agent approach was actually slower and more expensive. The failure point was architectural: a 3D house is a highly coupled system. Walls must support roofs; furniture must reside within floor boundaries. Because Opus had to write interfaces first and then validate every piece against those interfaces, the "Brain" spent massive amounts of tokens (5M+) simply reading back and reconciling the work of the sub-agents. When tasks cannot be completed in isolation, the overhead of orchestration outweighs the benefits of parallel execution.
Case Study 2: Decoupled Modular Execution (The Procedural City)
Conversely, when the task is decomposed into decoupled modules, the "Hands" architecture excels. In a test generating an endless, procedurally generated browser-based city, the workload was split into twelve distinct modules (roads, rivers, trunk systems, etc.) that functioned with minimal cross-dependency.
The Results:
- Opus Alone: ~37 minutes, $6.12 cost.
- Orchestrated (Opus + 12 Haiku): ~26 minutes, ~$7.27 total cost ($1.81 for the sub-agents).
Here, the sub-agent approach was significantly faster. The "Brain" spent only a few minutes planning and distributing the workload, allowing the twelve Haiku agents to execute their specific modules simultaneously. While the total token count rose (with helpers generating 16M tokens), the cost of those 16 million tokens was only $1.81—a fraction of what it would have cost to process that volume through Opus.
Case Study 3: Maintaining Stylistic Unity (Motion Graphics)
The third challenge in multi-agent systems is "stylistic drift." In a test generating a 20-second motion graphics piece using FFmpeg and code-based animation, the goal was to ensure ten different sub-agents produced scenes that felt like a single cohesive film.
The success of this experiment relied on a specific implementation: The Single Brief Principle. Instead of allowing each Haiku agent to interpret the creative direction, Opus generated one master specification—a shared document containing color palettes, timing, and musical beats. Every helper read this brief before execution. This ensured that while the content was distributed across ten agents, the taste remained centralized in a single source of truth.
Implementation: Configuring Sub-Agent Models
Implementing this architecture within an IDE like Cursor or via Cloud Code is remarkably straightforward. By modifying the settings.json file, developers can force specific models for sub-agent tasks.
By injecting a command into the receipts section of your configuration, you can define the sub-agent model as Haiku. From that point forward, any task spawned by the primary agent (the "Brain") will automatically utilize the Haiku tier for execution, effectively automating the hierarchical delegation.
The Three Golden Rules of Agentic Orchestration
To successfully implement a high-scale, low-cost AI architecture, developers should adhere to these three principles:
- Add Hands when parts are decoupled: Only use sub-agents when the modules do not require real-time structural interdependence (e.g., independent software modules vs. interdependent 3D geometry).
- Buy Tries with low-cost tokens: Use Haiku to run hundreds of iterations or "trial and error" loops. When a single attempt costs cents, you can afford massive-scale experimentation that would be economically impossible on higher-tier models.
- Maintain one Director for taste: Always use a high-reasoning model (Opus/Sonnet) to write the master brief. If the "taste" or logic is decentralized among sub-agents, the resulting output will lack cohesion.
By treating LLMs not as single-use tools, but as a hierarchical workforce of managers and executors, we can achieve what appears to be superintelligent scale for a fraction of the traditional computational cost.