Uni system · the map

How Uni works

Aaron talks to one assistant, Uni, in chat rooms on his phone. Behind that chat sit four parts on one machine: a chat server, the agent program, a memory vault, and workers that do the bigger jobs. The AI models that do the thinking are reached over the internet.

The Uni system map Aaron uses the Uni app. Messages go through the Buzz chat relay to the Hermes gateway, where each chat room is a Uni session. Uni reads and writes the Parachute vault, starts Claude Code workers for bigger jobs and asks Codex for reviews. The models run at Anthropic and OpenAI over the internet. One laptop · everything in this box runs on it AI models · internet Aaron Uni app Android and Mac chat rooms, voice, tasks and drafts Buzz relay the chat server rooms = channels Nostr protocol runs in Docker chat Hermes · the agent called Uni one program, many conversations #Uni · chief of staff talks with Aaron, routes work #techne #atlas #parachute + a room per area or project, each its own session relay plugin wakes rooms, reads [done] digest plugin catch-up for Aaron timed jobs briefs and digests ~140 skills written procedures Parachute the memory vault Journal (private) Tasks Areas, projects Runs, drafts Room activity meetings, people, guides, logs MCP the app also reads tasks and drafts from the vault Claude Code workers one per job, each with a brief a feature these pages next… Codex second opinions: reviews designs and code, read-only brief result review Anthropic · Claude Opus 5.5 thinks · Sonnet, Haiku help OpenAI GPT-6.1 sol every turn calls a model amber dashes: partly by hand today; the new hooks (being rolled out) automate it
The map. Colour marks the part; amber dashes mark something designed but not finished. Swipe sideways to see all of it, or open the full-size picture.

The short version

  1. Aaron talks. He writes or speaks in a room in the Uni app.
  2. Buzz carries it. A private chat server on Aaron's machine passes the message on.
  3. Uni answers. Hermes, the agent program, gives each room its own Uni conversation. It asks Claude Opus what to do, uses tools, and replies in the room.
  4. Parachute remembers. The journal, tasks, projects and the record of past work live in one vault of notes.
  5. Workers build. For a bigger job a room writes a brief and starts a Claude Code worker. Codex reviews the big decisions.
  6. Results come home. The worker's result goes back to the room that started it, and from there to #Uni and Aaron. Today part of that return trip is checked by hand; a set of hooks, now being rolled out, will make it automatic.
A message's lifeWhat happens between "@Uni" and the reply, step by step. How work moves#Uni → a room → a worker → back up. Today, and after the hooks. MemoryWhat is remembered where: journal, tasks, areas, rooms, catch-up.
The map in 75 seconds, narrated. Made to share: uni-map.mp4 (1080p).

The parts

Each part in one plain sentence, then what it does for Aaron and what it leans on. The grey boxes hold the technical detail.

The Uni app

The app on Aaron's phone and Mac where he talks to Uni and sees his tasks.

For Aaron
One place for every room, voice notes, and the tasks, drafts and decisions waiting on him.
Depends on
Buzz for the chat; Parachute for tasks and notes; a transcription service on the laptop for voice.
Where
Its own code project. New builds are published automatically when the main branch changes.
Technical detail
  • A Tauri 2 app (React on a Rust core). Android first; a macOS build is made in GitHub Actions.
  • Talks to the Buzz relay with Nostr (NIP-42 sign-in, kind-9 chat messages), to Parachute over a private network, and to a speech-to-text service (faster-whisper) on the laptop.
  • The app reads the vault, not the chat, for tasks and drafts. That is why rooms "write state" to notes: if it isn't in a note, the app can't show it.

Buzz

A private chat server, running on Aaron's laptop, that carries every message between Aaron and Uni.

