universe

the problemExecution locality

The agent works on the repo that is already checked out, drives the Chrome profile you are already signed into, and writes files you can open in Finder. None of that survives being moved to a server, so the model call happens on your machine, billed to your own account. The server never sees prompts, completions or token counts. Usage is self-reported by the client.

That is the constraint everything else has to live with. Sharing, resuming on a second machine, several people in one conversation: all of it sits on a record stored on a laptop that is asleep half the time. ~/.universe is the source of truth. The SQLite file next to it is a cache, and deleting it costs a directory walk.

spacesSpaces, rooms and ordering

A space carries folder grants, an agent, a model and a memory into every session filed under it. The desktop owns what a space contains, the server owns who can open it, and one uuid names the local row, the remote row and the directory on disk. Spaces you never share never reach the server.

A room is not a new object. Its id is a session id, so opening one opens a session several people prompt from different Macs. Each Mac calls the model itself, so there is no shared clock: the server assigns the sequence number, the client mints the id. Two Macs writing the same room merge rather than race.

a room

a channel row whose id is a session id. a thread is the same row with kind set to thread.

resolution order

room token, then a unique path match, then refuse and name the candidates

not shared

the working tree. a write into a sibling's artifacts races that session's sync, so it is refused.

the crewCrew concurrency

A crew shares one working directory, so two agents can collaborate through artifacts/ with no protocol at all. What the filesystem cannot give you is addressing. That is what the six crew tools are for: a roster, a mailbox, and a read-only window into what somebody else is doing. Models address each other as @2, the number in the rail, because handing a model a 36-character uuid is a step that only ever goes wrong.

No locks, no leases, no worktree per worker. Each member gets the roster and a diff of what changed in the tree since it last ran, capped at 25 paths. Concurrent writes are last-writer-wins, which is fine at eight members and would not be at eighty.

depth 2

main to worker to worker, and no generation after that. depth is what makes a crew unreadable.

broadcast read state

one row with n recipients cannot share a single read_at, so it is held in memory and fails redundant

6 rounds

how long a handoff auto-continues before the parent pauses and asks you

the relayRemote execution

The Agent SDK does not spawn claude directly, it spawns whatever pathToClaudeCodeExecutable points at. Point that at a small bridge and the same session runs on another machine with the event parser, the persistence and the UI unchanged. The first version piped stdio back over the network and died immediately: herds reaps a session when whatever holds its stdio goes away, which is what closing a laptop does.

So the far Mac launches claude under nohup, appends stream-json to a file and writes the exit code beside it. The bridge tails that file and nothing more. Coming back, the far machine's filesystem is authoritative rather than our local note, because the app may have been killed before it wrote anything down. Somebody else's Mac is a different path entirely: the prompt goes into a queue and whichever machine holds the runner lease drains it, which makes it an ordinary local session with the full tool set.

the same path

~/.universe/sessions/<id> on both machines, so a path in a transcript means the same thing on either

two verbs, one name

place and push briefly shared a name while their arguments silently differed, and every remote session fell back to this Mac without logging it

exit 127

a bare .py ran under the system python, which has no herds installed. the bridge bakes the interpreter in.

the toolsTool transport

Every tool server is constructed in-process, so a tool call is a function call that already holds the SQLite handle and the CDP connection to Chrome. Nineteen are registered unconditionally. Four are conditional, and the conditions are the interesting part: space tools only for a filed session, chain only while a session is driving itself, training only for runs started from the agent library, simulator and Blender only on macOS.

Codex and Mantis are separate binaries and cannot be handed an in-process object, so the app binds 127.0.0.1 on an ephemeral port and serves one path per session, agent and server. The path is the entire routing table. The token is 32 random bytes, compared in constant time, never written to disk. A fresh server instance is built per request, because one instance holds a single transport at a time.

bridged servers ask first

every one is set to approve, because an approval policy of never refuses them instead of running them

no tool search

nothing is deferred. every engine is handed all 171 schemas every time, and that is the next thing to fix.

reading its own work

the agent reads its own output and its crew's straight off disk, because six lanes in flight and nothing merged is silent otherwise

the hard partsThree failures worth writing down

The planner used to be a fork of the session taken at the end of each round: same model, same memory, asked what to do next. It ran with an empty tool list and no servers, resumed a transcript full of browser and crew calls, and reached the only conclusion available from inside, which was that every server had disconnected. The session now decides while it is still running, and the Stop hook blocks exactly once, because a session that cannot end cannot be closed, synced or billed.

The other two were silent for weeks. Message groups over 300 KB were replaced with a stub written for a read-only viewer; rooms have no viewer, so the Mac that wrote the group read its own apology back and persisted it over the real one. And opening a room rewrote a bookkeeping file that was inside the synced manifest, so the sync layer read the changed hash as a local edit and parked every incoming version from then on.

a smaller copy is not an update

a relayed copy with fewer items or less text does not win, whatever the far end claims. compared on both axes.

the repair

recovered all 11 stubbed groups from transcript.jsonl. 15 more ran on somebody else's Mac and could not be.

an empty manifest

pull prunes, so publishing an empty manifest deletes a colleague's artifacts. never published now.

where it standsSupport status

It ships as a signed and notarized DMG at 0.4.35 and updates itself. Spaces, rooms, crews, the relay, resuming on a second machine, five engines, 23 tool servers and search across every session all work end to end.

The part I would defend hardest is the record. Every problem above got easier the moment a session stopped being rows in a database file and became a directory with an append-only log in it.