v2.0.3

The sidebar scrolls wherever the pointer is over it. The sidebar is where the window is dragged
from, and the list of spaces and sessions inherited that: it scrolled only with the pointer on a row,
and stood still over the gaps between rows, a space's or section's heading, or the empty space at the
foot of the list, where macOS took the scroll for the start of a window drag. The list is no longer
part of the drag area; the window still drags by the strip at the top of the sidebar.

v2.0.2

An open Realm notices a new version. Realm looked for updates once, when it opened, so a Realm
left open for days never heard of a release, and the update button at the foot of the rail, above
your profile, could not appear until it was quit and reopened. It now looks again every few hours
while it runs, and when you come back to its window after an hour or more. The button appears as soon
as a new version starts downloading, and a click restarts into it once it is ready.

v2.0.1

Faster in long sessions

Typing keeps up in a long session. In a session a few thousand turns long, every key you typed
re-drew the whole transcript and re-read every message in it — about a sixth of a second per
character, measured on a real home. A keystroke now redraws the prompter alone: a median of 24 ms in
the same session, close to what a new one measures.

Scrolling stays smooth while an agent is answering. A long transcript now draws its most recent
part, and earlier turns load as you scroll up to them, or from Show earlier messages at the top. A
reply streaming into a session thousands of turns long used to hold the window for up to half a
second at a time; in the same session it now drops a frame or two. The part you are reading stays
put while more arrives below it, a saved prompt opened from the Library is drawn before Realm takes
you to it, and coming back to a session puts you where you were.

The cursor

The cursor blinks in Low power. Low power held every cursor still, so with it on there was no
blinking cursor anywhere in the app. It now keeps the plain blink, which changes twice a second, and
only the smooth, phase, expand and pulse animations give way to it — they redraw on every frame,
which is what Low power is there to stop. Reduce motion still holds the cursor still.

Realm v2.0.0

This release was going to be 1.6, and before it shipped it grew into a redesign of the prompter, the
model picker, the transcript and the window around them — so it is 2.0. What 1.6 was to bring is all
here, as it now stands.

Working with an agent

The prompter is quieter, and every chip in it is one shape. What you type is set in medium
weight, a rung up from the text around it, because it is what the card is for. A picked element, a
link, a skill, a skill that has since gone and a command opening the draft, such as /goal, are
each one rounded pill in its own tone, with a mark and a name; under the pointer the mark becomes
the chip's ×, and a selection that covers a chip lights the chip instead of a square box round it.
The permission control has lost its fill and its chevron and is a shield and a word — a shield with
a question mark for Ask each time, one with a tick for Accept edits, and one with a warning mark, in
red, for Full access — and its menu wears the same marks. The + opens a menu drawn by Realm rather
than macOS, because its rows say what they do: Add, with Files… (⌘U), Folder…, Select in Realm,
Skills and Goal…; Mode, picked in place rather than through a submenu; and Connectors, which lead to
the space's Connections. The skill picker and the @ and / lists fade where they scroll instead of
being cut off by their search field.

@ names anything the agent can use. One list: the files in the session's checkout, the ones it
has changed first; the Library; skills; the apps on this Mac; and @Mac, which drives Calendar,
Reminders, Contacts and the Mac's other apps, and wears the Apple mark. A bare @ is a short tour, a
few of each kind under quiet heads; a word after it is one list ranked across every kind, each row
saying what it is, so Return takes the best match whatever it is. A mentioned file goes to the agent
as an attached one would, and the chip is the file. A mentioned app gets computer use for that app,
in that session, and nothing more: its first action still asks, the session's mode still holds, and
nothing outlives the session or becomes a setting of the space.

Point at a part of Realm, and the agent gets it. Select in Realm, in the + menu or on ⌘⇧C, does
for the app what the browser pane's picker does for a page: the same outline follows the pointer
across the window, and a click drops the part it outlines into the prompter as a chip, with a
picture of it attached. A press on a control's glyph or its label picks the control; hold ⌥ to take
exactly what is under the pointer. The chip is written for an agent working on Realm — what the part
is and says, the component that draws it, a selector made of the app's own class names — and
mentions the picture only while the picture is still attached. A part under a browser pane, which
the window's own capture cannot see, goes without one, and its chip says so. Escape cancels.

