Disclosure up front: I build agentproto, one of the
nine tools below. Every fact is dated and pulled from each project's own docs
or repo; where a competitor beats me, it says so in plain text. Corrections
welcome — file an issue, I'll fix it.
Most "best orchestrator" roundups rank. They hand you a leaderboard, crown a
winner, and leave you to discover three weeks later that the winner solves a
problem you don't have.
This one doesn't rank. It places. Because the awesome list has grown past
fifty entries and
half of them changed shape in the last six months — so the useful question was
never "which is best," it's "which one fits the specific way my setup hurts."
The one idea, if you remember nothing else:
A ranking tells you who won. A map tells you where you are. Two questions
locate any orchestrator on it — who checks the work, and who equips the
agents — and almost every tool answers one while quietly dodging the other.
Those two questions are the ones the landscape
piece ends on, and they're not
arbitrary. They're the two halves of the bottleneck that caps every agent
fleet: the judgment that decides "done" is true, and the plumbing that gets a
new capability to every agent instead of one. Everything else a tool advertises
— panes, voice, kanban swimlanes — is UX on top of how it answers those two.
Method: each project's own docs and repo, checked 2026-07-07 → 2026-07-14, plus
hands-on sessions where noted. Supervision rungs refer to
the ladder: L0 you watch, L1 watchdogs, L2
permission relay, L3 verifier loops, L4 external policy gates.
The two questions, and why the map has two axes instead of ten
Strip a tool's branding and it answers two questions or dodges them.
Question one — who checks the work? When the agent says "done," what decides
whether that's true? This is the supervision ladder: at the bottom (L0) the
checker is you, reading a diff; at the top (L4) it's a process the agent can't
see or sweet-talk, holding the commit until a gate passes. The rung is the
answer.
Question two — who equips the agents? When you give one agent a new tool or
skill, how many of the others get it for free? For almost every tool the answer
is zero — you rewire each agent by hand, which is the quiet serial tax nobody
puts on the pricing page. The vendors equip agents, but only inside their own
walls. Exactly one tool on this list distributes your tools to every agent;
that's its own companion piece.
Plot both and the field sorts into a shape, not a ranking. Cockpits answer
question one with your eyeballs and dodge question two. Steering tools give the
human a nicer surface and dodge both. Only the daemon shape can even reach the
top-right corner — and only one is standing there. Let's walk the map.
The daemons: the only shape that can answer both
A daemon is a long-lived process that owns sessions behind an API. It's the only
shape that can run unattended — which is the only shape that can answer
question one above rung L2, and question two at all.
agentproto (disclosure: mine)
Local daemon + CLI, Apache-2.0, 0.5.0-alpha. Nine adapters under one manifest
contract (Claude Code, Claude SDK with Anthropic/Moonshot/OpenRouter gateways,
Codex, Hermes, opencode, Mastra Code + Agent, browser-as-agent). The three bets
are exactly the two questions plus the safety to delegate them:
- Checks the work: L4. A completion policy attaches to a session; at turn-end a gate fires — a shell command (lint/tests/typecheck) or a skeptical judge model — and the commit is staged behind a human ack. It runs on the daemon, so it survives your laptop closing.
- Equips the agents: yes — and this is the rare one. You author a tool once (a TOOL contract + a DRIVER implementation, plain files) and the daemon serves it over MCP to every agent; external MCP servers can be imported and handed to any agent at spawn. Write once, every agent gets it.
- Role-gated nested orchestration: executors can't spawn, supervisors can (with depth and children caps), so an agent can safely manage a team without fork-bombing your machine.
Weaknesses, honestly: alpha APIs that will move under you, no mobile client, no
voice, terminal-native UX only. And of ~52 numbered AIP specs, the daemon plus
core adapters are operational — the rest is early scaffolding. If your
bottleneck is steering from a phone, this is the wrong tool; keep reading.
Paseo — the strongest steering tool on this list
The other real daemon, and — credit where it's due — the best tool here for
driving agents from anywhere. 10.3k★ (as of 2026-07-13), AGPL-3.0, a one-man
company. Daemon plus
desktop / iOS / Android / web / CLI clients, QR pairing, voice control (local or
OpenAI STT/TTS), an official Docker image, and a self-hostable web UI. Five
first-class providers (Claude Code, Codex, Copilot, OpenCode, Pi) plus custom
ones — custom binaries, ACP agents, Anthropic-compatible endpoints like Z.AI and
Qwen. Recurring schedules with run history. Its MCP server is opt-in
(daemon.mcp.enabled) so Claude Desktop or Code can drive it.
I didn't just read the docs — I installed it and ran the permission relay end to
end. Launch an agent in always-ask mode, watch it freeze on a Write, approve
from another terminal with paseo permit allow, task completes. It works
exactly as advertised.
Two gotchas from the actual session (2026-07-13). The default Claude model
is Opus, so our one-word"hi"cost $0.29 before we'd typed a real prompt.
And everyrunspins up a fresh workspace unless you pass--workspace. Full
log in the hands-on review.
Now place it on the map. Checks the work: L2/L3 — it relays the agent's own
permission prompts to a nicer surface, plus a Ralph-loop skill with an optional
verifier. There's no L4: no daemon-side turn-end gate, no commit staging.
Equips the agents: no — injectIntoAgents pushes Paseo's control tools
into agents, but there's no way to write your tool once and have every agent
get it. So: unbeatable at question one's ergonomics, silent on question two. If
your bottleneck is steering from the couch, stop here — it's excellent.
The cockpits: your eyeballs are the checker
A cockpit is an interface you sit inside and review from. Every one answers
question one with "you, watching" (rung L0) and question two with "you, rewiring
each agent by hand." That's not a knock — for exploratory work L0 is the right
rung. It's a ceiling, and the ceiling is your own attention.
The ceiling, measured. Tools whose supervision model is "a human watches
each pane" have no programmatic API, no per-turn gates, and state that
evaporates when the app closes — the ladder piece has the exact
wall. Teams then hand-roll tmux-plus-Redis
watchdogs to compensate — reinventing a daemon badly.
Claude Squad — the terminal-first classic.
AGPL-3.0 TUI over tmux + git worktrees, multi-agent (Claude Code, Codex, Gemini,
Aider), brew install claude-squad (needs tmux + gh). One isolated workspace per
task, review by hand. L0 by design — you are the loop. No API, so question two
never even comes up.
Conductor — the most polished L0 cockpit.
Closed-source Mac app: clones your repo, gives each agent (Claude Code, Codex,
Cursor) its own git-worktree workspace, with a genuinely strong diff viewer and
PR flow. A Conductor Cloud variant exists. macOS only, no programmatic surface —
review throughput is the whole product, and it's good at it.
Crystal → Nimbalyst — the shape outlives the app.
Crystal (Stravu's Electron app, the first GUI for parallel Claude Code/Codex
sessions in worktrees) was deprecated in February 2026; Nimbalyst is the
successor — same model plus a session kanban, a linked task board, one-click
worktree isolation, a per-session diff sidebar, and the only native iOS app in
the category with push-on-input. Still L0 at heart, but the mobile monitoring
nudges it toward "watch from anywhere." Open-source, Mac/Windows/Linux + iOS.
Vibe Kanban — the cautionary data point.
The agent kanban board — and the reason "who maintains this?" is a real column
in the table below.
The sustainability receipt, now dated. Bloop, the company behind Vibe
Kanban, shut down in April 2026; the project survives only as
community-maintained open source with its cloud services sunset. It's not
alone — Opcode (formerly Claudia) is no longer actively developed, and Crystal
became Nimbalyst. Evaluate open-source agent tools as local tools you own,
not as SaaS with a support guarantee. (Nimbalyst's own 2026 roundup of
agent-management tools makes the same point.)
The batch runner and the remote control
Two tools that look like supervision from a distance and turn out to answer
question one with an asterisk.
Claude Code Agent Farm — L1, and honest about it.
MIT Python batch runner: throw dozens of Claude Code instances at a lint/type-fix
queue (its repo demos 20+), coordinated by tmux + lock files, with an HTML
report and a workload watchdog that auto-restarts stalled agents. That watchdog
is its answer to question one — and a watchdog keeps the process alive, it
says nothing about whether the output is right. Restart twenty stalled agents
enough times overnight and by morning you don't have correct code — you have
twenty confident reports and one shared mistake, multiplied. Claude Code only,
by design. The right tool for exactly one job, and it doesn't pretend otherwise.
Omnara — L2, plus the sharpest architecture lesson on the list.
YC S25, Apache-2.0 apps. Syncs coding-agent sessions (Claude Code, Codex, n8n)
across terminal, web, and mobile, with notifications and human-in-the-loop
replies — so its answer to question one is "you, from your phone" (L2). In 2026
it pivoted to a hosted, voice-first managed-agents platform. The pivot carries a
lesson worth more than the feature list:
Don't build on a CLI you don't control. Omnara originally wrapped the
Claude Code CLI and had to abandon that architecture — constant upstream CLI
changes made the wrapper unmaintainable. It rebuilt on the stable Claude Agent
SDK. Intercepting a fast-moving interactive CLI is a losing architecture; build
on a programmatic layer. (Per Omnara's own GitHub README.)
The competitor that isn't on the awesome list
Here's the fair part, because credibility depends on it. The biggest competitor
to every tool above isn't a third-party tool — it's the model vendors absorbing
orchestration natively, and their integration reaches deeper than any outsider's
can.
What shipped, dated. Claude Code Agent Teams; Dynamic Workflows (Claude
writing its own orchestration script); Outcomes — a grader model that
scores work against your rubric and forces retries, a legitimate L3;
Advisor — a cheap executor consulting a stronger model mid-turn; and
Managed Agents, Anthropic's hosted meta-harness. If you're an all-Claude shop
on a Team plan, that's a real answer to question one, closer to the model than
I'll ever sit.
So why does third-party orchestration outlive it? Two structural limits, and
they're both about the two questions.
The catch that sends you cross-vendor. Every vendor stack is
single-vendor by construction — Advisor has the same single-vendor,
encrypted-advice catch as Agent Teams; see the landscape
piece for the compatibility-table
breakdown. That rules out the exact case where checking pays off most: a cheap
open executor judged by a stronger model. And it all lives on their plans and
their infrastructure.
That matters because open weights caught up. On SWE-bench Verified (July 2026)
the frontier is GPT-5.6 Sol at 96.2 and Claude Fable 5 at 95 — but the best
permissively-licensed models, GLM-5.2 (MIT, 82.8), Kimi K2.7 (78.2) and
DeepSeek-V4 (MIT, 76.2), now match proprietary frontier from a few months back
at a fraction of the price. The rational 2026 fleet is mixed — and a mixed fleet
only pays off if something external, cross-vendor, catches the $0.10 model's
mistakes before merge (the routing math is its own post).
The vendor stacks, by design, can't be that something.
The long tail (and what it's actually solving)
amux, cmux, dmux, mux (yes, all of them), clideck, thurbox, agentbox, AGX,
sortie, tutti… Most are cockpit or batch-runner variants — same two answers as
their bigger cousins. The interesting outliers aren't orchestrators at all:
coordination micro-protocols like gnap (git-as-task-board), swarm-protocol
(MCP work-claiming), and wit (AST-level function locks). They solve agent
collision — two agents clobbering the same file — not agent supervision.
Useful, but a different question than either of ours. Full zoo in the
awesome list.
The table (the receipt)
Read it as a coordinate grid: the two middle columns are the two questions.
| Tool | Shape | Who checks the work | Who equips the agents | License / status | The honest catch |
|---|---|---|---|---|---|
| agentproto (mine) | daemon | L4 — turn-end gate, judge, commit behind ack, survives disconnect | your tools → every agent (TOOL/DRIVER + imported MCP) | Apache-2.0, 0.5.0-alpha | alpha APIs, no mobile/voice, terminal-only |
| Paseo | daemon | L2/L3 — permission relay, Ralph loop | injects its own control tools only | AGPL-3.0, 10.3k★ | no L4 gates, no user tools; Opus default is pricey |
| Claude Squad | TUI cockpit | L0 — you, in a pane | you, by hand (no API) | AGPL-3.0, community | caps at 2–5 agents; dies at screen-lock |
| Conductor | Mac cockpit | L0 — you, great diff viewer | you, by hand (no API) | closed, free | macOS only, no programmatic surface |
| Nimbalyst (ex-Crystal) | cockpit + iOS | L0 + mobile push-on-input | you, by hand | open-source | Crystal deprecated Feb 2026; still eyeballs |
| Vibe Kanban | kanban board | L0 — you, on a board | you, by hand | community-maintained | Bloop shut down Apr 2026 |
| Agent Farm | batch runner | L1 — a liveness watchdog | n/a (one vendor, one job) | MIT, community | keeps it alive, not correct; Claude Code only |
| Omnara | remote control | L2 — you, from your phone | n/a (hosted) | Apache-2.0, YC S25 | pivoted to hosted; approval fatigue |
| Vendor-native (Claude) | in-product / hosted | L3 — Outcomes grader, inside the walls | vendor equips, per-product only | proprietary | single-vendor; Advisor advice encrypted |
(Facts from each project's own docs/repos, 2026-07-07 → 2026-07-14. The
vendor-native row is unpacked in
the state-of piece.)
Pick by the shape of your pain, not by a ranking
There is no best tool, only best fits. Find your bottleneck; the map picks for
you.
- Steering from the couch or phone, best-in-class UX → Paseo (or Omnara if you'd rather it be hosted).
- Terminal cockpit, hands-on review, no lock-in → Claude Squad; Mac-native with a great diff viewer → Conductor; want a board + the only native iOS app → Nimbalyst.
- Grinding a mechanical fix queue with one vendor → Agent Farm.
- All-Claude shop on Team/Enterprise, happy inside one vendor → the native stack (Agent Teams / Dynamic Workflows / Outcomes).
- Unattended runs, mixed-vendor fleets, a real check before merge, and your own tools distributed to every agent → agentproto.
The tie-breaker, if two rows look close. Ask the two questions out loud
against your actual week. If your pain is "I can't watch fast enough,"
question one sorts you — climb the supervision
ladder. If your pain is "I keep re-wiring the same
tool into every agent," question two sorts you, and today almost nothing
answers it. Steering tools answer neither; they add cockpits in front of the
same bottleneck.
That's the whole map. Nine tools, two questions, one honest table — and the one
row I built is disclosed as mine on every line. A ranking would've told you I
won. A map tells you something more useful: exactly which pain each of us was
built to kill, and which we quietly left on the table.
If I've mis-rated where your tool sits, or a dated fact has gone stale since I
checked, tell me where — I'll fix the piece.
The series — Orchestration, Honestly
Ten pieces, one argument. Start anywhere; each one cross-links the rest.
| Piece | The one idea | |
|---|---|---|
| 1 | You can't parallelize the trust | Amdahl's Law: why your fifth agent slows you down |
| 2 | Harness engineering | you rent the model; the harness is the part you own |
| 3 | The supervision ladder | five rungs of trusting an agent you don't watch |
| 4 | The approval plane | auto-approve reads, gate writes — wire the line between |
| 5 | Kill the loop | why "keep going until done" compounds a wrong turn |
| 6 | Route by cost | plan expensive, execute cheap, verify independently |
| 7 | Files with contracts | the interop layer every agent system reinvents |
| 8 | Knowledge is power | give your agent your knowledge, not the internet's average |
| 9 | Paseo, hands-on | a full real-session review of the daemon |
| 10 | 9 orchestrators, compared (you're here) | the tool-by-tool teardown + a decision table |
Written by the maintainer of agentproto (Apache-2.0, source). Same contract as our /compare page — dated facts, named strengths, corrections by issue. Got something wrong? File an issue.
Building agentproto in the open — follow @theagentproto and @agentik_ai on X.
Top comments (0)