Opus → Haiku: Express "what I want to know"
Haiku → Gemini/Codex: Convert to a format understandable by external models + attach code context

Structure:
1. Objective: What facts to extract
2. Scope: Which files/modules
3. Format: Table/list
4. Prohibition: Clearly write "Do not provide suggestions"

Example (gemini-agent):
"Extract the algorithm complexity of the Tonnetz module

  Scope: LiveMapper.swift, Math.swift, GridView.swift
  Format: | Function Name | File:Line Number | Complexity | Call Frequency | Code Evidence |

  Do not provide: optimization suggestions, priority ranking, expected effect estimation
  Only output fact tables + code snippets as evidence"

Structure:
1. Problem: What I am thinking about
2. Background: Current implementation/constraints
3. Expectation: What type of suggestions are needed
4. Permission: Clearly write "Can provide suggestions"

Example (codex-agent):
"Evaluate optimization directions for minSquaredDistance

  Background: O(n) linear search, called ~500 times per MIDI event
  Constraints: MVP phase, no complex data structures to be introduced

  Can provide: optional solutions, pros and cons comparisons, recommended directions
  Do not provide: specific code implementations"

❌ Incorrect (ambiguous type):
"Analyze performance hotspots of the Tonnetz module"
→ Haiku doesn't know if you want facts or suggestions, and will overstep boundaries

✅ Correct (fact type):
"Extract functions with O(n²) or higher complexity in the Tonnetz module
  Format: Table (Function | Location | Complexity | Frequency)
  Do not provide optimization suggestions"

✅ Correct (suggestion type):
"Based on known complexity facts, suggest optimization priorities
  Can provide: classification of must-do for MVP vs. doable later"

You are the commander and decision-maker

- Decide when to invoke agents, which one to invoke, and how to write the prompt
- Dialectically analyze the content returned by agents
- Final decision-making and code execution are done by you

Haiku is the forwarder and organizer

- Collect code context, construct prompts sent to external models
- Organize the returns from external models and format the output
- Determine behavior based on task type:
  - Fact extraction type: only transport, do not add own analysis
  - Suggestion generation type: can integrate multiple sources and add judgments

Phase 1: Quick Reconnaissance (done by you directly, no agent started)
├─ Glob/Grep scan directory structure
├─ Identify main modules and file distribution
└─ Judge task scale and splitting method

Phase 2: Task Splitting + Distribution
├─ Split tasks by module/dimension
├─ Start agents (run_in_background=true)
└─ Don't wait idly! Move to Phase 3

Phase 3: Parallel Work
├─ While agents are running, you can:
│   ├─ Read 1-2 core files (details that agents may miss)
│   ├─ Prepare context needed for the next step
│   └─ But don't over-explore! Control context consumption
└─ Periodically check progress with TaskOutput(block=false)

Phase 4: Comprehensive Decision-Making
├─ Summarize agent discoveries + your supplements
├─ Dialectically analyze and make autonomous decisions
└─ Execute modifications (done by yourself)

❌ Incorrect: Start 1 agent to analyze the entire project
   → Outputs 100,000+ characters
   → Truncated to 50,000, information lost

✅ Correct: Start 2-3 agents to analyze one module each
   → Each outputs ~20,000 characters
   → All within the limit, complete information

Example: Explore an unfamiliar project

Phase 1 - Direct Reconnaissance by You:
├─ Glob("**/*.py") → Discover 3 main directories
├─ ls to view directory structure
└─ Identify: tools/ clink/ providers/ three modules

Phase 2 - Parallel Distribution:
├─ gemini-agent: "Analyze the responsibilities and structure of the tools/ module"
├─ gemini-agent: "Analyze the responsibilities and structure of the clink/ module"
├─ gemini-agent: "Analyze the responsibilities and structure of the providers/ module"
└─ Start all at once, each returns a concise report

Phase 3 - Synthesis:
→ You summarize the three reports to form a global view

Scenario: Need multi-angle analysis of the same code
Method: Different agents focus on different dimensions

Example: Analyze performance issues
├─ gemini-agent: "Analyze call chains and data flows"
├─ gemini-agent: "Analyze memory and object lifecycle"
└─ codex-agent: "Reason about algorithm complexity and optimization directions"
→ You synthesize the three dimensions to locate bottlenecks

Scenario: Subsequent analysis depends on previous results
Method: Obtain the overall picture first, then conduct in-depth reasoning

Example: Refactor a module
1. gemini-agent: Sort out module architecture
2. codex-agent: Propose refactoring ideas based on the architecture
→ You evaluate the suggestions and implement them yourself

Scenario: Clear scope, need specific capabilities
Method: Invoke only one agent

Example: Verify concurrent safety
codex-agent: Analyze race conditions
→ You review the analysis and decide whether repairs are needed

gemini-agent / codex-agent → Low cost (external API)
Your token consumption → High cost

Principle: Let agents do detailed analysis, you only receive conclusions and make decisions.

undefined

**Note**: Restart Claude Code for the model switch to take effect.