Originally published on tamiz.pro.
The field of AI agents has moved rapidly from single-model executors to complex multi-agent orchestration.
But after running 157 agent deployments across diverse task domains, one pattern emerged with striking consistency: planning quality predicts success far better than execution speed or model size.
This isn't just theoretical—it's a practical lesson that's reshaping how engineers architect agent fleets, giving rise to what we're now calling Orca-style agents: hierarchical, planning-first systems that separate the expensive business of thinking from the cheaper business of doing.
The Experiment: 157 Agent Runs Over six months, our team deployed and monitored 157 distinct agent runs across four primary use cases: code generation pipelines, automated testing workflows, infrastructure-as-code provisioning, and data transformation tasks.
Each run varied along three dimensions: Architecture: Single-agent vs. flat multi-agent vs. hierarchical (Orca-style) Planning depth: No planning, brief intent statement, or full recursive planning loop Execution model: Direct LLM call per action vs. tool-augmented execution with validation The results were unambiguous.
Systems that invested 3-5x more tokens in planning achieved 4.2x higher task completion rates and 3.8x fewer rollback cycles compared to agents optimized purely for fast execution.
The correlation between planning sophistication and success held across every domain.
Why Planning Beats Raw Execution The intuition behind this finding rests on an economic principle of LLM usage: planning is cheap relative to costly mistakes.
A well-structured plan reduces the probability of executing the wrong sequence of tools, making incorrect API calls, or generating code that fails integration testing.
Consider the token economics: Phase Tokens (typical) Cost impact Planning (intent + decomposition) 800–2,500 Low Execution per subtask 300–1,200 Medium Correction after failure 1,500–4,000 High Agents that plan thoroughly front-load their costs.
Those that rush to execute often pay exponentially more in corrections, retries, and human intervention.
The Orca Architecture Pattern The name "Orca" comes from the hierarchical social structure of killer whales: a single matriarch orchestrates, while specialized pod members execute discrete tasks.
In agent terms, this translates to: Core Components Strategic Planner (the matriarch): Holds global context, decomposes goals, assigns subtasks, and validates outcomes.
Runs on a stronger model with longer context windows.
Specialist Executors (the pod): Each handles a narrow domain—code generation, test writing, documentation, validation.
Run on smaller, cheaper models optimized for throughput.
Shared Memory Layer: A structured knowledge graph or vector store that maintains state across the fleet, preventing redundant work and enabling cross-agent learning.
Orchestration Loop: A lightweight controller that routes tasks, aggregates results, and triggers replanning when validation fails.
Why This Separation Matters The critical insight is that not all thinking is equal.
Strategic decisions—understanding requirements, identifying edge cases, sequencing dependencies—benefit from deep context and reasoning.
Tactical decisions—formatting output, calling a specific API, generating a template—are better handled by focused, optimized models.
Separating these concerns allows you to: Run planners on premium models without paying premium prices for every action Scale executor capacity independently of planning capacity Implement targeted retry logic without restarting entire workflows Observe and debug planning failures separately from execution failures Implementation Patterns From the 157 runs, several implementation patterns emerged as particularly effective: Pattern 1: Recursive Decomposition with Validation Gates The planner decomposes a goal into subtasks, each with explicit success criteria.
Executors complete subtasks and return