Let say we have huge task or coding task if we ask a single agent to do it with same context
An agent works like this:
- It keeps a history (context) of everything it has seen/done
- Every next decision = function of that history
So mathematically: next_action = f(all_previous_context)
As the task grows:
- context size ↑
- irrelevant info ↑
- contradictions ↑
This leads to: Signal vs Noise collapse
The agent can’t distinguish:
- what matters now
- what mattered 50 steps ago
If the same agent:
- writes code
- then checks its own code
Its evaluation is biased by its own past reasoning.
Break the system into roles
1. Planning (What should be done?)
- Understand goal
- Break into steps
2. Execution (Do the work)
- Write code
- Implement features
3. Evaluation (Check correctness)
- Test behavior
- Find bugs
The loop (this is the real architecture)
Now combine everything.
The system runs like this:
Phase 1: Plan
- Orchestrator defines:
- validation contract
- features
- milestones
Phase 2: Execute For each feature:
- spawn worker (fresh context)
- implement
Phase 3: Validate
- spawn validators (fresh context)
- test behavior
Phase 4: Fix loop
If issues found:
- orchestrator creates fix features
- workers implement again
- validators re-check
This loop continues until: validation == pass