RealmDownload for Mac

Give your agents a world to work in.

Bring the coding agent you already use. Each space in Realm holds a checkout, the agents working on it, and the terminals, browsers and documents they open. Every space sits in one sidebar on your Mac, and it’s all still there tomorrow.

Download for MacGitHub

Apple silicon · in active development

Realm: every space in the sidebar, a session that fixed a crash and the two files it edited, and the file its answer named open in the side panel at the line it named.

What a realm is made of.

  1. The checkout

    A space points at your code, one checkout or several, and its sessions work there. Every turn gets a checkpoint, so you can put the files back.

  2. The terminal

    Real terminals next to the agent. The agent can read what a terminal is actually showing on screen, not a raw log, and answer a prompt that's waiting in it.

  3. The browser

    A browser pane that stays signed in, which agents can read and drive. It stops at a consent screen: approving a sign-in is your click unless the space says otherwise.

  4. The tools

    Linear, GitHub, Slack, Notion and your own MCP servers, through one gateway per space. Agents get the tools but never the credentials, and every call is logged.

  5. The boundary

    A macOS sandbox a space can put its agents in. The checkout stays writable and credential folders can't be read. It's off by default, because a sandbox that hasn't met your toolchain yet can break a build.

  6. The agent

    Claude Code, Codex, Cursor, Gemini, OpenCode, GitHub Copilot, goose, Qwen Code or Grok, each with its own login, models and permission modes. Realm never asks for an API key.

That's a realm.

Make one for every project. They run side by side, none of them can reach another's tools, and each one is right where you left it when you come back.

One for every project, all at once.

Your spaces sit side by side, each with its own agents working. The sidebar shows all of them at once with what's waiting and working in each, and Needs you at the top collects anything that's stuck on you.

Skip

Every space in one sidebar.

Each space in a profile gets its own section of the sidebar: its name in its colour, a count of what's waiting and working, and its sessions. Needs you sits on top and collects every session that's waiting on a permission or a question, from every space and every profile. Open a row and you can answer it right there. Switching spaces loads nothing, because they're all loaded already.

