Competitive Landscape: AO vs T3 Code vs OpenAI Symphony vs Cmux #526

Which tool fits your workflow? A cross-examined comparison.

Quick pick

What each tool is

Agent Orchestrator (AO) — Give it a GitHub/GitLab/Linear issue, it spawns an agent in an isolated worktree, opens a PR, auto-fixes CI failures, routes review comments back. You intervene only when it's done or stuck.

T3 Code — Desktop app by Theo Browne. Chat with a coding agent, see visual diffs, approve changes before they land. Currently wraps Codex, Claude Code adapter in progress.

OpenAI Symphony — Polls your Linear board, auto-claims tickets, spawns Codex agents, delivers PRs with proof-of-work. Elixir/OTP for fault tolerance. Linear-only.

Cmux — Native macOS terminal built for AI agents. Split panes, notifications, scriptable browser. Not an orchestrator — it's where you run your agents. macOS only.

Feature matrix

Getting started

When to use what (cross-examined)

Use AO when...

You want full lifecycle automation — issue in, PR out, CI fixes handled, review comments routed.

But can't Symphony do this too?
Yes. Symphony also goes from ticket to PR autonomously. Both handle CI verification. The differences: AO works with GitHub Issues, Linear, and Jira — Symphony is Linear-only. AO's plugin slots let you swap agent, runtime, tracker, SCM, and notifier independently. Symphony's agent runtime is extensible but the rest is tightly integrated. On review handling, AO forwards comments to the agent on the existing branch; Symphony closes the PR and starts a fresh branch.

But can't T3 Code also run autonomously?
T3 Code has a "full access" mode where the agent writes files without asking. But there's no CI failure handling, review routing, or auto-merge. The autonomy scope is different: T3 Code automates coding. AO and Symphony automate the entire PR lifecycle.

Use T3 Code when...

You want to review every change before it lands — visual diffs, approval gates, structured chat.

But can't AO also do human-in-the-loop?
AO has task-level approval gates (decomposed plans require human approval) and escalation notifications. But AO doesn't show per-file diffs inside its dashboard — it delegates code review to GitHub/GitLab. T3 Code lets you approve individual file writes before they touch the filesystem. Different granularity: AO is human-on-the-loop (oversight at milestones), T3 Code is human-in-the-loop (oversight at every edit).

Is T3 Code limited to small workloads?
No hard technical limit. You can run multiple threads in parallel. But T3 Code is a conversational UI — each thread is a focused interaction. AO's dashboard groups agents by urgency (merge-ready, needs-response, working, done), which is designed for monitoring many agents at once.

T3 Code working on issue #336: conversational interface showing implementation progress, linked source files, and "Commit & push" in the top-right. The agent explains what it implemented and what's left — you decide when to ship.

Use Symphony when...

You want fault-tolerant autonomous agents with strong concurrency guarantees, and you use Linear.

But AO also has a Linear plugin?
Yes. AO's tracker-linear plugin supports full issue CRUD. If you use Linear, both tools work. The concurrency architecture differs: Symphony runs on Erlang/OTP with supervision trees — crashed agents auto-restart transparently. Per-state concurrency limits prevent race conditions (e.g., max 1 agent in human-review state). AO detects dead agents via polling and escalates or recovers, but can't transparently restart a crashed process mid-execution.

Does Symphony handle the full PR lifecycle like AO?
It handles CI verification and merging. Review handling is different — Symphony does a full reset (closes PR, creates fresh branch, re-implements). AO forwards review comments to the agent for incremental fixes on the existing branch.

What if I don't use Linear?
Symphony won't work for you today. AO supports GitHub Issues, Linear, and Jira.

Symphony Demo Video

— Shows Symphony's poll-dispatch model: Linear ticket claimed, Codex agent spawned, workspace isolated, PR delivered with proof-of-work verification.

Use Cmux when...

You want a better terminal experience for running AI agents — any agent, any orchestrator.

But AO already has a web dashboard with a terminal?
Yes. AO's dashboard has an xterm.js terminal via WebSocket. Cmux adds: native GPU rendering, lower latency, notification rings on pane borders, drag-and-drop pane layout, and a scriptable in-app browser. AO's dashboard adds: PR lifecycle cards, CI status, review comments, fleet-level overview, and remote access from any browser. They're at different layers — Cmux is a terminal, AO's dashboard is a management plane.

