Multi-agent orchestration: coordinator pattern for Claude/Codex/OpenCode

[heyramzi]

The idea

Orca already runs Claude Code, Codex, and OpenCode side by side in terminals with git worktree isolation. What if it could coordinate work between them automatically?

The pattern — pioneered by Augment Intent (closed-source, Mac-only) — works like this:

1. User writes a spec or describes a task
2. A coordinator agent reads the codebase, decomposes the task into subtasks with dependency ordering
3. Specialist agents execute subtasks in parallel, each in its own worktree
4. Results merge back automatically with conflict resolution
5. The spec updates to reflect completed work

No open-source desktop coding environment does this natively today. Orca is uniquely positioned because it already has the foundations:

• Multiple agent terminals running simultaneously
• Git worktree support per agent
• Agent Explorer panel (feat: add Agent Explorer panel to right sidebar #648) — already reads .claude/ config for agents, skills, commands
• Managed account switching per agent ([codex] add managed OpenCode Go account switching #657)
• Terminal session preservation across worktrees (fix: preserve terminal sessions when switching worktrees #535)

What exists today (external tools)

I've been researching the multi-agent orchestration landscape:

Tool	Approach	Handoff?	Open source?
Augment Intent	Coordinator → specialist agents	Automatic	No
Multica	Task board + daemon	Manual reassignment	Yes
Overstory	SQLite mailbox + tmux	Automatic via messages	Yes
Gas Town	Mail system + roles	Automatic via inbox	Yes
Agent of Empires	tmux session manager	None (parallel only)	Yes

See also: Awesome Agent Orchestrators

What Orca could build

A lightweight orchestration layer that sits above the existing terminal infrastructure:

Phase 1: Inter-agent messaging

• Simple message bus between agent terminals (SQLite or in-memory)
• Agent A can send structured messages to Agent B
• Human (user) has an inbox showing agent notifications

Phase 2: Task decomposition

• Accept a spec/issue as input
• Use the coordinator agent (e.g., Claude with Opus) to decompose into subtasks
• Route subtasks to the right terminal/agent based on capability

Phase 3: Automated handoff

• Agent A finishes implementation → auto-triggers Agent B for review
• Agent B approves → auto-triggers merge of worktree branches
• Conflict resolution with tiered strategy (auto-resolve → agent-assisted → human)

Phase 4: Living specs

• Specs update as agents complete work
• Progress visible in a unified view

Why Orca specifically?

Orca is the only open-source desktop environment that:

1. Already runs multiple coding agents in parallel with proper terminal management
2. Has worktree isolation built in
3. Has an agent config browser (Agent Explorer)
4. Is actively building multi-account agent management

The missing piece is the glue — the coordinator that makes the agents collaborate instead of just coexisting.

Cost-efficient model routing

From benchmarking research (Artificial Analysis Coding Index), the optimal setup routes different models to different roles:

Role	Model	Cost/1M tokens	Why
Coordinator	Claude Opus 4.6	~$10	Best reasoning, used sparingly
Builder	MiMo-V2-Pro	~$1-3	80% cheaper than Sonnet, strong coding
Reviewer	GLM-5.1	~$1-3	#1 SWE-Bench Pro (58.4%)
Runner	MiniMax M2.5 free	$0	Renames, formatting, grunt work

This hierarchical approach achieves ~97% of full-frontier accuracy at ~61% of the cost (source).

Discussion questions

1. Does this align with where Orca is headed?
2. Should orchestration be built into core, or as a plugin/extension?
3. What's the right messaging protocol between agents — SQLite, IPC, filesystem-based?
4. Should the coordinator be a dedicated agent or any agent can coordinate?

Happy to contribute to implementation — I've been working on the agent infrastructure PRs and have a working Multica setup across 9 repos that could inform the design.

---

References: Augment Intent · Multica · Overstory · Gas Town · Awesome Agent Orchestrators · Addy Osmani — The Code Agent Orchestra

[heyramzi]

Additional context: the economic case for multi-model orchestration

One more reason this matters beyond pure capability — AI model subsidies are shrinking.

Right now, $200/month subscriptions give you inference worth $500-$1,000+ (source). That won't last. As subsidies reduce, you can't rely on one model anymore — the economics force multi-model routing:

Task complexity	Model	Real cost/1M tokens
Architecture, planning	Claude Opus 4.6	~$10
Implementation	MiMo-V2-Pro	~$1-3
Code review	GLM-5.1	~$1-3
Terminal/builds	GPT-5.3 Codex	~$1.25
Research	Gemini 3 Flash	~$1.1
Grunt work (renames, formatting)	MiniMax M2.5	$0 (free)

Using Opus for everything at $10/1M would cost **$20 per task** (avg 2M tokens). The hierarchical approach above achieves 97.7% of frontier accuracy at 61% of the cost.

This is why orchestration needs to be model-aware — the coordinator should route work to the cheapest model that can handle it. Orca already knows which agent is in which terminal. Adding cost-aware routing would be a differentiator no other open-source tool has.

Key insight from Artificial Analysis: DeepSeek V4 achieves ~90% of GPT-5.4 performance at 1/50th the input cost. GLM-5.1 is #1 on SWE-Bench Pro while costing 1/5th of Opus. The frontier is no longer just about the best model — it's about the best model per dollar per task type.

[timerloggedout-spec]

Commenting for updates.

Have similar concepts integrating.

Working in Termux environment.

Edit:
Also; searching for 'seeded' repo's intended for synthesis.

Edit 2:
How are you calculating expected complexity scores?

[heyramzi]

The CLI primitives are already there

Just tested this — orca terminal list already exposes every named agent terminal (CLAUDE, CODEX, OPENCODE, GEMINI) with live handles. The full orchestration handoff is scriptable today with three commands:

# Resolve terminals by name
CLAUDE=$(orca terminal list --json | jq -r '.result.terminals[] | select(.title == "CLAUDE") | .handle' | head -1)
OPENCODE=$(orca terminal list --json | jq -r '.result.terminals[] | select(.title == "OPENCODE") | .handle' | head -1)
CODEX=$(orca terminal list --json | jq -r '.result.terminals[] | select(.title == "CODEX") | .handle' | head -1)

# 1. Architect builds
orca terminal send --terminal $CLAUDE --text "implement dark mode per spec" --enter
orca terminal wait --terminal $CLAUDE --for exit --timeout-ms 3600000

# 2. Hand off to reviewer
orca terminal send --terminal $CODEX --text "review the changes in branch feat/dark-mode" --enter
orca terminal wait --terminal $CODEX --for exit

# 3. Scout researches in parallel (no wait needed)
orca terminal send --terminal $OPENCODE --text "find all existing theme tokens in the codebase" --enter

No Multica, no tmux scripts, no external daemon. The loop runs on top of Orca's own runtime.

What's actually missing is the GUI

The CLI works. What doesn't exist yet is a visual representation of the handoff flow — something like:

[CLAUDE: implementing...] ──► [CODEX: reviewing...] ──► [merge]
                                     ▲
                              [OPENCODE: researching...]

A panel in Orca that shows:

• Which agent is currently running
• What task it received
• The dependency graph between steps
• One-click handoff (send to next agent) or automatic trigger on terminal exit

This is a thin UI layer on top of orca terminal send/wait/read — the hard infrastructure is done. The value Orca could add is making this flow visible and controllable without writing shell scripts.

For comparison, this is exactly what Augment Intent does — but it's closed-source and opaque. An open version with Orca's terminal transparency would be significantly more useful.

[heyramzi]

Sorry for the AI slop but it would be amazing if we thought on a better GUI/Flow/System for that

[hosamsh]

I'm curious if it makes sense to start with a simpler setup, for instance, each step just hands off the task at hand + a change summary to the next agent. Without sophisticated notifications and shared memory, just filesystem and logs.

[Jinwoo-H]

We've added experimental orchestration capabilities to our Orca CLI, feel free to install the skill and try it out! (in Settings -> Experimental -> Agent Orchestration) https://github.com/stablyai/orca/blob/main/skills/orchestration/SKILL.md

[chansantheman]

I think https://bernstein.run/blog/orchestrator-vs-desktop-ade does a another great angle of orchestration benefit.