How it works

The original is kept. Everything else is built on top.

RivetHub does four things with what your agents do: it captures the whole session, makes it searchable, organizes it into something a person can read, and serves it back to you and to any agent.

Capture: the whole session, from each tool's own hook

Each tool calls rh capture hook from its own hook system. The hook reads the tool's transcript and posts new prompts, replies, tool calls and tool results to your node. It always exits cleanly, so a capture problem never blocks your session; if the node is down, the batch is spooled to disk and sent on the next run.

ToolCaptures onReads
Claude CodeUserPromptSubmit, PostToolUse, Stop, SubagentStop, SessionEndthe session transcript
CodexStop, SessionEnd~/.codex/sessions
Grok BuildStop, PreCompact, SessionEnd~/.grok
OpenCodesession.idle, session.error, from an OpenCode plug-in~/.local/share/opencode/opencode.db
DeepSeek Harnessturn/end, from a dsh plug-in~/.dsh

rh harness connect <tool> does the wiring. Turn on memory.capture.redaction in ~/.rivethub/config.yaml to strip secrets before anything is stored; it is off by default. RivetHub's own model calls are never captured as sessions.

The Sessions list in the RivetHub app on sample data: sessions from Claude Code, Codex and Grok Build by day, each with a one-line gist, its topic and its message count.
Every captured session, from every tool, in one list (app preview, sample data).

Summaries: a tree over each session, never a replacement

When a session goes idle, the summarizer writes a tree of summaries over it: leaves over stretches of the conversation, branches over leaves, one root over the whole. Long sessions stay readable, search can match an idea rather than an exact phrase, and an agent can read a session one level at a time.

The captured messages stay exactly as they were. A summary hit expands back to the messages it was written from.

A session in the RivetHub app on sample data: the summary of the whole session, its branches and leaves, each leaf linking to the messages it was written from.
A session opens on its summary tree; each leaf links back to its messages (app preview, sample data).

Topics and decisions: work filed where it belongs

Sessions are filed into work topics, nested up to four levels. File a session yourself, or let the categorizer do it; it never overrides a placement you made. Each topic carries its decisions: short, dated statements of what was agreed.

The people, hosts, services, repositories and models your work mentions become entities, with pages of their own, kept apart from the work tree.

A topic page in the RivetHub app on sample data: the article the workers wrote, its dated decisions, and the sub-topics inside it.
A topic: its article, its decisions and the topics inside it (app preview, sample data).

Wiki: what is currently true, rewritten rather than piled up

The wiki builder reads each new summary and updates the pages it concerns: one page per root topic and one per entity. A page is rewritten within a fixed size budget, so it stays current instead of growing forever. Whatever a rewrite drops is archived, not lost.

On a standalone node, pages are written as plain Markdown files under wiki_dir (for example ~/.rivethub/wiki). On a Postgres datahub, each scope is a Git repository you can clone, read and diff. Agents read the wiki with wiki_search and wiki_read.

An entity page in the RivetHub app on sample data: a machine's wiki article, its current facts, and a dated timeline of changes.
An entity's wiki page: the article, the current facts and how they changed (app preview, sample data).

You approve changes

Changes to the shape of your memory (merging two topics, moving one, renaming, closing, deleting, creating a topic or a type) wait as Tidy proposals until a person approves or rejects them. Today proposals are reviewed through the node's API (/api/tidy/proposals), and will appear in the desktop app once it releases. Deleted sessions move to trash first.

The Review page of the RivetHub app on sample data: a conflict between two sessions, new facts, new entities and suggested filings, each waiting to be accepted or rejected.
Review: everything memory is unsure of, waiting for a person (app preview, sample data).

Recall over MCP: any agent can ask

rh mcp serves your memory to any MCP client, over stdio or over HTTP with a bearer token. rh harness connect adds this entry for you.

any MCP client
{ "mcpServers": { "rivethub": { "command": "rh", "args": ["mcp"] } } }
memory_search
Hybrid, keyword, fuzzy, regex or vector search, with date filters.
memory_browse
Messages in time order, by day or by session.
memory_get_full
The full text of a result that search shortened.
memory_stats, memory_tags
What is stored and how it is labeled.
wiki_search, wiki_read
The topic and entity pages.

Export and move: the record goes where you go

rh memory export writes a store out and rh memory import reads one in. rh memory merge-store folds one Postgres store into another in a single transaction. rh memory bundle packages chosen sessions for another RivetHub to ingest, and rh memory sanitize scrubs secrets from a bundle and writes a report of every change before it leaves your machine.

On one machine the whole record is a single SQLite file you can copy.

Models: bring your own, or none

Nothing is required to start. Capture and keyword search need no model. Add an embedding endpoint for semantic search, and a chat model for summaries, filing and the wiki. Any OpenAI-compatible endpoint works, local or hosted, and the model you choose is the only thing outside your node that sees session text. Jobs wait, they do not fail, while a model server is unreachable.

The setup guide has the config.

The 46-second overview

With sound and captions. Illustrated walkthrough (not app screenshots); commands match rh 0.8.

See it with your own sessions.

Three steps to a first captured session, with no model and no account.