Is "AO + Cmux" a real integration?
Not yet. No terminal-cmux plugin exists in AO. Today you manually tmux attach inside a Cmux pane. It works but it's not seamless. They could complement each other — AO for lifecycle management, Cmux for terminal quality — but this hasn't been shipped as a tight integration.

Cmux multi-pane layout: AO dashboard (browser pane) tracking session ao-78, dev server logs (top-right), and CLI showing ao status (bottom-right).

Cmux showing the AO-spawned agent completing implementation and running build/typecheck/lint/test — zero human intervention after ao spawn.

Combos

Key architectural differences

AO — 8 plugin slots (runtime, agent, workspace, tracker, SCM, notifier, terminal, lifecycle). Reaction engine auto-handles CI failures, review comments, merge readiness — each with configurable retries and escalation. Session state is file-based. Polling-based detection (30s intervals).

Symphony — Erlang/OTP supervision trees for process-level fault tolerance. Agent behavior defined in WORKFLOW.md versioned with your code. Per-state concurrency limits. Review rework is destructive (full reset). Linear + Codex only (officially).

T3 Code — Wraps coding agents via JSON-RPC. Provider-agnostic architecture (one provider shipped today). Per-edit approval gates. Designed for focused 1-on-1 work with an agent.

Cmux — Unix socket IPC. Agents can programmatically create panes, send notifications, control browsers. GPU-rendered via libghostty. Has orchestration primitives but no higher-level orchestration logic.

FAQ

Getting started

What do I need installed to try each one?
AO: Node 20+, pnpm, tmux, git 2.25+. T3 Code: Node + OpenAI key. Symphony: Elixir, PostgreSQL, Linear workspace, OpenAI key. Cmux: macOS 14+, then brew install.

What's the fastest way to try AO?
ao init --auto runs a config wizard. Or ao start https://github.com/your-org/your-repo auto-detects everything and launches the dashboard.

Can I try T3 Code without installing?
Yes. npx t3code runs it as a local web server in your browser.

Do I need to know Elixir to use Symphony?
To use it, no — you configure WORKFLOW.md and it runs. To customize or contribute, yes.

Does Cmux require Ghostty?
No. Cmux is built on libghostty (the rendering library) but ships as a standalone app. It reads Ghostty config for themes/fonts if you have one.

Agents and models

What AI models does each tool use?
AO: whatever model the agent plugin uses (Claude for Claude Code, GPT for Codex, etc.). T3 Code: OpenAI models via Codex (Claude support coming). Symphony: OpenAI Codex (gpt-5.3-codex referenced in config). Cmux: none — it's a terminal, you bring your own agent.

Can AO use Claude Code and Codex on different projects simultaneously?
Yes. The agent plugin is per-project in the config. Project A can use Claude Code, Project B can use Codex.

Can Symphony use Claude Code?
Not officially. A community port exists. The agent slot is extensible (App-Server Protocol over stdio), but only Codex is maintained by OpenAI.

Can T3 Code use Claude Code?
PR #179 adds a Claude Code adapter. Not merged yet.

Do any of these work with local/self-hosted models?
AO: if your agent plugin supports it (Aider works with local models via LiteLLM). T3 Code: not yet. Symphony: not yet. Cmux: depends on the agent you run inside it.

Issue tracking and CI

Does AO work with Jira?
Yes. There's a tracker-jira plugin.

Can Symphony work with GitHub Issues instead of Linear?
Not today. Linear is the only supported tracker. GitHub Issues adapter is on the roadmap.

What happens when CI fails?
AO: lifecycle manager detects the failure, fetches CI logs, sends them to the agent, agent fixes and pushes. Configurable retry count (default 2), then escalates to human. Symphony: agent must provide "proof of work" (CI green, tests passing) before the PR is considered complete. If CI fails, the agent retries within its implementation run.

What happens when a reviewer requests changes?
AO: forwards the review comments to the agent on the existing branch. Agent addresses them incrementally and pushes. Symphony: closes the PR, creates a new branch, re-implements from scratch. T3 Code: no automated handling — you manage reviews manually.

Scaling and concurrency

How many agents can run in parallel?
AO: no hard limit. Bounded by machine resources and API rate limits. The auto-poller defaults to 5 concurrent agents (configurable). Symphony: defaults to 10 concurrent agents with per-state limits. T3 Code: no hard limit on threads, but the conversational UI is designed for focused work.

