Spawn Implementation Agents

Orchestrate specialized agents during implementation to keep main agent context under 40k tokens per phase.

The Problem

Without agents, implementing a phase uses ~92k tokens in main agent:

• •Read plan & changelog: 15k
• •Read existing code files: 30k
• •Find usage patterns: 15k
• •Write implementation: 10k
• •Write tests: 10k
• •Run verification: 10k
• •Update changelog: 2k

This approaches the 200k context limit and risks compaction.

The Solution

Use agents to isolate heavy operations:

• •Main agent: 38k tokens (plan + changelog + summaries + code writing)
• •Sub-agents: 60k tokens total (in isolated contexts)
• •Total system: 98k tokens (50% safety margin)

5-Phase Orchestration Pattern

Phase 1: Analysis (Parallel)

Spawn simultaneously to gather context:

Task(subagent_type="workflows:codebase-analyzer",
     prompt="Analyze existing auth system architecture.
     Focus on handler pattern, middleware usage, error handling.
     Return 2-3k summary with key patterns and file:line references.")

Task(subagent_type="workflows:codebase-pattern-finder",
     prompt="Find similar implementations of authentication handlers.
     Return 3k of concrete examples showing handler pattern, validation, errors.")

Task(subagent_type="workflows:thoughts-analyzer",
     prompt="Extract insights from changelog.md about previous phase learnings.
     Return 2k of key deviations and discoveries that affect this phase.")

Wait for all three. Main agent receives ~8k of summaries.

Phase 2: Implementation (Main Agent)

Main agent writes code using summaries:

• •Has patterns from codebase-pattern-finder
• •Understands architecture from codebase-analyzer
• •Knows previous deviations from thoughts-analyzer
• •Writes implementation: 10k tokens
• •Total so far: 15k (plan/changelog) + 8k (summaries) + 10k (code) = 33k

Phase 3: Testing (Sequential)

Spawn test writer:

Task(subagent_type="workflows:test-writer",
     prompt="Generate tests for AuthHandler following patterns in testing.md.
     Test functions: Login(), Logout(), ValidateToken().
     Return test code only, ~3k tokens.")

Main agent receives test code, integrates it. Total: 36k

Phase 4: Verification (Sequential)

Spawn verifier:

Task(subagent_type="Bash",
     prompt="Run verification commands from plan.md:
     - make test
     - make lint
     - make build
     Return concise summary: ✅ passed or ❌ failed with key errors only.")

Main agent receives pass/fail + errors. Total: 38k

Phase 5: Documentation (Main Agent)

Update changelog.md: 2k tokens. Final total: 40k

Token Budget Comparison

Guidelines

When to spawn in parallel:

• •Analysis phase (codebase-analyzer + pattern-finder + thoughts-analyzer)
• •Independent lookups (finding multiple unrelated examples)
• •Reading multiple unrelated files

When to spawn sequentially:

• •Test writing (needs implementation to be done first)
• •Verification (needs tests to be written first)
• •Operations that depend on previous results

What agents return:

• •Summaries, not raw data (2-5k tokens each)
• •Key patterns, not all files (concrete examples only)
• •Pass/fail + errors, not full output (1-2k tokens)

Benefits

• •60% token reduction per phase in main agent
• •Larger phases possible: 5-8 files instead of 3-5
• •Complex integrations supported: Agents find patterns
• •Large files OK: Agents handle reading (>2000 lines)
• •Safety margin: 100k tokens remaining in system

Important Notes

• •Main agent NEVER reads large files directly
• •Main agent orchestrates, sub-agents execute
• •Summaries are compressed, not exhaustive
• •This is guidance, not automation - user still in control