Competitive Landscape: AO vs T3 Code vs OpenAI Symphony vs Cmux #526
Replies: 1 comment
-
|
One layer missing from most agent orchestrators: behavioral enforcement. These tools handle orchestration (which agent runs when) but not governance (what each agent is allowed to do within its task). Orchestration answers: "Which agent handles this step?" I built an open protocol for the governance layer: Nobulex. Agents declare behavioral constraints (permit/forbid/require), every action gets evaluated before execution, and decisions go into a SHA-256 hash-chained audit trail. For orchestrators like AO, this would sit between the orchestrator and the agent execution — the orchestrator routes the task, the enforcement layer makes sure the agent executes within bounds. Different layer, complementary. Try it: nobulex.com/playground |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
-
Quick pick
npx t3code) or Cmux (brew install)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
pnpm install && pnpm buildnpx t3codeor download from t3.codesmix deps.get && mix ecto.setupbrew install --cask manaflow-ai/cmux/cmuxao initwizardWORKFLOW.md+ Linear webhookWhen to use what (cross-examined)
Use AO when...
You want full lifecycle automation — issue in, PR out, CI fixes handled, review comments routed.
Use T3 Code when...
You want to review every change before it lands — visual diffs, approval gates, structured chat.
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.
Symphony Demo Video
symphony-demo-compressed.mp4
— 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.
Cmux multi-pane layout: AO dashboard (browser pane) tracking session
ao-78, dev server logs (top-right), and CLI showingao 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.mdversioned 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 --autoruns a config wizard. Orao start https://github.com/your-org/your-repoauto-detects everything and launches the dashboard.Can I try T3 Code without installing?
Yes.
npx t3coderuns 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.mdand 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-jiraplugin.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
ghCLI 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
symlinksconfig 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-permissionsby default for autonomous operation. You can override viaagentConfig.permissionsin 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 revertor 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 restoreto resume, orao 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
.gitdirectory, 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-stuckreaction 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 notifyCLI).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
ghauth). 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.
Beta Was this translation helpful? Give feedback.
All reactions