What happens when an agent crashes?
AO: lifecycle manager detects the dead session via polling (~30s). Recovery system classifies it (live/dead/partial/unrecoverable), attempts automatic recovery (up to 3 times), then escalates to human notification. Symphony: OTP supervisor automatically restarts the agent process with error context — transparent to the user. T3 Code: the thread shows an error; you restart manually.

Can AO handle 50+ agents?
Technically yes (no hard cap), but the polling-based architecture becomes I/O bound. Symphony's BEAM runtime handles hundreds of concurrent processes natively.

Dashboard and monitoring

Can I see code diffs in AO's dashboard?
No. AO's dashboard shows session status, PR metadata (additions/deletions count, CI checks, review state), and terminal access. For actual code diffs, it links to the PR on GitHub/GitLab.

Can I interact with an agent through AO's dashboard?
Yes. The dashboard embeds an xterm.js terminal connected to the agent's tmux session via WebSocket. You can also send structured messages via "ask agent to fix" buttons on review comments.

Does Symphony have a dashboard?
No. Symphony is a background daemon. You monitor it via terminal logs and Linear board state.

Does T3 Code show what the agent is thinking?
Yes. The chat UI shows reasoning traces, tool calls, and proposed file changes with visual diffs before they're applied.

Security, secrets, and permissions

Does my code leave my machine?
The code stays local. LLM API calls send code context to the model provider (Anthropic, OpenAI, etc.) depending on which agent you use. This is true for all four tools.

Can these tools push to my repo without my permission?
AO: agents push to feature branches and open PRs. They don't push to main/default branch. Auto-merge is off by default. Symphony: similar — agents create PRs, merging is configurable. T3 Code: nothing is committed without explicit approval (in supervised mode). Cmux: it's a terminal — whatever you type happens.

Do I need to give these tools my GitHub token?
AO: yes, for PR creation and CI monitoring (uses gh CLI auth). Symphony: yes, for PR operations. T3 Code: for git operations. Cmux: no — it's a terminal.

How are secrets (API keys, tokens) handled?
AO: API keys are environment variables or set in the YAML config. They're passed to the agent's tmux session. Secrets are not committed — AO's pre-commit hooks include secret scanning. Symphony: keys are in environment variables and Elixir config. T3 Code: API keys are stored locally by the app. Cmux: inherits your shell environment.

Can agents access .env files or credentials in the repo?
AO: agents run in isolated worktrees and can read anything in the worktree. Use symlinks config to control what gets linked in. Sensitive files not symlinked won't be accessible. Symphony: agents run in per-issue directories with configurable sandbox policies (network isolation, restricted paths). T3 Code: agents can read the project directory in full-access mode. Cmux: depends on what you run.

Can I restrict what the agent is allowed to do?
AO: agent-specific — Claude Code has permission modes (bypass, ask, deny). AO sets --dangerously-skip-permissions by default for autonomous operation. You can override via agentConfig.permissions in the YAML. Symphony: supports network sandboxing (network-none) and workspace path restrictions. T3 Code: supervised mode requires approval per action. Full-access mode has no restrictions.

Is there an audit trail?
AO: session metadata files track status, branch, PR, timestamps. The dashboard shows event history. Git history on the feature branch serves as the code audit trail. Symphony: proof-of-work includes CI reports, test results, and change walkthroughs. T3 Code: the thread history is the audit trail.

Rollback and recovery

What if I need to undo what an agent did?
All tools work via git branches. The simplest rollback is deleting the branch or closing the PR. Since agents work in isolated worktrees/directories, your main branch is never touched until you merge.

Can I roll back a merged PR?
Standard git revert. None of these tools have a built-in "undo merge" feature — use git revert or GitHub's revert button on the PR.

What happens to the worktree if an agent crashes?
AO: the worktree persists on disk. You can ao session restore to resume, or ao session kill + manual cleanup. Orphan worktrees can accumulate — there's an open issue for automated cleanup. Symphony: workspace directories persist. Manual cleanup needed. T3 Code: worktrees persist; managed via git.

Can I resume a failed agent session?
AO: ao session restore <name> re-attaches to the worktree and restarts the agent. Symphony: failed runs can be retried by moving the Linear issue back to the "Ready" state. T3 Code: you continue the conversation thread.

Monorepos and large repos

Do these work with monorepos?
AO: yes. Each agent gets its own worktree (shares .git directory, no full clone). You can scope agent rules per project. Symphony: yes, per-issue workspace directories. T3 Code: yes, it uses worktrees. Cmux: it's a terminal — depends on the agent.