The model picker is one short list, with effort and fast mode at its foot. The chip says who
will answer — the harness's mark, the model, its effort, and a bolt when fast mode is on — and
behind it is one compact list, grouped by the harness a click runs a model through, with the current
model ticked and in view, a search at the top, and another harness's mark on a row only where that
harness can run the same model too, one click away, rather than the model listed twice. What the
highlighted model is for, its context and its price sit in a strip under the list. The foot is the
effort card: the level by name, a track with a dot for each level that model takes — ← and → step
it, Home and End go to the ends — a reset once you have moved it, and the bolt. Unset, it names the
model's own default rather than going blank, and the level now reaches the agent: on every Codex
turn, mid-session for Claude, and through an ACP agent's own thought level where it has one. Fast
mode can be asked for before the first turn — Codex's catalog says which models take it, one Claude
session answers for every Claude model, and elsewhere the bolt says the first turn will check — and
a model that cannot run fast names the ones that can. Asked for before a session's first message, it
also really runs fast; until now it never reached Claude. Code review's and the media viewer's
question boxes kept only the model you picked before their first question, so the level, the bolt
and the permission did nothing there; that question now starts with all four. Every popover opens
where it will stay, so the bolt is still under the pointer for a second press. Picking a model no
longer closes the picker: the model changes, the list stays where it was and the card turns to the
new model's levels, so its level and fast mode are set in the same visit, and a click outside, the
chip or Escape put it away; ← and → in its search step the level of the model just picked. A level you choose at
XHigh or Max lights the track the way the landing page draws its light — streams running into a white
core at the knob, the cube's facets faint beside it — hotter at Max, and turning fast mode on charges
the bolt and sends a glint down the track and across the chip. Reduce motion shows the light still;
Low power and a window in the background pause it.

A session can hand work to other models. Ask in words — "have GPT-6 Luna build this" — and the
session's agent starts a sub-agent on that model. A model is found by its name, so GPT-6 Luna runs
through Codex and Fable on the newest Fable, and a sub-agent on the lead's own harness runs the
lead's model unless another is named. Or open the session's Agents tab, from the side panel's +: its
sub-agents, each with its model, its task, where it stands and its report, a click from its own
transcript, and under them Build with, where you pick models — this session's own, your starred
ones, More models for the rest — say what to build, and Split by model to give each its own part
instead of leaving the split to the agent. It sends an ordinary message in your name, so the
session's agent still divides the work, starts each sub-agent, gives them worktrees of their own
when they would edit the same files, waits for their reports and tells you what each did, all in the
transcript beside your ask. Implement with…, on a plan and under an answer, opens the tab with that
text in it. In the lead's transcript each sub-agent is a quiet line of its own — "Subagent finished
· Write the tests", its model, its time — rather than folded into a "Worked for 8s" that hides the
one thing a reader of a delegation came for.

Every agent's questions come on one card. A question looks the same whichever agent or server
asks it, and says who is asking first — "Codex asks", "Linear's MCP server asks" — because the same
question means something different from each. What it offers comes from Realm, never from the asker:
options, with pictures as tiles; several at once; text, masked when it is a secret; yes or no; a
model for each step of a plan, from the catalog; a file in the workspace, found the way ⌘P finds
one; a branch of the checkout; a date or a time; or a page to open, shown whole and opened in your
browser only on a click. 1 to 9 pick an option, Return takes the highlighted row and Escape skips.
Answered, it stays where it was asked, as the question and your answer. Codex's questions used to
arrive as nothing at all; they reach the card now, with the ones its MCP servers pass on. Gemini,
Cursor and the other ACP agents can ask too, and so can a Connection's MCP server in the middle of a
call, which waits while you think. Any agent can ask through ui_ask, one of Realm's own tools, on
by default and allowed in every permission mode — up to four questions at once, a secret among them
masked as you type it. A form from Codex, an ACP agent or an MCP server that asks for a key or a
password is declined without being put to you.