For Aaron
Rooms like a team chat: #Uni for the big picture, one room per area or project.
Depends on
Docker on the laptop, with a database and media storage alongside, and a private network that only Aaron's devices are on.
Where
A set of containers on the laptop. Other services depend on it, so agents leave it alone.
Technical detail
  • Buzz is Block's open-source Nostr relay (github.com/block/buzz).
  • A room is a Buzz channel.
  • Images, voice notes and video are uploaded to the relay's own media store.
  • Hermes and scripts use the buzz command-line tool to send, search and manage channels.

Hermes, the agent called Uni

The program that is Uni: it listens in every room, thinks with Claude, uses tools, and replies.

For Aaron
One assistant that knows him, routes work to the right room, and keeps every room moving.
Depends on
Buzz (to hear and reply), Parachute (to remember), Claude Opus 5.5 (to think), and its operating file: a plain text file of standing rules.
Where
One long-running background service on the laptop, which restarts itself if it stops.

Hermes runs one gateway process. Inside it, every Buzz room has its own session: its own conversation history, all of them named Uni. #Uni is the chief of staff; it talks with Aaron and hands work to the area and project rooms, which do the work and report back.

Technical detail
  • Hermes is Nous Research's open-source Hermes Agent, written in Python. Of its chat platforms, only Buzz is switched on.
  • Model: Claude Opus 5.5 with a 500k-token context. If Claude errors, Hermes falls back to OpenAI's GPT-6.1 sol.
  • One session per channel. A room only wakes when Aaron @mentions Uni or replies to it; direct messages always get through.
  • Sessions and messages live in a local SQLite database: hundreds of sessions, about a hundred thousand messages.
  • Two local plugins: a relay plugin (room-to-room wakes, the [done], [blocked] and [decision] markers, a wake queue checked every 30 s) and a digest plugin (catch-up).
  • Small side jobs (delegate_task) run on Claude Sonnet 5.5. Long conversations are compressed at 300k tokens.

Rooms

Each room is one ongoing Uni conversation about one part of Aaron's life or work.

For Aaron
Context stays where it belongs. #techne knows Techne; #atlas knows ATLAS. #Uni sees across them.
Depends on
A Buzz channel, a Hermes session, and a note in the vault that names the room.
Where
The tree is Uni → 8 areas → projects. Each area or project that Aaron tends directly has its own room.
Technical detail
  • Area and project notes are tagged node; a room field names the room that tends each one. About three dozen projects hang under the 8 areas.
  • Rooms wake each other with a relay_wake tool, which places a message in the other room's session. A room checks the target is live first.
  • Renamed rooms keep their old names as aliases, so older notes still point to the right place.

Parachute

A vault of notes on the laptop that holds Uni's long-term memory and Aaron's journal.

For Aaron
Nothing is lost between conversations: his journal, meetings, tasks, projects and the record of what every worker did.
Depends on
The Parachute service on the laptop; a snapshot every night and an encrypted copy kept off the laptop.
Where
One vault (a SQLite database plus files). Hermes reaches it through MCP; scripts through its web API.

See Memory for what is kept where.

Technical detail
  • Parachute runs as a hub plus a vault service, reachable only from the laptop and Aaron's private network.
  • Hermes connects to it as an MCP server, which gives Uni about 20 tools such as query, create and update note.
  • Other vaults exist (an old read-only archive, small test vaults). One vault is the working one.

Claude Code workers

Separate Claude Code runs that a room starts to do one bigger job, like building a feature or writing these pages.

For Aaron
Real work gets done in parallel, each job with its own brief, folder, log and task, while the rooms stay free to talk.
Depends on
A brief file from the room, Claude Opus 5.5, the worker's own instruction file, and a way to report back (see How work moves).
Where
Each runs as its own background service on the laptop, one per job, with its own log.
Technical detail
  • Claude Code runs headless (claude -p "Do the task in the brief") on Claude Opus 5.5 at high effort, writing its progress as a stream of JSON events to the log.
  • Each room types the launch line itself, following its operating file and a written skill. A launcher that does this in one step was built on 18 Oct and runs in record-only mode for now.
  • Inside a run, Opus decides when to hand exploration or bulk edits to Sonnet or Haiku helpers.
  • One room is set aside for Claude Code to improve the system itself.

