/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

Moonbridge MCP — Unified Agent Interface

One interface, multiple backends. Moonbridge wraps both Codex and Kimi:

Adapter	Strengths	When to Use
`codex`	Long-context, tool calling, security	Refactors, migrations, debugging, backend
`kimi`	Native vision, extended thinking	UI from designs, visual debugging, frontend

Single agent:

mcp__moonbridge__spawn_agent({
  "prompt": "...",
  "adapter": "codex",           // or "kimi"
  "reasoning_effort": "high"    // codex: low/medium/high/xhigh
  // OR
  "thinking": true              // kimi: extended reasoning
})

Timeout: Moonbridge defaults: Codex=30min, Kimi=10min. Override for edge cases:

Task	Timeout
Quick check	`60`
Large refactor	`3600`

mcp__moonbridge__spawn_agent({ ..., "timeout_seconds": 3600 })

Parallel agents (same or mixed adapters):

mcp__moonbridge__spawn_agents_parallel({
  "agents": [
    {"prompt": "Backend API", "adapter": "codex", "reasoning_effort": "high"},
    {"prompt": "Frontend UI", "adapter": "kimi", "thinking": true},
    {"prompt": "Tests", "adapter": "codex", "reasoning_effort": "medium"}
  ]
})

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.

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 Moonbridge Agents (Codex, Kimi)

Give them 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 moonbridge agents in same call (spawn_agents_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 moonbridge
mcp__moonbridge__spawn_agents_parallel({
  agents: [
    {prompt: "Task 1: ...", adapter: "codex"},
    {prompt: "Task 2: ...", adapter: "codex"},
    {prompt: "Task 3: ...", adapter: "kimi", thinking: true}
  ]
})

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

All Codex delegation goes through Moonbridge MCP. Use mcp__moonbridge__spawn_agent with adapter: "codex". This gives you:

Single interface for both Kimi and Codex
Mixed-adapter parallel spawning
Consistent parameter naming

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

delegate