Three sessions waiting on you (two questions and a sub-agent's permission, one from another profile) above every space's sessions.
Three sessions waiting on you (two questions and a sub-agent's permission, one from another profile) above every space's sessions.

A transcript you can read.

A turn isn't a wall of log. Tool calls fold into rows you can open, a plan shows up as a plan, and a reply can carry a chart, a diagram or a comparison. When a turn changes files, it ends with a card listing each file and its line counts from git. Review opens that turn's diff, and Undo is there when a checkpoint can take back exactly that turn. Every prompt also leaves a tick down the edge of the pane, so a long session has a map.

One turn: the answer, the files it named as links, and the two it edited, with Review and Undo.
One turn: the answer, the files it named as links, and the two it edited, with Review and Undo.

Bring the agent you already use.

Claude Code, Codex, Cursor, Gemini, OpenCode, GitHub Copilot, goose, Qwen Code and Grok all run here, most of them through one Agent Client Protocol adapter. Each keeps its own login, models and permission modes. The model picker groups models by the harness that runs them, and its footer holds each model's effort levels and fast mode. Realm never asks for an API key. Signing in runs the agent's own login, and you're the one who approves it.

Every installed agent's models in one list. Opus 5.5 is picked, at Max, with fast mode on.
Every installed agent's models in one list. Opus 5.5 is picked, at Max, with fast mode on.

One agent can start more.

An agent in Realm can hand work to other agents. Each one is a real session in the space, so you can open it and watch it work.

Several at once.

Independent tasks run in parallel, in the space's checkout, an environment you name, or a fresh worktree. A sub-agent asks for permission like any other session, and none of them gets to skip that, even if it's asked to.

Two levels deep, and that's it.

A sub-agent can hand work off once more. Past that, Realm says no, because every level is one more agent somebody has to keep track of.

Everything comes back.

Each sub-agent sends a final report to the agent that started it. Its whole run stays in its own session, and the transcript gives it a line of its own when it's done.

Skip

Hand work to other models.

Ask in plain words ("have GPT-6 Luna build this") or pick models in a session's Agents tab and say what to build. The session's agent splits up the work, starts a sub-agent on each model through whichever harness runs it, waits for the reports and tells you what each one did. Every sub-agent gets its own line in the transcript, and its own session is a click away.

Two sub-agents on two harnesses. One finished with its report, the other is waiting on a permission.
Two sub-agents on two harnesses. One finished with its report, the other is waiting on a permission.

Your tools, without your credentials.

Linear, Notion, Slack, GitHub, Jira, Figma and Sentry connect in one click, and you sign in through the app. A connection belongs to the space instead of an agent, so every session in the space reaches it through one Realm endpoint. The agent gets the tools and never the credential: it calls Realm, and Realm calls the server. Every call is logged with its arguments and what came back, and your own MCP servers go in the same place. OAuth connections are encrypted with a key kept in the macOS Keychain. A key you paste into a custom server isn't, and the app tells you so right at that field.

Connecting an app to a space. One click each, and every session in the space can use them.
Connecting an app to a space. One click each, and every session in the space can use them.

Review pull requests without handing over GitHub.

Code review lists your pull requests through your own gh, so Realm never holds a GitHub token and sees exactly what gh sees. A pull request opens on its summary and its changes. A reviewer reads the diff in read-only mode, on the model and effort level you pick, and leaves its findings on the page. None of its findings and none of your comments reach GitHub until you press Submit review.

A pull request's summary with three findings from a reviewer, one of them on a line the diff doesn't show.
A pull request's summary with three findings from a reviewer, one of them on a line the diff doesn't show.

Confine what an agent can touch.

A space can run its agents and terminals inside a macOS Seatbelt policy. Its checkouts and toolchain caches stay writable, the files in your home that run things later can be read but not changed, and credential folders can't be read at all. The policy covers the process and everything it starts. Seatbelt isn't a container and the network stays open, so this limits what a session can damage or read, not what it can send. It's off by default, per space, because a list of writable folders that hasn't met your toolchain yet can break a build.

The three postures a space can take, set to the one it ships with.
The three postures a space can take, set to the one it ships with.

Work that outlives the window.

realm-server keeps running after you close the window, so a long turn finishes whether you're watching or not. Tasks can run on a schedule, and every run is a real session you can read and pick up from. Each turn is bracketed by a checkpoint. Restoring one puts the files back, and for Claude it rewinds the conversation too.

Three tasks, each on its own model, and one run open as its own session next to the task's card.
Three tasks, each on its own model, and one run open as its own session next to the task's card.

Questions

Which agents can I run?
Claude Code and Codex have their own adapters. Cursor, Gemini, OpenCode, GitHub Copilot, goose, Qwen Code, Grok and others speak the Agent Client Protocol and share one. Claude needs no install, because Realm ships with Claude Code, and Codex installs and signs in during first run. You install the rest yourself, and Realm checks what's on your Mac and gives you the exact install or login command for anything that's missing.
Do I need an API key?
No. Realm drives the CLI you already have, on whatever plan or key you already pay for. It never proxies a provider's traffic and never asks for a key.
Where does my work live?
On your Mac, under ~/Realm. Transcripts, documents, skills and checkpoints are files and a SQLite database on disk. Nothing is uploaded, and there's no account to make.
Can an agent read my tokens?
Not through the gateway. Connections are proxied per space: the agent calls Realm, Realm calls the server, and the credential stays on Realm's side. At rest, it depends on the kind. An app you connect in a click stores an OAuth token encrypted with a macOS Keychain key. A key or header you paste into a custom MCP server is stored in Realm's database in plain text, and the app says so next to the field. Saved website sign-ins are the strictest: encrypted, never handed to an agent, and every fill needs Touch ID.
Which Macs does it run on?
macOS on Apple silicon. Builds are signed and notarized, and the app updates itself from its public release feed.
Is it finished?
No. It's in active development, and the changelog is the honest record of what has landed. Things move fast, and some parts of the app are newer than others.

Open your first realm.

Point it at a checkout, start a session with an agent you already have, and leave the window open all day.

Download for Mac

Apple silicon