A native macOS workspace where every coding agent stays visible, recoverable, and within reach from the UI or CLI.
The thesis
Starting agents is easy. Staying close to the work is the hard part.
Not unattended orchestration. atrium is for builders who watch, steer, interrupt, compare, and resume agent work as it happens.
The point is not to disappear. The point is to stay close enough to matter.
Core pillars
What makes atrium atrium
atrium is built on four pillars: organization, persistence, visibility, and control. Each one solves a problem that gets painful the moment you run more than one coding agent.
Organization. Every project has its place.
Workspaces hold projects. Rooms hold the active work inside each one. Panes hold agents, terminals, editors, browsers, notes, and diffs. Keep client work, experiments, and long-running branches separated without scattering them across your desktop.
Persistence. The room survives every restart.
Every pane, branch, terminal, and agent session writes itself to disk as you work. Reopen the whole working state after a crash, reboot, or context-switch — without reconstructing the job from memory.
Visibility. Every agent stays in sight.
A sidebar tracks every agent across every room and workspace. Status, last activity, blocked runs, and waiting prompts stay visible at a glance. Notifications pull you back only when an agent actually needs you.
Control. Drive the workspace from inside or out.
Intervene through the UI when you are watching. Drive the workspace from a CLI when it should move on command. Agents can spawn other agents, open browser panes, and coordinate across rooms — all from the same scripting surface you use yourself.
Word of mouth
I use atrium and I freaking love it. Saving workspaces and resuming sessions (and finding ones from weeks ago) is insane and I don't think I can live without it anymore.
Demo vid on the website was good enough for me to be dangerous. As a non-dev, I picked it up quite quick.
I'm in and up and running — the onboarding is excellent, it properly held my hand through getting my first session running, and now my own Claude is busy spinning up agents and showing me how the comms works. It's really excellent work you've done here.
we just committed twice as many PRs today as literally any other day before atrium, it's honestly genius.
Bring Your Own
zsh, bash, fish — your shell, your dotfiles, your muscle memory.
The shell has been around for decades. CLI agents are making it powerful again. atrium doesn't replace any of that — it gives your existing tools a durable place to work together.
Parallel without chaos
Fan out as many agents as you have ideas.
Every task launches into its own room. Opt into worktree isolation and branches don't collide, diffs don't drift, agents don't fight over the same files. Review them side-by-side when they're done.
Task launches a worktree
One command — `task launch ATR-N --worktree` — spins up an isolated git worktree, a fresh room, and an agent already pre-bound to it. No setup, no collisions.
Branches stay isolated
Every agent works on its own checkout. Refactor, build, and break things in parallel — without stomping each other's diffs or fighting over locked files.
Review before it lands
Attributed diffs, anchored comments, and resolvable threads, side-by-side across rooms. Nothing reaches main until you say so.
Agent oversight
See every agent at a glance.
Starting agents is easy. The hard part is knowing which one needs you. A live sidebar tracks every agent across every workspace and room — live state, the command running behind each terminal, and a nudge back to work when one stalls. Step in when it matters, stay out when it doesn't.
Live state per agent
Working, waiting, later, or dismissed — at a glance, across every workspace.
Stop runaway processes in one click
Every active terminal surfaces its running command. Kill a stuck process, replay the last one, or jump to its pane — without leaving the sidebar.
Know when to step in
System notifications when an agent starts waiting on you — not every time it speaks.
Jump straight to any agent
Click an entry to focus the agent's pane and switch into its room — no hunting through workspaces.
Dismiss without losing context
Pause any agent. Its pane snapshots and session resume exactly where they left off.
Nudge agents back to work
One click on a stalled card sends a 'please continue' straight into the agent's session — no switching rooms or retyping context.
Workspace memory
Scroll back through every session.
Prompts, replies, commits, tasks, and notes land in one feed — backfilled automatically, no setup. Scope it, search it, and summarize any window in a click.
Docs are caught up for 0.153 → 0.167 — the agents rename, plus new Timeline and Observatory pages. Two landing sections drafted. Commit?
match the real timeline styling first, then commit
Three epics landed back-to-back this week — the Observatory pane (a galaxy-style universe visualization with spatial audio), the Agent Definition rename (profiles → agents), and the Timeline feed…
The whole story, by day
Your prompts, the agent's replies, commits, tasks, and notes — one chronological feed, grouped by day, newest first.
Scope to any altitude
Narrow the feed to a workspace, a room, or a single pane. The breadcrumb at the top is the control.
Full-text search
Find the turn where it happened — every prompt and reply searchable, ranked by relevance, matches highlighted.
Brief, Update, Recap
Turn a window of work into a written summary in one click. It lands in a note you can keep, edit, and share.
The CLI is the API
Scriptable from day one.
Every pane, task, agent, room, and browser is one CLI call away. Drive atrium from your shell, your scripts, or the agents themselves — atrium exports $ATRIUM_CLI_PATH into every pane it owns.
$ atrium task create --title "fix flaky auth test" --priority high✓ ATR-42 created$ atrium task launch ATR-42 --adapter claude-code --worktree✓ worktree created · agent started · bound to ATR-42$ atrium agent list --json | jq '.[] | .room'"auth-refactor" "integration-tests" "docs-pass"$ atrium browser snapshot e2f1 --visible-onlyOne binary, every surface
Tasks, panes, rooms, workspaces, agents, browsers — all addressable from the same CLI.
Designed for agents and humans
Every command accepts --json. Agents script atrium. Humans script atrium. Same surface.
Self-documenting
Every verb has --help with exact flags. The CLI is the contract, and it can't drift.
Under the hood
atrium
Persistent · Programmable
atrium:// protocol
URI-based dispatch for panes, workspaces, commands, and hooks. Every action in the app has an addressable URI.
State-backed workspace model
Every namespace is addressable, restorable, and observable via the state registry — the same surface persistence is built on.
The rest of the room is already built in
Files, browser research, tasks, search, source control, and workspace controls are part of the environment, not separate apps you have to stitch back together around the agent.
Worktree-aware file tree
Follows the focused terminal's branch. Git status inline. Drag files into panes.
Language-aware editor
Monaco + LSP for TypeScript, Python, Bash, and YAML — with ESLint and Ruff diagnostics inline.
Skills & Agents library
Reusable runbooks and named agents in one sidebar. Mention `+skill` or `++agent` in any pane to load them.
Vault search
Find any past session by content — across every adapter's history. Fuzzy matches, ranked, with snippets.
Launch agents on tasks
Fire a task card into a fresh worktree with one command. Agent starts pre-bound, room labeled, context ready.
Speech-to-text
Talk to your agents. Hands off the keyboard, dictation into the focused pane.
Inter-agent messaging
Agents discover each other, read context, and send framed messages across panes with scope controls.
Notepad
Workspace-scoped notebook with four modes: prose, hand-drawn sketches, interactive canvases agents can author, and sandboxed HTML.
Markdown editor
Rich-text editing for .md files. RTE/source toggle, inline review comments, table of contents, and Mermaid diagrams.
Built-in source control
Stage, diff, commit, push, and drill into commits without leaving the workspace.
Review agent work
Review attributed diffs, leave anchored comments, resolve threads, and send feedback back to agents.
CLI-controllable browser
Research, navigate, and automate live web pages from inside atrium with a built-in browser pane.
Repo search
Search file contents and filenames with regex, live streaming results.
Built-in task board
Track work with shared tasks, comments, statuses, and filters that live inside the same app.
Native workspace controls
Split panes, drag-to-rearrange, tabs with layout diagrams, global zoom, themes.
The Observatory
Your work, as a night sky.
Every workspace you've ever opened becomes a galaxy. Sessions twinkle. Commits go supernova. Pan, zoom, and scrub back through the whole map of where your work has been.
Galaxies, stars, supernovae
Each workspace is a galaxy tinted to its accent. Sessions twinkle as stars; major commits flare as supernovae; a live agent pulses on its own heartbeat.
Click in for the real numbers
Open any galaxy for its stats — sessions, active time, top files, adapter mix, and recent commits. The map is backed by your actual history.
Scrub the year, sound optional
Drag the timeline back through time and atrium pins your marathons, big days, and wake-ups. Toggle an ambient soundscape panned to where each galaxy sits.
Build the room where humans and agents can actually work together.
Not another AI IDE. Not unattended orchestration.
atrium exists to turn AI coding from isolated prompts into durable collaborative work.
The goal is not to hide the agent or replace the human. The goal is to give both a durable place to coordinate, inspect progress, recover context, and keep momentum.
01
Rooms, not tabs
02
Context, not resets
03
Oversight, not guesswork
Steerable
Humans stay in the loop. Agent work should be redirectable, inspectable, and easy to recover.
Shared
Humans and agents should inhabit the same operating context instead of rebuilding everything from scratch on every handoff.
Persistent
Real work carries forward over time. Sessions, panes, context, and structure should survive interruption without drama.
Trust boundary
Your code never leaves your machine.
Local-first by design
Every workspace, session, and scrollback lives on disk in ~/.atrium/. Your code never leaves your machine.
Your agents, your accounts
atrium coordinates the CLI agents you already authenticate. No atrium account. No model key in our hands.
Telemetry you control
A coarse anonymous baseline — app launches and active-session pings — is on by default. Detailed usage analytics and crash reports are opt-in, and one toggle turns all of it off. Your code, paths, and prompts are never collected.
Try the build.
Tell me what's missing.
Early access isn't a trial — it's a collaboration. The features you request, the bugs you find, and the rough edges you flag go straight into the roadmap. Come build the workspace you actually want to work in.
Claude Code, Codex, Gemini CLI, Cursor CLI, Antigravity, OpenCode, and Pi.dev supported out of the box, with a growing adapter model underneath. macOS today.