/delegate

You orchestrate. Specialists do the work.

Reference pattern for invoking multiple AI tools and synthesizing their outputs.

Your Role

You don't analyze/review/audit yourself. You:

Route — Send work to appropriate specialists
Collect — Gather their outputs
Curate — Validate, filter, resolve conflicts
Synthesize — Produce unified output

Your Team

Codex CLI — Implementation Agent

Fire-and-forget delegation for implementation work:

codex exec --full-auto "Implement X following the pattern in Y. Run pnpm typecheck after." \
  --output-last-message /tmp/codex-out.md 2>/dev/null

Task	Reasoning Effort
Boilerplate, CRUD	`medium`
Features, tests	`high` (default)
Complex debug, security	`xhigh`

codex exec --full-auto -c model_reasoning_effort=xhigh "Debug this race condition"

Task Tool — Parallel Agent Spawning

For parallel work within Claude Code:

Task({ subagent_type: "general-purpose", prompt: "Backend API review" })
Task({ subagent_type: "general-purpose", prompt: "Frontend component audit" })
Task({ subagent_type: "general-purpose", prompt: "Test coverage analysis" })

Multiple Task calls in a single message run in parallel.

Gemini CLI — Researcher, deep reasoner

Web grounding, thinking_level control, agentic vision
Best at: current best practices, pattern validation, design research
Invocation: gemini "..." (bash)

Non-Agentic (Opinions Only)

Thinktank CLI — Expert council

Multiple models respond in parallel, synthesis mode
Best at: consensus, architecture validation, second opinions
Invocation: thinktank instructions.md ./files --synthesis (bash)
Note: Cannot take action. Use for validation, not investigation.

Agent Teams — Full Claude Code Teammates

When workers need to communicate, challenge each other, or coordinate across layers.

Start a team: Describe the task and team structure in natural language. Claude handles spawning.

Lead in delegate mode: Shift+Tab after team creation. Lead coordinates only.

Plan approval: For risky work, require teammates to plan before implementing. Lead reviews and approves/rejects plans.

When to use over Codex CLI / Task tool:

Signal	Teams	Codex CLI / Task
Workers must discuss findings	YES	no
Competing hypotheses / debate	YES	no
Cross-layer (FE+BE+tests)	YES	no
"Implement this spec"	no	YES
Result-only, no coordination	no	YES

Internal Agents (Task tool)

Domain specialists for focused review:

go-concurrency-reviewer, react-pitfalls, security-sentinel
data-integrity-guardian, architecture-guardian, config-auditor

How to Delegate

Apply /llm-communication principles — state goals, not steps:

To Codex (via CLI)

Give it latitude to investigate:

"Investigate this stack trace. Find root cause. Propose fix with file:line."

NOT:

"Step 1: Read file X. Step 2: Check line Y. Step 3: ..."

To Thinktank (Non-Agentic)

Provide context, ask for judgment:

"Here's the code and proposed fix. Is this approach sound?
What are we missing? Consensus and dissent."

Parallel Execution

Run independent reviews in parallel:

Multiple Task tool calls in same message
Gemini + Thinktank can run concurrently (both bash)

Dependency-Aware Orchestration

For large work (10+ subtasks, multiple phases), use DAG-based scheduling:

The Pattern

Phase 1 (no deps):    Task 01, 02, 03 → run in parallel
Phase 2 (deps on P1): Task 04, 05     → blocked until P1 complete
Phase 3 (deps on P2): Task 06, 07, 08 → blocked until P2 complete

Key principles:

Task decomposition — Break feature into atomic subtasks
Dependency graph — DAG defines execution order
Parallel execution — Independent tasks run simultaneously
Fresh context — Each subagent starts clean (~40-75k tokens)

Step 1: Decompose

Split feature into atomic tasks. Ask:

What can run independently? → Same phase
What requires prior output? → Blocked

Step 2: Declare Dependencies

Use TaskCreate/TaskUpdate primitives:

TaskCreate({subject: "Install packages", activeForm: "Installing packages"})
TaskCreate({subject: "cRPC builder", activeForm: "Building cRPC"})
TaskUpdate({taskId: "2", addBlockedBy: ["1"]})  # Task 2 waits for Task 1

Step 3: Execute Phases

Spawn all unblocked tasks in single message:

# Phase 1 - all parallel via Task tool
Task({ subagent_type: "general-purpose", prompt: "Task 1: ..." })
Task({ subagent_type: "general-purpose", prompt: "Task 2: ..." })
Task({ subagent_type: "general-purpose", prompt: "Task 3: ..." })

Step 4: Progress

After each phase:

Mark completed tasks: TaskUpdate({taskId: "1", status: "completed"})
Check newly-unblocked: TaskList()
Spawn next phase

When to Use DAG Orchestration

Scenario	Use DAG?
Large migration (10+ files, phases)	✅ Yes
Multi-feature release	✅ Yes
Single feature (1-5 files)	❌ Overkill
Quick fix	❌ Overkill

For typical feature work, simple parallel spawning is sufficient.

Curation (Your Core Job)

For each finding:

Validate: Real issue or false positive? Applies to our context? Filter: Generic advice, style preferences contradicting conventions Resolve Conflicts: When tools disagree, explain tradeoff, make recommendation

Output Template

## [Task]: [subject]

### Action Plan

#### Critical
- [ ] `file:line` — Issue — Fix: [action] (Source: [tool])

#### Important
- [ ] `file:line` — Issue — Fix: [action] (Source: [tool])

#### Suggestions
- [ ] [improvement] (Source: [tool])

### Synthesis

**Agreements** — Multiple tools flagged:
- [issue]

**Conflicts** — Differing opinions:
- [Tool A] vs [Tool B]: [your recommendation]

**Research** — From Gemini:
- [finding with citation]

When to Use

Code review — Multiple perspectives on changes
Incident investigation — Agentic tools investigate, Thinktank validates fix
Architecture decisions — Thinktank for consensus
Audit/check tasks — Parallel investigation across domains

Note

Codex delegation uses the CLI (codex exec). For parallel work within Claude Code, use the Task tool with subagent_type: "general-purpose".

/llm-communication — Prompt writing principles
/review-branch — Example implementation
/thinktank — Multi-model synthesis
/codex-coworker — Codex delegation patterns

delegate