agent-orchestrator

Agent Orchestrator (AO) is a local desktop workspace for coordinating multiple AI coding agents on the same codebase without their work colliding. Instead of juggling a pile of terminal tabs and Git branches, you add a repository, spin up a “worker” for each task, and pick the coding agent, model, and interface that fits — Claude Code, Codex, Cursor, Aider, and 23 others are supported through one workflow. Each worker automatically gets its own Git branch and worktree, so parallel agents never fight over the same files.

Behind the desktop app, a local Go daemon watches agent activity and source-control state in real time, using a change-data-capture layer to keep the UI in sync as workers run. Every worker’s task, conversation, terminal, changed files, isolated in-app browser preview, pull request, CI status, and review state stay attached to that session from creation through merge, so you can drop into any task and see exactly where it stands.

On top of individual workers, AO runs a persistent “project orchestrator” agent that reasons across the whole repository — product direction, technical strategy, priorities — and can turn an approved plan directly into new or redirected worker sessions. A live Kanban board (Working, Needs You, In Review, Ready to Merge) derives each card’s column from session, pull-request, CI, and review facts, giving a single operational view of everything in flight.

AO is Apache-2.0 licensed and built in the open, with 27 coding-agent integrations, a documented backend architecture, and an active Discord and contributor community around a fast-moving desktop app for macOS, Windows, and Linux.

What You Get

• Per-task isolation: every worker gets a dedicated Git branch and worktree, so parallel agents never collide on the same files.
• Support for 27 coding agents — Claude Code, Codex, Cursor, Aider, GitHub Copilot, Grok, opencode, Devin, and more — through one supervised interface.
• A live Kanban board that derives each task’s column (Working, Needs You, In Review, Ready to Merge) directly from session, PR, CI, and review state.
• A persistent project orchestrator agent that holds repo-wide planning context and can spawn or redirect workers itself.
• An agent-controllable, per-worker isolated browser for previewing and inspecting local app changes.
• Native desktop apps for macOS, Windows, and Linux with automatic updates.

Common Use Cases

• Parallel feature development - a team spins up a worker per ticket so several agents can implement unrelated features on the same repo simultaneously without branch collisions.
• Bug triage and fixing - a developer describes a bug in New Task, lets an agent reproduce and fix it in an isolated worktree, then reviews the diff and PR from the same card.
• Project-level planning - a tech lead uses the project orchestrator to reason through an ambiguous roadmap item, then has it break the plan into tasks and delegate them to workers automatically.
• Cross-agent comparison - a developer runs the same task with two different coding agents in separate workers to compare approaches before merging either one.
• Reviewing agent PRs from one board - a maintainer watches the Kanban’s “In Review” and “Ready to Merge” columns to see which agent-authored PRs are blocked on CI or waiting for a human review pass.

Under The Hood

Architecture The Go backend under backend/internal follows a ports-and-adapters layout: a pure domain package holds session/activity/PR vocabulary, backend/internal/ports defines interfaces, and backend/internal/adapters implements them per concern (agent, chatdriver, container, reviewer, runtime, scm, systemexec, telemetry, tracker, workspace) so infrastructure like Git, containers, and SCM providers can be swapped without touching business logic. The daemon package is the composition root wiring these together, daemon/supervisor manages the daemon process lifecycle, and backend/internal/cdc runs a change-data-capture poller/broadcaster that pushes live session and PR state to the Electron renderer rather than the UI polling per request. The Electron frontend consumes this through a generated OpenAPI TypeScript client and TanStack Router/Query. A separate cloud/ module reimplements the same session/project contracts against a hosted PostgreSQL control plane, sharing workspace packages with the desktop app rather than duplicating UI logic — though it does mean the core session/PR/CI state machine is encoded independently in two places that need coordinated updates.

Tech Stack The backend is Go 1.25 using chi for HTTP routing, cobra/pflag for the ao CLI, modernc.org/sqlite with goose migrations for local persistence, an Agent Client Protocol SDK and websockets for agent and terminal streaming, and pseudo-terminal libraries for per-session PTY handling. The Electron frontend is React 19 and TypeScript on Vite, using electron-forge for packaging and auto-updates, TanStack Router/Query, Radix UI with Tailwind CSS v4, an embedded terminal component, a rich text editor for chat, and a typed fetch client generated from the backend’s OpenAPI schema. The separate cloud control plane is a second Go module backed by PostgreSQL with hosted authentication, plus a private Next.js UI sharing common client packages with the desktop app. Deployment targets are native desktop installers built via Electron packaging tools, plus Docker Compose for the cloud stack’s local and staging environments.

Code Quality The Go backend carries an extensive suite of test files and the frontend has a comparably large test suite covering unit and end-to-end tests, backed by more than a dozen CI workflows covering backend tests plus linting, frontend typechecking and tests, CLI end-to-end tests, a dedicated update-flow end-to-end workflow, mobile tests, secret scanning, and release-integrity guards. Error handling in the domain layer consistently wraps and returns errors rather than swallowing them, package-level doc comments explain core invariants like session-state derivation, and the lint pipeline runs the full test suite before static analysis. Strict TypeScript typechecking is wired into CI for both the renderer and the shared client packages. This is a thoroughly tested and CI-gated codebase relative to comparable open-source tools.

What Makes It Unique AO’s distinguishing technical choice is treating multi-agent coordination as a state-derivation problem rather than a chat-log problem: instead of storing an agent’s status directly, the daemon derives each worker’s Kanban position live from session activity, Git worktree state, pull-request facts, and CI/review signals via its change-data-capture poller, so the board reflects ground truth even when an agent’s own reporting is stale. Pairing a single project-scoped “orchestrator” agent with persistent planning memory against per-task “worker” agents each isolated in their own worktree is a clearer division of planning versus execution than tools that treat every agent session as an equal, disconnected unit. Supporting dozens of different coding-agent CLIs and APIs behind one shared protocol integration layer is also a broader integration surface than most comparable orchestration tools attempt.

Self-Hosting

Licensing Model Apache License 2.0 — the entire desktop app, backend daemon, and cloud control-plane source are published under a single permissive license with no separate enterprise tier or license key.

Self-Hosting Restrictions None found. The desktop app runs entirely locally against its own Go daemon and SQLite store; no features were found gated behind a paid plan in the reviewed source.

Enterprise Features No paid feature tier exists in the repository itself. Untrivial-ai also operates a hosted “AO Cloud” control plane that runs workers on cloud infrastructure instead of your machine, but its source is included in this same Apache-2.0 repository rather than split into a private edition.

Cloud vs Self-Hosted The desktop app is fully functional self-hosted with no cloud dependency; hosted cloud execution is an optional add-on covered by the same open codebase, not a hidden proprietary layer.

License Key Required No.