30 AI Agents Built the System That Manages Them: A Deep Dive into Agent Orchestrator
Picture this: you have 5 Claude Code terminal windows open, each working on a different issue. You go for coffee, come back, and find 3 still running, 1 crashed with an error, and 1 finished—but you don't know which branch it pushed to. GitHub shows 5 PRs waiting for review, 2 failing CI, 1 with reviewer comments. You start copy-pasting error logs back into each window.
Congratulations. You've been demoted from engineer to project management tool—and the worst kind.
This was pkarnal's (Composio) real experience in February 2026. He brute-forched his way to 20 concurrent agents with bash scripts + tmux + git worktree before realizing: the agents aren't the problem; coordinating them is.
8 days later, he had 40,000 lines of TypeScript, 3,288 tests, and 17 plugins—most of it written by those 30 agents themselves. The project is open source: Agent Orchestrator (MIT), 6,800+ stars.
1. Eight Days to Build a System—Only 3 of Human Work
The timeline is worth examining. Not an "8-day lock-in" myth—pkarnal had a day job; actual focused work was ~3 days spread across 8.
| Date | Branch commits | Lines added | PRs merged | Notes | |------|---------------|-------------|-----------|-------| | Fri 2/13 evening | 157 | +30,070 | 1 | Kickoff, ran overnight | | Sat 2/14 | 112 | +5,599 | 27 | Explosion day, full platform launch | | Sun 2/15 | 63 | +4,779 | 5 | Half day | | Mon 2/16 | 68 | +3,575 | 8 | Around day job | | Tue 2/17 | 94 | +9,512 | 4 | Evenings only | | Wed 2/18 | 71 | +2,921 | 11 | Work + evening | | Thu 2/19 | 91 | +3,990 | 4 | Agents ran all day, evening review | | Fri 2/20 | 0 | — | 1 | Wrap-up |
Total: 656 branch commits, +76,454 lines, 61 PRs merged.
The pattern: assign tasks before bed → agents work overnight → review and merge in the morning → assign new tasks before work → repeat.
Saturday was the explosion day: 27 PRs merged in one day—core services, CLI, Web Dashboard, all 17 plugins, npm publish, shipped at once.
How much was AI-written? 84% of PRs were created by AI sessions; 100% of commits carry AI co-authorship attribution. Each commit's git trailer identifies which AI model wrote it—no ambiguity between human and machine work.
2. Core Idea: You Are the Bottleneck
Most people misdiagnose the problem with AI coding agents.
Agents can write code. That's not the bottleneck. You are.
You spawn five tasks, go for coffee, come back 20 minutes later, and find yourself refreshing GitHub tabs—waiting for PRs, checking CI, reading review comments. You automated engineering, then replaced it with bad project management.
Agent Orchestrator removes you from this loop. It tracks every session, watches CI, forwards review comments back to agents, and pings you only when human judgment is genuinely needed.
| Without orchestration | With orchestration | |----------------------|--------------------| | Manually create branches | Automatic worktree assignment per issue | | Check windows one by one | Dashboard shows all sessions in real time | | Copy-paste CI errors | Automatically injected back into agent session | | Forward review comments manually | Auto-routed to the right agent | | Check each PR before merge | Automatic notification—you just decide | | Dead agents go unnoticed | Activity detection catches it |
3. Three Key Design Decisions
1. Git Worktree Isolation
Each agent gets its own git worktree, branch, and PR. Not a full clone—a worktree is a separate working directory of the same git repo, sharing the object store with zero extra storage overhead.
This means 30 agents can work on different branches of the same repo simultaneously without interference. Agent A's refactor never collides with Agent B's bugfix.
2. Reactions System: Self-Healing CI
The most useful feature. When CI fails, the orchestrator injects the failure logs into the agent's session; the agent reads the logs, fixes the code, and re-pushes. When a reviewer requests changes, the orchestrator routes the comment to the corresponding agent, which updates the PR automatically.
Configurable rules:
ci-failed: auto-handled, up to 2 retries, then escalates to a humanchanges-requested: auto-handled, escalates after 30 minutes unresolvedapproved-and-green: notify only, wait for manual merge (auto-merge optional)- Attention zones—grouped by whether they need your attention (CI failures, awaiting review, healthy runs)
- Live terminal—xterm.js embedded in the browser to watch agent output in real time
- Session detail—currently edited files, recent commits, PR status, CI status
- Mid-to-large codebases (too small is pointless)
- Solid CI and tests (reactions can't work without CI)
- A dozen or more open issues (agents need work)
- You have a day job and no time to babysit multiple agents
- You're willing to trust agents with most decisions, stepping in at critical points
- Small personal projects (managing 1–2 agents manually is simpler)
- No CI or test coverage (reactions system is useless)
- You need line-by-line review (the automation assumptions clash with your workflow)
- You primarily work offline
- Orchestrator Agent (strategic): decompose, assign, monitor, decide
- Coding Agent (tactical): read code, write tests, fix bugs, push PRs
- Human (judgment): review, merge, handle escalated complexity
- GitHub: https://github.com/ComposioHQ/agent-orchestrator
- npm: https://www.npmjs.com/package/@aoagents/ao
- Author's blog: https://pkarnal.com/blog/open-sourcing-agent-orchestrator
- Author's GitHub: https://github.com/pkarnal
- Company: Composio (https://composio.dev)
- License: MIT
- Star growth: https://star-history.com/#ComposioHQ/agent-orchestrator&Date
All 41 CI failures self-corrected—the reactions system forwarded them to agents with zero human plumbing.
3. Eight Pluggable Slots
Not either/or—any combination:
| Slot | Default | Options | |------|---------|---------| | Runtime | tmux (macOS/Linux) / process (Windows) | process, docker | | Agent | claude-code | codex, aider, cursor, opencode, kimicode | | Workspace | worktree | clone | | Tracker | github | linear, gitlab | | SCM | github | gitlab | | Notifier | desktop | slack, discord, composio, webhook, openclaw | | Terminal | iterm2 | web | | Lifecycle | core | — (fixed core) |
All interfaces are defined in packages/core/src/types.ts. A plugin implements one interface and exports a PluginModule—that's it.
Note: openclaw appears among Notifiers. Agent Orchestrator can notify your OpenClaw assistant directly—no manual GitHub checking; completed PRs push straight to your chat.
4. The Orchestrator Itself Is an Agent
This is what fundamentally distinguishes Agent Orchestrator from other "run agents in parallel" tools.
> The orchestrator itself is an AI agent. Not a dashboard. Not a cron job. Not a script that polls GitHub.
It reads your codebase, understands the backlog, decomposes features into parallelizable tasks, assigns them to coding agents, monitors progress, reads PRs, and decides next steps. When CI fails, it decides to inject the logs back; when a review comment arrives, it decides who routes it; when a PR passes, it decides to notify you to merge.
Competitor comparison:
| Tool | Positioning | Key Difference | |------|-------------|----------------| | Agent Orchestrator | Fully automated PR lifecycle | Orchestrator is itself an AI agent | | Claude Squad | Terminal TUI wrapper | More a session manager; no auto CI repair | | Microsoft Conductor | YAML workflows | Deterministic orchestration, not intelligent decisions | | Bernstein | Deterministic scheduler | Janitor cleanup, not AI-driven | | Emdash | 22 CLI providers | Electron desktop, parallel dispatch | | Vibe Kanban | Kanban + MCP decomposition | Web app, community-maintained |
Claude Squad is more a "terminal multi-window manager"—it helps you switch tmux sessions but doesn't handle CI or reviews automatically. Agent Orchestrator is the "intelligent butler"—you run ao start and walk away; you only return to review and merge.
5. Web Dashboard and Remote Access
The dashboard (Next.js 15, Server-Sent Events for real-time updates, no polling) includes:
macOS gets automatic sleep prevention (caffeinate), so you can access the dashboard remotely from your phone via Tailscale. The laptop lid still sleeps (hardware limitation); clamshell mode with external power + display + input is required.
6. Limitations and Boundaries
First, agents idle more than expected. In practice, with 4 agents running, 2 sessions idled 90+ seconds waiting for tool approval. On token-based billing, idle costs accumulate.
Second, not suitable for offline work. Requires GitHub/Linear connectivity and CI pipelines. Purely local projects or non-git workflows won't fit.
Third, not for per-edit review. If you want to manually approve every line change, this system's automation will conflict with your workflow. It's human-on-the-loop, not human-in-the-loop.
Fourth, a package rename leftover. Renamed from @composio/agent-orchestrator to @composio/ao; older tutorials may break.
Fifth, the OpenClaw notifier is a highlight but ecosystem-dependent. Without OpenClaw, you're limited to desktop/slack/discord/webhook. The richness of notification channels determines how quickly you get pulled back into the loop.
7. Is It for You?
For you if:
Not for you if:
8. A Verdict: From "Writing Code" to "Herding"
Agent Orchestrator represents not "AI writes code faster" but a redistribution of the engineering role.
Before: you write code, test, debug, review PRs. Now: you set direction, make key decisions, and merge—writing, testing, and debugging are done by agents, and coordination between agents is done by an orchestrator agent.
It's a three-layer structure:
pkarnal's practice proves the structure works: 8 days, 3 days of focus, 40,000 lines—humans only assign tasks and make final judgments; everything else is automated.
But it raises a deeper question: when the orchestrator agent gets smart enough, does it become the new bottleneck? Today's orchestrator manages 30 agents—what if a codebase needs 300? Will we see a recursive "orchestrator of orchestrators"?
The answer: yes, and it's already happening. Vibe Kanban's MCP decomposition is a higher-level coordinator—decomposing tasks before dispatching them to lower-layer agents. Agent Orchestrator is single-layer herding; the next layer may be multi-layer herd topologies.
9. One-Sentence Takeaway
Agent Orchestrator isn't just another AI coding tool—it's a scheduling operating system for AI programming. Eight pluggable slots let you freely combine agents, runtimes, issue trackers, and notification channels; git worktree isolation lets 30 agents run in parallel without conflict; the reactions system closes the loop on CI failures and review comments automatically. 40,000 lines of TypeScript, mostly written by the agents it was built to manage—this isn't the future; it's February 2026.
If you're using Claude Code across multiple issues, this system restores your role from "project manager" back to "engineer."
---
Project Info