The transcript says when, and what each turn changed. A message you send shows the time it was
sent as you point at it, and the keyboard can reach it too. A finished turn is dated the same way —
a clock time today, Yesterday 7:38 PM, then the date, with the full date and time in the tooltip —
where it used to show a bare time that read the same a minute or a week later, and a turn that
failed says Failed after 4s instead of the playful past tense, which read as a job done. A file the
agent names that is really in its checkout becomes a link, and opens in Documents beside the session
at the line it named. A turn that changed files ends with an Edited 3 files card: each file, in the
order it was edited and a click from opening, with its counts as git measured them when the turn
settled rather than as its tool calls claimed them; Review, which opens that turn's diff as the side
pane's Changes tab; and Undo, offered only where a checkpoint takes back exactly that turn and
nothing after it — where Realm took none, the card says so. A tool call that edits a file now names
it the same way for Claude, Codex and the ACP agents: the file's mark, its path, its counts.

A track down every transcript's edge, and turns you can keep. A session pane has a tick down its
left edge for each prompt, placed where the prompt sits in the log, the one being read in ink and a
dot on any turn that changed files. Point at a tick and a card says what was asked, how the answer
began, when, and what the turn edited; a click goes there and leaves the keyboard in the prompter,
and once the track has the keyboard ↑ and ↓ walk it. The bookmark in the card's corner, or S on the
track, saves that turn: its tick takes the accent, ⌥↑ and ⌥↓ step between saved turns, and Library ▸
Saved lists every turn saved in the profile, with the answer each began with, a click from the
prompt in its session.

A reply can carry a chart, a diagram or a comparison. An agent can write a Mermaid diagram, a
realm-chart (columns, bars, lines or a sparkline) or a realm-compare of up to six options as
...

Realm v1.5.0

Realm can use itself. A session in a space can now open a terminal pane and read what it is
actually displaying — the rendered screen, so a full-screen program's repaints resolve instead of
replaying as escape codes — and it can read Realm's own interface as elements and click in it. The
terminal provider is on by default and the interface one is off, and the asymmetry is the point:
every harness already has a shell tool, so a terminal that talks back adds a capability rather than
a second way to run commands, while reaching the window you are reading in is a different kind of
thing to hand out. A sign-in is the case that pays for all of it: claude auth login under a
non-interactive shell hangs forever, because there is nothing on the other end to answer the code it
prints. Here it runs, and Realm can read the URL, open the consent page, and stop at the one act
that grants a durable capability — which stays yours unless you say otherwise, per space.

The Agents page is a room, not only a list. Three views over the same agents, because "what is
everything doing" and "what did that one just say" are different questions and a list only answers
the second. The wall is tiles with state on their faces; the office is a drawn room with a figure per
agent in a seat, redrawn from a sentence you type at it. Ordering comes from what actually moved,
which is also what the new "Sort spaces by activity" switch reads.

Two things are called what they are. The sidebar's catch-all section said "Space" — a container's
name sitting under "Open", which names what its rows are — and now says Sessions. And a pane group
is a split: the strip above the panes, the sidebar's button, the palette's row, the ⌘⇧[ / ⌘⇧] labels
and the names new ones are given all say so. The strip also stopped crowding the traffic lights.

The cursor has the controls it should have had. A terminal's cursor gets a shape — block, bar or
underline — as its own setting rather than a mode of the blink, because a bar that holds still and a
block that pulses are both pairs people ask for. The code editor's caret gets its own blink switch,
separate from the terminal's, the same split VS Code makes. The prompter's caret still cannot be
told either way: it is the platform's, and Chromium exposes no way to hold it still until
caret-animation lands. The switch says so rather than quietly covering half of what it names.

Claude Opus 5.5 is in the model picker. Adding a Claude model is not just a row — the bundled CLI
has to know the id, or the API answers with a 400 and the session quietly runs something else. That
rule had been written in three comments and enforced by none of them, and it had already gone wrong
once. It is a test now: every model Realm offers is checked against the binary that will be asked to
run it.

