One page for every Claude Code and Codex session, on every machine you use.
Read them, search them, and keep working in them, like a desktop chat app. Self-hosted.
中文 · Quick start · Install guide · How it works
Claude Code and Codex keep each session on the machine where it ran, and each client shows only its own. That is fine with one laptop. It stops being fine with a laptop, a second laptop and a couple of GPU servers:
- The work is scattered. Which machine was that conversation on? There is no list of everything and no search across machines.
- Checking on a long run means SSH. A training job or a big refactor on a server can only be watched from a terminal on that server.
- Picking a session up elsewhere is fiddly. Find the machine, find the session id,
claude --resume, hope nothing else is writing to it. - Hosted dashboards want your transcripts. They hold your code, your prompts and whatever the agent printed. Those should stay on hardware you control.
Atrium is the fix I wanted: an atrium is the open court in the middle of a house that every room opens onto. Every machine opens onto one page. Three things were not negotiable:
- The agents stay as they are. A message sent from Atrium runs
claudeorcodexon the session's own machine and is appended to the same native transcript. Open the session later in a terminal or the desktop client and it is all there. Nothing is locked in. - Everything stays yours. Your server or your own computer, your machines, plain files. No account, no cloud service.
- Nothing listens on the internet. The page binds to loopback. Machines reach it through an SSH tunnel made with a key that can do two things and no more.
See everything
- Every session from every machine in one sidebar: the few you used last on top, then machine, working folder, and sessions newest first. Or a flat list by day. The pencil on a machine's row renames it; that changes only the name shown.
- Full history with tool calls folded into tidy steps, and full-text search across all of it.
- Machines are listed in the order you last used them. Under each, folders nobody has touched for seven days wait behind "more folders", and old sessions fold away, so the list stays about current work.
- Usage on a status bar along the bottom of the window: how much of each agent's plan limit is used and when it resets, and the tokens of the last seven days by day, machine and model. The limits are what the
claudeandcodexCLIs on your machines last saw; Atrium does not ask the services itself.
Keep working
- Type at the bottom of any session. The turn runs on the machine that owns it, output streams back live, and permission requests show up as buttons.
- Away from the page, a run that needs your OK, has answered or failed can reach you as a notification, and you can answer the request right there (see Notifications on your phone).
- Start a new session on any connected machine, in any folder: pick a recent one, browse, or type a path.
- Choose the model and reasoning effort from the list that machine's own CLI reports.
Branch like a chat app
- Edit an earlier message or try an answer again: the same session goes on from that point, and what it replaced is folded away, one click from being read again.
- Fork from any reply to start a new session from there; the original is left alone.
- Side chat: ask a question next to the conversation. It knows everything said so far, and nothing asked there is written back.
- Type
/for commands: Atrium's own, plus the slash commands and skills your Claude Code install reports.
Work on the machine (off until you turn it on)
- A real terminal on the session's machine, as if you had SSHed in.
- The session's folder as a file tree, with a small editor.
It comes in English and Chinese, as a web page, as a small macOS app, and as an app on a phone's home screen.
Download the archive for your system from Releases and unpack it. It holds the hub, the runner and the install scripts, so nothing needs compiling. Each machine needs claude and/or codex installed and signed in.
| System | Archive |
|---|---|
| Mac, Apple silicon | atrium-<version>-darwin-arm64.tar.gz |
| Mac, Intel | atrium-<version>-darwin-amd64.tar.gz |
| Linux, x86-64 | atrium-<version>-linux-amd64.tar.gz |
| Linux, ARM | atrium-<version>-linux-arm64.tar.gz |
To build from source instead you need Go 1.22+ and Node 18+: make puts the same files in bin/.
Everything runs on your own Mac or Linux desktop and listens on loopback only. No server, no SSH, no account.
tar -xzf atrium-*-darwin-arm64.tar.gz && cd atrium-*-darwin-arm64
./scripts/local-install.sh install
./scripts/local-install.sh linkinstall sets up three small background jobs (the archive, the page, the runner), and link opens the page signed in at http://127.0.0.1:13005. To remove it all: ./scripts/local-install.sh uninstall (your transcripts are not touched).
The machines need one computer they can all reach by SSH to act as the server. It does not have to be in the cloud:
| The server can be | Notes |
|---|---|
| a small cloud server | 1 GB of RAM is enough |
| a computer at home that stays on | a mini PC, a NAS, a Raspberry Pi; reach it over your LAN or a private network such as Tailscale. No public address needed |
It needs Linux with systemd and root access. Then:
Unpack the archive for each computer's own system on it, then:
./scripts/server-install.sh --atrium ./bin/atrium # on the server, as root
./scripts/machine-install.sh key # on each machine: prints a public key
atrium-machine add laptop 'ssh-ed25519 AAAA…' # on the server: prints a runner token
./scripts/machine-install.sh install --server my.server --name laptop --token … # back on the machineThe full walk-through, including signing in, is in docs/install.md.
The page opens on a short setup guide. It gives you the commands with your machine's name filled in, then checks each machine live: runner connected, claude or codex found, history arrived. When a machine is all green you can start.
each machine the server (loopback only)
┌────────────────────────┐ rsync over SSH ┌──────────────────────────────┐
│ push transcripts ───┼──────────────────▶│ /srv/agent-sessions/<name>/ │
│ │ │ │ │
│ tunnel 127.0.0.1:13005┼──── SSH -L ──────▶│ agentsview (parses, indexes)│
│ │ │ │ │
│ runner starts claude/ │◀── long-poll ────▶│ atrium (page + control) │
│ codex per turn │ └──────────────────────────────┘
└────────────────────────┘ browser → http://127.0.0.1:13005
- History comes from the raw transcript files. agentsview parses and indexes them; Atrium reads its API.
- Control is a small runner on each machine. For every message you send it starts
claude -p --resume <id>orcodex exec resume <id>in the session's own folder, so the turn lands in the same native transcript. A Claude process that its own background tasks keep alive takes the session's next message itself instead of a new one being started. - Access is by SSH tunnel. The hub and the archive bind to loopback. Each machine's key can write into its own folder on the server and open that one tunnel, nothing else.
On one computer (setup A) the same three parts run side by side: the archive reads your transcripts where they already are, and there is no push and no tunnel.
Hover a message to see what you can do with it.
| Do this | What happens |
|---|---|
| Edit one of your messages (pencil) | The session goes back to just before that message and continues from your new text. It stays the same session; the turns it replaced are folded under a "rewritten here" mark. |
| Try again (under the last reply) | The same, with the message unchanged: the reply is replaced. |
| Fork (under any reply, or the button in the header) | The view is cut back to that point; your next message starts the new session. |
Side chat (⌘.) |
A panel on the right with a fork of the session as it is now. Ask what you like; the main session never sees it. |
Type / |
A menu of commands. Atrium's own run right away. The rest come from the Claude Code CLI on that machine and are sent to it as a message. |
| Open Info next to a conversation (⌘I) | How full the context window is and what fills it, the model and effort in use, MCP servers, what the last turn cost, and the background commands and monitors the agent started, each with a Stop button; click a command to see what it has printed, followed live while it runs. While they run you can keep chatting: the next message goes to the same agent process, and when a task ends the agent is told and picks up from there. Claude answers these itself, also for a session that is not running (no message is sent, nothing is written); for Codex the context figure is read from its session file. |
| Pick a model and reasoning effort | The list is the one the agent's own CLI reports on that machine, with the effort levels each model accepts. Effort has its own button next to the model. "Reload" in the model menu reads the list again. |
| Paste a picture, drop files on the page, or use the paperclip | They go out with the message: saved on the machine the session runs on, in a folder of the runner's own, and the agent is told where. Up to 10 files of 25 MB each. The hub keeps a copy of the pictures for a month, so the conversation shows them on every device. |
| Send while a run is in flight | With Claude Code the message goes in at once and the agent sees it after the tool call under way, within the same turn, as when you type into Claude Code while it works. With Codex it is queued and goes out when the run ends. Either way, ⌘Enter (or "Send now" on a queued message) stops the turn and sends it right away. A run that has answered and only waits for its background tasks does not hold the message box. |
| + on a machine or folder in the sidebar | A new session there. On a machine, the folder menu opens so you can pick or type one. |
Editing and trying again use what Claude Code's own rewind uses: --resume <id> --resume-session-at <message>. The session keeps its id, the replaced turns stay in the transcript as a branch it no longer follows, and claude --resume in a terminal picks up the new version. The first message of a session has nothing before it to go back to, so rewriting that one starts a new session instead.
Forks never touch the original transcript: Claude Code forks with --resume <id> --fork-session (plus --resume-session-at when the copy should stop early), Codex with codex exec fork. Codex can only fork from the end, so editing and trying again are offered for Claude Code sessions only. Neither a rewrite nor a fork rolls back files: whatever the replaced turns changed in the folder stays changed.
The panel on the right has two more tabs for the machine the session lives on:
- Terminal (
⌘J): a login shell in the session's folder on a real pseudo-terminal. Your own prompt, colours,vim,htop. A message starting with!is typed into it. It keeps running when you close the panel. - Files (
⌘E): the folder as a tree, and a small editor with syntax colours and⌘S. If the file changed on the machine after you opened it, saving asks first.
Both travel over the runner's existing connection, so no extra port is needed. Each keystroke makes a round trip through the hub: fine for commands and quick edits, slower than a local terminal.
They are off by default. A runner can normally start claude and codex, and save the attachments of a message into its own cache folder, and nothing else. To allow these two tabs on a machine, say so in that machine's own runner.json and restart the runner:
{ "hub": "…", "token": "…", "allow_shell": true }With that line, anyone who can sign in to your Atrium page can run commands and change files on that machine as the runner's user. Turn it on only where you are comfortable with that.
Claude Code refuses "Allow everything" when it runs as root. If a runner is root on a throwaway machine such as a container, add "root_sandbox": true to that machine's runner.json and restart the runner: it then tells Claude the machine is a sandbox (IS_SANDBOX=1). Leave it off anywhere you would mind an agent running any command as root without asking.
Download Atrium-<version>.dmg from Releases and drag Atrium to Applications. It is a small native window around the page, with notifications when a run finishes or needs your confirmation, a dock badge, menu-bar shortcuts and one-click sign-in. It opens http://127.0.0.1:13005, which is where both setups above put the page.
The app is not signed with an Apple Developer ID, so macOS refuses to open it the first time. Either allow it in System Settings → Privacy & Security → "Open Anyway", or clear the download flag:
xattr -dr com.apple.quarantine /Applications/Atrium.appTo build it yourself: make app. See app/README.md.
The page works in a phone's browser, and "Add to Home Screen" turns it into an app with its own icon. On a phone the list of sessions is the home screen: back from a conversation, or a swipe from the left edge, returns to it. Enter makes a new line there and the send button sends; on a computer Enter sends and Shift+Enter makes a new line. "Enter key" in the ⋯ menu changes this either way. The page still listens on loopback only, so the phone has to come in through something that ends on the server: a VPN or proxy that runs there and connects to 127.0.0.1:3005 for you, or a TLS reverse proxy as in the install guide. Sign in with "Sign in on another device" under ⋯ at the bottom of the sidebar.
The hub can run a command of yours when a run needs your OK, has answered, or failed. Anything that can send you a message works: a chat app's CLI, curl to ntfy or Bark, a mail command. Add a notify block to the hub's config.json and restart the hub:
"notify": {
"command": ["lark-cli", "im", "+messages-send", "--as", "bot", "--user-id", "ou_xxx", "--text", "{text}"],
"url": "https://atrium.example.com"
}commandruns without a shell.{text}is the whole message: what happened, the session's title, the machine, a line of detail, the link.{head},{title},{detail},{kind},{machine}and{url}are its parts. The same values are in the environment (ATRIUM_TEXTand so on), and the message is on standard input, so["curl", "-s", "--data-binary", "@-", "https://ntfy.sh/your-topic"]works too.- A command that lays the message out itself (a card with buttons, say) gets every part as one JSON object in
{json}andATRIUM_JSON:kind,head,title,detail,machine,url,text, and for a request that can be answered,request,choices(label and the reply that picks it),questions(each with its options, for a form),free(an answer in your own words is taken too) andhint. A reply line may name the request it answers:{"text": "1", "request": "..."}. urlis the page's address as your phone reaches it; the message then ends with a link to the session.onpicks what to tell about: any of"permission","done","error". Leave it out for all three.langis"en"or"zh".replieslets you answer from where the notification arrived. It is a command that keeps running and prints what you write back, one JSON object per line:{"text": "1"}. A permission request then says "Reply 1 to allow, 2 to deny", a question lists its options by number, and your reply answers the latest request still waiting. Make sure the command passes on only your own messages: whoever can write to it can approve what your agents ask for. For Feishu/Lark:["lark-cli", "event", "consume", "im.message.receive_v1", "--as", "bot", "--jq", "select(.chat_type == \"p2p\" and .sender_id == \"ou_xxx\") | {id: .message_id, text: .content}"].- Nothing is sent while an Atrium page is in front of you: visible, focused, and used in the last five minutes.
"always": truesends anyway.
The hub's systemd unit from the setup guide keeps it off the network, so a command that calls a service fails there. scripts/notify-feishu.py is a small separate service for that case: the hub leaves messages in a folder, the script sends them as cards and writes back what you press or reply: Allow and Deny buttons for a permission request, a question's options as buttons with a field for your own answer, a form when there are several questions or several options can be picked. Its header says how to run it.
atrium notify-test sends a test message. Mind that a message carries the session's title and the first lines of the agent's reply through whatever service your command uses.
- One writer per session. If a session is running in a terminal or desktop client, stop it there before sending from Atrium, or the two will interleave in one transcript. Atrium warns when a session changed elsewhere moments ago.
- Other clients do not refresh live. A message sent from Atrium is in the transcript at once, but an already-open desktop client shows it only after a restart.
- Sessions created elsewhere appear after about a minute (the push interval).
- "Allow everything" can still ask. Claude Code runs some safety checks whatever the mode, for example before
rm -rfon a path it cannot work out in advance (rm -rf "$(…)"). The request then says it comes from such a check. The terminal asks the same. - Permissions default to whatever the machine's own settings say. Pick "ask me" in the message box to confirm each action from the page, or from a notification if you set those up.
- Transcripts are plain text on the server. They can contain secrets you pasted or the agent printed. Treat the server accordingly.
- It is for one person. There are no user accounts: whoever can sign in sees everything.
| Path | What |
|---|---|
cmd/atrium |
the hub: API, sign-in, runner endpoint, the embedded web page |
cmd/atrium-runner |
the per-machine runner |
web/ |
the page (React + Vite) |
app/ |
the macOS app (Swift) |
scripts/ |
install scripts (one computer, server, machine), the release build, and the Feishu/Lark notification service |
devstack/ |
a stand-in for everything (made-up sessions, fake claude and codex) for working on the page |
To work on the page with nothing installed: devstack/up.sh seed, then cd web && npm install && npx vite, and open http://127.0.0.1:5199.
Early. It runs the author's daily setup: two Macs, two Linux containers and one small server. The server and machine scripts come from that working deployment but have not been exercised on a clean server yet. The one-computer install is the newest part: it has been run end to end on macOS (Apple silicon, launchd), and not yet on Linux. Expect rough edges, and please report them.
Apache License 2.0. Copyright 2026 Atrium contributors.