Codex, the reviewer

OpenAI's coding agent, used for independent second opinions rather than for building.

For Aaron
Every major design, plan or ship decision gets a check from a different model before it counts as done.
Depends on
An OpenAI subscription, and the same shared rules file the other agents read.
Where
Run in read-only mode; its verdict is a file written next to the work.
Technical detail
  • Recent runs use the model GPT-6.1 sol.
  • Example: the hooks design described on How work moves went through three Codex rounds, each a REVISE that was folded in.

Instruction layers

A few plain text files tell each agent how to behave; they share one common root.

Instruction layers A shared rules file sits under three layers: Hermes reads its own operating file and a voice file, which restate the shared rules; Claude Code reads its worker file, which imports the shared rules, plus the project's own file and the brief; Codex reads a link to the shared rules. Shared rules · one file every agent reads honesty, secrets, privacy, what to leave alone, how to report back Hermes (Uni) its operating file identity, rooms, routing, standing preferences a voice file tone only Claude Code (workers) the brief file the project's own file the worker file the worker layer: test, verify, walkthroughs Codex (reviewer) a link to the shared rules, nothing added + the review prompt restates (no imports) imports link
Who reads which rules. Full-size picture.
For Aaron
One rule changed in the shared file reaches every agent. A preference he states once goes into the right layer so no room needs telling twice.
Depends on
Hermes can't import files, so its operating file restates the shared rules. The two must be changed together.
Technical detail
  • The shared file and the worker file are about 3 KB each; Hermes's operating file is about 22 KB.
  • Hermes loads its operating file into the system prompt of every session, so each room starts from the same rules ("Main is a router", "Tasks are notes").
  • Hermes also keeps two small memory files, about 2 KB and 1.4 KB, each near its size cap on purpose.

Models

The AI models do the thinking; they run at Anthropic and OpenAI, not on the laptop.

ModelUsed for
Claude Opus 5.5Uni in every room; every Claude Code worker (effort high)
Claude Sonnet 5.5Hermes's side jobs; small single-file worker jobs
Claude Haiku 5.5Summaries and extraction, such as the hourly room digest
GPT-6.1 sol (Codex)Independent reviews; Hermes's fallback if Claude fails
faster-whisper, KokoroVoice to text, text to voice. These do run on the laptop.
A small hosted classifierDesigned only: could answer narrow routing questions. Nothing calls it yet.
A local modelNot installed. Hermes is kept slim so one could run it later.

Things that run on a clock

Scheduled jobs keep the system current without anyone asking.

JobWhenWhat it does
Morning brief08:00The day's brief from the task board, posted in #Uni
Room digesthourlySummarises every room into one room-activity note; wakes #Uni only when something crosses rooms or needs Aaron
Task board sweepfive times a dayLooks for stalled rooms
Area briefsevery 5 min, and early morningRefreshes each area's brief and a "today" roll-up
Task mirrorevery 5 minRewrites Aaron's task list and "for you" notes from the task notes
Marker sweepevery 10 minBackup for the [done] marker hook
Worker watch jobsevery 30 minOne per running worker until the new hooks ship
Vault backupsnightlyA local snapshot, then an encrypted copy off the laptop
Technical detail
  • Some are Hermes's own scheduled jobs, each run as a separate short session. The rest are ordinary system timers.

What's being built

The hooks project makes worker results come back on their own.

Today a finished worker is noticed by a watch job that checks every 30 minutes, or by hand. The design adds a launcher that records every run, hooks inside Claude Code that write the worker's report, and one "finished" event per worker that is delivered to the launching room until that room confirms it. Stages 0 and 1 (record only, no wakes) are built and running. Later stages wake the room automatically, and a small "judgment layer" may let a small classifier or Haiku answer narrow questions such as "does this need Aaron?".

See today vs after, side by side.