docs

One repo, one installer, two surfaces. This is where you go from a clean box to a running reverie mesh — the memory daemon up, the cortex console on your path, and a mental model for which piece is doing what.

The mental model

reverie ships as a single repo that builds three things you care about. They are easy to keep straight once you know which question each one answers:

• reveried — the daemon. The long-lived process that holds the memory store and serves it over HTTP on :7437. It answers “what should this agent know?” and runs the offline consolidation (“dream”) cycle over what it has stored.
• reverie — the memory layer the daemon manages: placement-aware storage, consolidation, the bet that agent failure is a context problem and not a model problem. The daemon is how it runs; reverie is what it is.
• cortex — the operator console. A single CLI that talks to reveried over HTTP and manages local agent sessions over tmux and git worktrees. It answers “what are these agents doing, and what am I letting them do?”

The seam: you rarely talk to reveried directly. cortex is the surface you drive the daemon and the mesh from. reverie decides what an agent remembers; cortex steers the agents that use it. They live in one repo and are versioned together.

One-shot install

The default path gets you a running reveried daemon, the cortex CLI, and the bench harness on any machine with a Rust toolchain — about five minutes on a clean box:

git clone [email protected]:cerebral-work/reverie.git
cd reverie
scripts/install-reverie.sh

That single script:

• Verifies cargo + rustc are present, then builds the workspace with cargo build --release --workspace --all-features.
• Copies the built binaries — reveried, cortex, reverie-bench, reverie-tracee — into ~/.local/bin/.
• Probes Redis on 127.0.0.1:6379 (only a warning if it’s missing — the daemon still starts and degrades to a filesystem fallback).
• Installs the systemd user unit at ~/.config/systemd/user/reveried.service and starts it.
• Polls /health on :7437 and exits non-zero if the daemon doesn’t come up.

Nothing is written outside $HOME and no sudo is used. The script is idempotent — to upgrade, git pull and run it again; it stops the daemon, swaps the binary, restarts, and re-smokes /health.

Quickstart

With the daemon installed and running, everything else routes through cortex. A first session, end to end:

cortex init                 # cold-boot the mesh: verify infra, enable the reaper,
                            #   restart canonical workers, spawn the queue fan-out
                            #   pool; prewarm Ollama if available
cortex health               # confirm reveried is live on :7437
cortex sessions up          # bring up all canonical workers via mesh-spawn
cortex dash                 # watch the mesh live
cortex sessions down        # tear down all workers (preserves dirty worktrees)

cortex health --json is the one-shot probe across daemon + coord — the same signal external monitors consume. For the full set of verbs and flags, cortex --help is the canonical surface; this hub covers the path in, not every command.

Where to go next

The two projects this installs, each with its own page:

• reverie → — the memory layer: what it decides an agent should remember, where it places it, and how it’s validated.
• cortex → — the operator console: the full surface of verbs for bringing the mesh up, inspecting it, and gating it.

Status

Proprietary, bundled together and versioned with reverie (currently v0.9.13). Commands and flags will move until the v1.0 milestone — this hub tracks the install and bring-up path as the surface settles. For commercial licensing, embedded use, or evaluation access, [email protected].