How do worktrees handle large repos?
Worktrees are lightweight — they share the git object database with the main checkout. Disk usage is roughly the size of the working tree (not a full clone). For very large repos (10GB+), the initial worktree creation may take a few seconds.

Can agents work on different packages in a monorepo simultaneously?
AO: yes. Each agent gets its own worktree and branch. They can work on different packages without conflict. Merge conflicts are resolved at PR merge time. Symphony: same isolation model.

Failure modes

What if the agent writes bad code?
AO: the build/test step catches it before pushing (if the agent follows project rules). If bad code reaches CI, the reaction engine detects CI failure and sends the agent back to fix it. After configured retries, it escalates to a human. Symphony: proof-of-work verification requires CI green before the PR is considered complete. T3 Code: you see the proposed changes as diffs and can reject them before they're applied.

What if an agent gets stuck in a loop?
AO: stuck detection kicks in after configurable idle threshold (default 10 minutes). The agent-stuck reaction notifies you. Symphony: implementation runs have bounded retries with exponential backoff. T3 Code: you're watching the conversation and can interrupt.

What if two agents edit the same file?
AO: each agent works in an isolated git worktree on a separate branch. Conflicts surface at PR merge time, not during coding. Symphony: same — per-issue workspace isolation. T3 Code: depends on whether you use worktrees.

Day-to-day usage

How much babysitting does each tool need?
AO: minimal after setup. The reaction engine handles most events. You check the dashboard periodically or wait for notifications. Expect to intervene on stuck agents or ambiguous review comments. Symphony: similar — it's designed to run unattended. Check your Linear board for completed items. T3 Code: high — it's designed for active collaboration. You're part of the conversation. Cmux: depends on what you run inside it.

How noisy are notifications?
AO: configurable. Route urgent events (stuck, errored) to desktop/Slack, info events (completed, summary) to Slack only. You control this in the YAML. Symphony: no built-in notification system. T3 Code: no notifications. Cmux: built-in terminal notifications (OSC sequences + cmux notify CLI).

Can I use these behind a corporate proxy or VPN?
AO: yes, as long as the LLM API and GitHub/GitLab are reachable. No special proxy config in AO itself. Symphony: same — needs access to Linear API and OpenAI API. T3 Code: same — needs OpenAI API access. Cmux: it's a terminal — no network requirements of its own.

Do these work with private repos?
Yes, all of them. AO and Symphony use your git credentials (SSH key or gh auth). T3 Code uses your local git config. Cmux inherits your shell.

Choosing between them

I just want to try AI coding agents for the first time.
T3 Code or Cmux. Both install in under 2 minutes. T3 Code gives you a guided chat with diffs. Cmux gives you a terminal where you run any agent with better visibility.

I want agents working while I sleep.
AO or Symphony. Both handle the full issue-to-PR pipeline. AO if you want any tracker/agent/SCM combination. Symphony if you use Linear and want BEAM-level fault tolerance.

I want to review every line.
T3 Code. Per-edit approval gates are its core design.

I'm already using Claude Code in the terminal.
Cmux gives you a better terminal (notifications, sidebar, browser). AO gives you lifecycle automation on top of Claude Code (spawn on issues, auto-fix CI, route reviews).

Solo dev or team?
Solo: T3 Code or AO (manual spawn). Small team: AO with the dashboard for shared visibility. Platform/infra team: AO (plugin architecture) or Symphony (if on Linear). Enterprise: evaluate carefully — none of these are enterprise-hardened yet.

Which has the most active community?
By GitHub stars: Symphony (~13K) > Cmux (~7.2K) > T3 Code (~6.6K) > AO (~4.7K). By maturity: AO has months of development and 3,288 tests. The others launched in the last 2-3 weeks. Stars and maturity measure different things.

Can I migrate between them?
They don't share config formats or state. But they all use git branches and PRs as the output, so the work products are portable. Switching orchestrators means re-configuring, not re-doing work.

Which one will still exist in 6 months?
AO: backed by Composio, actively maintained. Symphony: backed by OpenAI, but "engineering preview" — production commitment unclear. T3 Code: backed by Theo/Ping, active development. Cmux: backed by Manaflow (YC S24), actively maintained.

Compiled 2026年03月18日. This space moves fast. Comments welcome if anything is outdated.