Reading and writing

• Line height is adjustable, as an offset rather than a value. Prose is 1.6, markdown 1.55 and a
  code block 1.65, and one slider moves all of them from their own starting point — a control that
  set a single number would flatten the distances that are the reason a code block breathes more
  than a paragraph.
• A Quick Look render and a guide come back to where you were reading. A PDF still does not, and
  cannot: Chromium renders it in a nested viewer that runs no script of ours.
• An answer's own passage can be quoted back instead of described.
• The prompter's pickers show a scrollbar while they scroll and not the rest of the time.

Getting rid of things

• "Really delete?" is optional, in Settings ▸ App ▸ Deleting. On unless you say otherwise, and read
  so that an unset preference keeps asking.
• Sidebar rows that are not sessions have a trash of their own. Archiving is a session's answer to
  being finished; a terminal or a documents pane had no way out but a right-click.
• Downloads no longer refuse a file because of its extension. The boundary that matters is the
  grant, not whether someone has heard of .parquet.

Elsewhere

• A schedule can name a single moment — "in two weeks, open the PR" — instead of being written as a
  cron expression that fires once in 2031 and is forgotten.
• A signed-out session says what to do about it, with the command to run, instead of showing the raw
  failure. It only says so after re-checking, because the credentials file cannot answer "signed
  out" on macOS and a remedy offered on a guess is worse than none.
• A passkey works in a browser pane. Electron ships the WebAuthn API without an authenticator behind
  it, so Realm is the authenticator: the key is held encrypted and reaches the page for the length of
  one request you approved with Touch ID.
• Right-click either arrow in a browser pane for the pages behind or ahead of it.
• ⌘⇧N opens Quick Chat; ⌘⇧G makes a split. Both were reachable only by mouse.
• A profile's spaces moved into that page's rail, beside Skills, Connections and Memory, instead of
  sitting over the title as a strip of chips.

Realm v1.4.1

A packaging fix for v1.4.0, which could not start. The terminal renderer that v1.4.0 introduced
pulls in a CommonJS library, and the server bundler leaves anything declared as a dependency for the
runtime to resolve — so the shipped server carried an import Node refuses at load, and died the
moment the app spawned it. v1.4.0 was withdrawn; everything below it is in this release.

Nothing caught it, and that is the more interesting half. The test suite passed, because the test
runner resolves that import through its own transform. Type checking passed, because the types were
never wrong. The build passed, because compiling a bundle does not run it. The first execution of
that line was going to be on someone's machine.

So pnpm release now boots the server it just packaged, on a scratch home, and requires it to report
ready before the version commit and the tag exist. It closes the class rather than the instance: any
import that resolves while compiling and explodes while loading now fails the release instead of
shipping.

Realm v1.3.0

The keymap is a file. ~/Realm/keybindings.json holds rules of {key, command, when}, where
when is a boolean expression over what the window is doing — !overlayOpen && sessionFocus. The
last matching rule wins, which is how a rule you write beats a default Realm ships. Defaults are
seeded the first time it is read, and newly shipped ones merge in later unless a rule of yours
already claims that command or that key. Everything that prints a shortcut reads the same list the
handler reads, so a rebind moves the hint with it instead of leaving a lie in the palette. Settings ▸
Keys lists all 43 commands with their current chord, marks a rule a later rule has already defeated,
and says plainly when your file could not be parsed — Realm runs its defaults and leaves the file
exactly as you left it.

Your own slash commands, and scripts a space owns. A command is a markdown file with front
matter, found in the space folder's commands/, in ~/Realm/commands/, and read-only from
~/.claude/commands/; $ARGUMENTS and $1…$9 expand into the draft, and a placeholder nothing was
typed for is left standing rather than quietly emptied. A script is a named shell line — pnpm test —
that runs in a real terminal and is addressable as script.<id>.run, so a key can be bound to it.
A key bound to a script this space does not define is left alone rather than swallowed, so it still
does whatever it would have done.

