atrium vs T3 Code
T3 Code is a fast, free, MIT-licensed front end for the agents already on your machine — and it goes with you to your phone. atrium is what surrounds the agent instead: terminal, editor, browser, tasks, and notes in a room that survives a crash, a reboot, and a closed lid.
atrium is the workspace around every coding agent you run. Each task launches into its own worktree-isolated room — terminal, agent chat, Monaco editor, browser, tasks, notes — journaled to disk and restored after a quit, crash, or reboot, with a background daemon that keeps agents running when the window is closed.
T3 Code is an open-source "agent harness control surface" from Theo and the T3 team. It drives the agent CLIs already installed on your machine — Claude Code, Codex, Cursor, Grok Build, OpenCode — from a desktop app, a web app, or native iOS and Android clients, with worktree isolation, a one-button PR flow, and remote access over Tailscale or SSH.
| Feature | atrium | T3 Code |
|---|---|---|
| Running agents | ||
| Drives the agent CLIs already on your machine | Yes — your own installs and subscriptions | Yes — your own installs and subscriptions |
| Supported agents | 10 — Claude Code, Codex, Antigravity, Cursor Agent, Kimi Code, OpenCode, Pi, Grok, Hermes, Oh My Pi | 5 — Claude Code, Codex, Cursor, Grok Build, OpenCode |
| Open adapter SDK (bring your own CLI) | Yes — MIT-licensed declarative manifest, any hook-capable CLI | Fork the app (MIT) — no adapter layer |
| Parallel agents in isolated git worktrees | Yes — one room per task | Yes — worktree isolation per agent |
| Model switching mid-thread | Yes, where the adapter's transport supports it | Yes |
| Agents keep running with the window closed | Yes — background daemon | Server keeps running; can run headless or as a service |
| Agent-to-agent messaging & coordination | Agents read each other's panes and message in-workspace | — |
| The workspace | ||
| Built-in terminal | Yes — full PTY panes, any command | Not an editor or terminal by design |
| Full code editor with LSP | Monaco — LSP, git blame, diagnostics | Inline diff review |
| Real browser pane | Yes — Chromium pane with DevTools, agent-drivable | — |
| Task cards that launch agents | Yes — fire a task into a fresh worktree, on a cron cadence | — |
| Notes — Markdown, Excalidraw, Canvas, HTML | Yes — a notepad with four note types | — |
| Voice dictation | Yes — push-to-talk, native macOS speech-to-text | — |
| Layout | Tiling mosaic — rooms, splits, parallel wings, docked panes | Project list plus a chat and diff panel |
| Shipping the work | ||
| One-button commit, push & PR | Via terminal, source-control pane, or browser pane | One button, with generated title, body, and changelog |
| Git host integrations | Any host, through your own git and gh/glab CLIs | GitHub, GitLab, Bitbucket, Azure DevOps — built in |
| Diff review at scale | Monaco side-by-side diffs, thousands of files, comment threads agents can act on | Inline diff review, draft and stacked PRs |
| Reach | ||
| Mobile app | — (inbound Claude remote-control prompts surface in chat) | Native iOS and Android apps |
| Web app / browser access | — | Yes — app.t3.codes, or self-hosted |
| Remote access to another machine | Self-hosted Linux boxes over direct SSH | SSH or Tailscale, with QR pairing tokens |
| Memory & recovery | ||
| What survives a restart | Layout, panes, scrollback, working dirs, env, agent sessions | Threads persist; no workspace layout to restore |
| Crash recovery with a restore chooser | Yes — pick which rooms and panes come back | — |
| Cross-session timeline & full-text search | Timeline, Vault search, Observatory map | Git-backed undo per project |
| Foundation | ||
| Platform | macOS client; Linux / WSL SSH locations | macOS, Windows, Linux, web, iOS, Android |
| Source availability | Closed source; adapter SDK is MIT | Fully open source, MIT |
| Price | Free during public beta — bring your own agent subscription | Free forever — bring your own agent subscription |
Comparison reflects publicly documented features as of August 2026. T3 Code's feature set may have changed since — check their site and tell us if a row is out of date.
T3 Code is deliberately not an editor and not a terminal — it's a control surface you run beside your real tools. atrium replaces the beside: a full PTY terminal, a Monaco editor with LSP, a Chromium browser with DevTools, source control, search, task cards, and notes, tiled next to the agent doing the work.
In the docs: the Chromium browser pane
T3 Code drives five harnesses. atrium ships ten adapters, and its MIT-licensed adapter SDK is a declarative manifest — hooks, session detection, chat transport, capabilities — so any hook-capable CLI becomes first-class without forking the app.
In the docs: the ten official adapters and the manifest behind them
Threads persisting isn't the same as the workspace persisting. atrium journals pane layout, terminal scrollback, working directories, environment, and live agent sessions, then restores them after a quit, a crash, or a reboot — with a chooser for exactly which rooms come back.
In the docs: what a restore brings back
In atrium an agent can read another pane, message another agent, open a browser and drive it, update a task card, or delegate into a fresh worktree — all through the same CLI you use. Coordination is a feature of the workspace, not something you orchestrate by hand.
In the docs: the commands agents call
Everything above ships in the same app — these come with it.
Approval cards, streaming diffs, subagent drill-in, plan mode, steering mid-turn — rendered from each tool's own protocol, not scraped from a terminal.
Every running agent across the workspace, with live status and one-tap messaging.
Reusable runbooks and pre-configured agents, launched with +skill and ++agent mentions — across any adapter.
Content-addressed workspace snapshots; on an unclean exit, pick exactly which rooms and panes to restore.
A navigable 3D night-sky map of every workspace you've ever opened — galaxies, stars, supernovae.
Full-text and regex search across the project, grouped by file, jump to any line.
Cron and loop schedules with an overlap gate, a stall watchdog, and recovery of interrupted runs.
Dracula, Nord, Catppuccin, Tokyo Night, Gruvbox, and more — or drop in your own JSON theme.
T3 Code goes places atrium's client doesn't. It runs on Windows and Linux, in a browser, and as real iOS and Android apps, so you can kick off and steer a run from your phone over Tailscale. atrium can run work on self-hosted Linux boxes over SSH, but its control surface still requires a Mac. T3 Code is also MIT and fully open source, and its PR flow is one button across GitHub, GitLab, Bitbucket, and Azure DevOps. If you already have an editor you love and want a small surface to delegate from anywhere, that is T3 Code's sharper fit; atrium is the deeper workspace around the work.
Yes, for the desktop half. Both drive the agent CLIs already installed on your machine, isolate parallel agents in git worktrees, and never resell you tokens. atrium adds a full workspace around the agent — terminal, LSP editor, browser, task cards, notes, voice — plus five more adapters, an open adapter SDK, and workspace resume after a crash or reboot. T3 Code goes further on reach: web, mobile, Windows, and Linux.
Not from an atrium mobile client today. T3 Code's native iOS and Android apps and Tailscale pairing are its clearest advantage. atrium can run projects and agents on self-hosted Linux boxes over SSH, but you control those locations from the macOS app. Claude Code's own remote control remains the exception: inbound mobile prompts surface in the chat pane.
T3 Code supports Claude Code, Codex, Cursor, Grok Build, and OpenCode. atrium supports those plus Antigravity, Kimi Code, Hermes, Oh My Pi, and Pi — and its declarative adapter SDK lets you add any hook-capable CLI yourself instead of forking the app.
No. T3 Code is MIT and fully forkable; atrium's app is closed source, and only the adapter SDK is MIT. If a permissive licence is a requirement, that's a real point for T3 Code. What atrium does match is the trust model: code stays on machines you choose, remote connections go directly over SSH, and agents talk directly to their own providers.
Through your own tools rather than a built-in integration. The source-control pane handles staging, branches, side-by-side diffs, and comment threads the agent can act on; PRs and CI checks go through a terminal pane or a built-in browser pane. T3 Code's one-button PR across four git hosts is the more packaged flow.
Yes. They drive the same CLIs against the same repos and neither changes your git workflow. Plenty of people will keep T3 Code on their phone and run atrium at the desk.
Free during public beta. Bring the agents you already pay for — your code stays on the machines you choose.
Download atrium for macOS