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, Cursor Agent, Grok, opencode, Antigravity, Kimi, Hermes, omp, 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 | — (local only today) | 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 (Windows / Linux on roadmap) | macOS, Windows, Linux, web, iOS, Android |
| Source availability | Closed source; adapter SDK is MIT | Fully open source, MIT |
| Price | Free in early access — 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.
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.
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 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.
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 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 is macOS-only and local today. It's MIT and fully open source, so you can fork it if it ever goes the wrong direction. Its PR flow is one button across GitHub, GitLab, Bitbucket, and Azure DevOps. And it's small on purpose: if you already have an editor you love and just want a fast, free surface to delegate to agents from anywhere, that's exactly what T3 Code is for. atrium is the opposite bet — one deep macOS workspace you stay inside.
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 today. T3 Code's native iOS and Android apps and Tailscale pairing are its clearest advantage — atrium is a local macOS app. The one exception is Claude Code's own remote control: inbound prompts from mobile surface in the chat pane. Remote workspaces are on atrium's roadmap, not shipped.
T3 Code supports Claude Code, Codex, Cursor, Grok Build, and OpenCode. atrium supports those plus Antigravity, Kimi, Hermes, omp, 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: your code never leaves your machine 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 early access. Bring the agents you already pay for — your code never leaves your machine.
Download atrium for macOS