Source files open in an editor. CodeMirror 6 in the documents pane, in the app's own theme, with
find, undo and a file-changed-on-disk prompt that asks rather than picking a winner. Markdown still
opens in the rich editor. ⌘P finds a file by name across the checkout and ⌘⇧P searches its contents
through git grep — which honours .gitignore and still finds the file written ten seconds ago and
never committed. A space with no checkout says so instead of showing an empty list.

A restore can take the conversation with it. Restoring a checkpoint put the files back and left
the agent remembering having written them. For Claude sessions it now rewinds both: the transcript is
cut back to that point and the provider conversation is resumed truncated at the same turn, so the
agent carries on with no memory of the turns after it. Every other agent says so rather than
implying otherwise — "Files only — the agent keeps its memory of these turns."

Agents and terminals can be sandboxed. A macOS Seatbelt policy applied when Realm starts an agent
CLI or a shell: this space's checkouts and the toolchain caches are writable, $HOME is not, and
~/.ssh, ~/.aws and ~/Library/Keychains cannot be read at all. It confines the process and
everything that process starts. It ships off, per space and on purpose: the writable-root list has
not met enough real toolchains yet, and one shared codex app-server cannot hold two spaces'
policies — so a Codex session in a sandboxed space refuses to start rather than running unprotected.
Seatbelt is not a container, and the settings page says so.

The activity lens lists your chats. Every one, across the profile's spaces, grouped by the day it
was last worked on, each row carrying the space, the folder and the branch — the facts that tell two
chats called "Fix the login form" apart. The gateway's call log keeps its record in the ⌘K sheet and
in a space's Connections tab.

Machines. A pane that shows a screen somewhere else and lets an agent drive it: a second Mac over
Screen Sharing, a cloud sandbox, or a Linux guest Realm boots here. Four transports are recognised
from whatever address a provider hands out, the password stays on this side of the relay, and the
agent's pointer is drawn as a pointer so you can watch it work.

realm-server outlives the app. It has a name, a lock and a door now: closing the window stops
looking rather than stops working, a second launch finds the daemon already running instead of
racing it for the database, and Realm keeps a menu-bar presence while it does. A refusal to run
against a server this app did not ship is enforced, not assumed.

Smaller things. A cursor on terminal output, so reattaching to a shell is not the same as losing
it. Codex's plan windows read off the wire it was already sending them on, and how much of the plan
is left. A message typed mid-turn can wait its turn or take it. Focus is restored where you left it,
with an answer to what changed while you were away.

Fixed. The band above the prompter is one object again: a plan, goal or agents strip stacked over
a composer in Plan or Ask mode kept the neutral edge while the card wore the mode's colour, which
notched the join at both sides.

Realm v1.2.0

Dividers that stay put. The line between two panes was disappearing and coming back when you
nudged it. A browser pane is a native view that composites above the window's own drawing, and its
bounds rounded each edge independently — so a pane whose left edge landed a fraction of a pixel
short covered the divider beside it and could not be drawn over in return. Even splits were where it
bit: halves round outward-safe, thirds and sixths do not. The view is now inset to the pixel grid and
can never reach outside its own box.

Reorderable pane-group tabs. Drag a tab along the strip to reorder it, or move it with ⌥←/⌥→.
The drop indicator is a rule in the gap between tabs, distinct from dropping a pane onto a tab,
which still moves that pane into the group.

First run, in two columns. The agents on the left, the space on the right. Stacked, the one field
anybody types sat below a dozen radios; side by side each half is scannable on its own. The space's
icon and colour are on that form now — first run was already choosing them, it just never showed you.

Quieter surfaces. The prompter's lift is cast from its curve rather than its box, so the shadow
follows the corner instead of squaring it off. The space strip's fill dissolves into the material
behind it, and the under-strip takes the card's ring and as much of its rounding as it can hold.

Fixed. pnpm app:icons finds and clears the stale bundle registrations that were putting an old
app icon on notification banners — every packaged build left in a worktree claims the same bundle
identifier, and macOS can resolve a notification's icon to any of them.

Realm v1.1.0

Agents. A page that reads every session the way a manager would: grouped by what they need from you — Needs you, Working, Failed, then Ready and Ended folded away — rather than by the space they happen to live in.

Connectors. The apps a space works in, connected in one click: each a vendor's own remote MCP server over OAuth, so there is nothing to install and no token to paste. Pasted links from those apps become chips that say what they point at.

Notifications reach your phone. A relay sends the three things worth interrupting for — a permission, a blocked run, a finished turn — to iMessage or a Slack webhook.

Ligatures. JetBrains Mono draws =>, !== and >= as single glyphs everywhere Realm shows code.

The model picker. The strip above the list now names the list's own separators — Claude, Codex, Cursor, Grok, DeepSeek — with each harness's mark, and takes you to one instead of filtering. Effort and permission labels moved above their controls, and the list's edges dissolve properly.

Dropped icons are compressed, not refused by the upload cap.

Smaller things. A bigger space name in the sidebar, a subtler sidebar edge, and an entrance for the connection banner and error bar instead of a hard cut.

Realm v1.0.0

The 1.0. Realm stops being a place to run one agent and becomes a workspace: documents and files
sit beside the session that is working on them, runs can be scheduled and delegated, and the whole
interface has been taken through a single design pass so it reads as one instrument.

Documents. Word, Excel, Keynote, PDF and Markdown files open in a pane of their own, beside the
session rather than on top of it. A tab is marked unsaved while you type, and a file changed on disk
under an open editor asks rather than picking a winner. The pane scrolls, and tables look like
tables.

The Library. It holds the files now, not just the skills. A card carries a real thumbnail where
the picture is the file, and clicking any card opens one preview — the render, the path, the size,
and a button back to the session that produced it, switching space when it lives in another one. Save
a copy, Reveal in Finder, Copy path, Expand and Open all route through the same predicate a session
summary uses, so a file cannot open two different ways depending on which list reached it. The skills
page was restructured alongside it, and no longer rejects a file it has just written itself.

Scheduled tasks. A clock in front of the runs — work that fires on its own schedule, with a
search field and four counted chips over the list. Beside it, a year of the days Realm was used,
drawn as a grid.

Delegation. The dock lists the sub-agents the harness is running, not just the ones Realm made.
Background Agent/Task calls return in under a second and then work for minutes, so ten of them
used to look exactly like ten finished calls; Realm now reads the harness's own task protocol and
shows them for as long as they run.

What a session knows. Every session is now told, at start, what Realm's own tools are for — and
only the ones it actually has. A space that switched the browser off is never handed a paragraph
about driving one, and each block says when not to reach for the tools, so nothing gets delegated
that would have been a one-line edit.

Plan mode looks like planning, and a plan has somewhere to go when it is finished. The permission
and mode chips are drawn as one control, and Full access no longer borrows Plan's colour.

The prompter takes / commands, starting with Export session, and a turn's summary now lands in
the transcript instead of covering the thing you type into — so what a turn produced is still
readable tomorrow.

Simulators. A control inside an Apple Simulator streamed into a browser pane can be picked. The
device screen is one canvas as far as the DOM is concerned, so Realm resolves the click against the
device's own accessibility tree and says plainly, in the prompt, that browser_act cannot address it.

A new app icon. The old one was a shader that read as a smudge at 32px. This is a drawn mark —
two interlocking bays on the app's own near-black, each face lit by the way it points: a white top,
grey sides, a near-black base — taken from one SVG to every native size, so the menu bar and the
dock come off the same geometry.

Design. Fast mode, OpenHands as an agent, ⌘K on the app's own curve, real app icons on the
permissions page, per-CLI self-update, and a pass over every control: buttons and fields on the
squircle rather than snapping square on hover, hairlines and blurs softened, settings and connections
rebuilt as cards, list edges dissolved, the sidebar actually translucent, and nothing set below 11px
anywhere in the renderer.

The site was rebuilt around what Realm does rather than how to configure it: the mark drawn live
as liquid glass on the GPU, a features page over real product screenshots, a changelog, share images
for links, and a download button that asks GitHub for the current release instead of pinning a URL
that goes stale.