Reading the log

Stats glossary.

Every term shown by captain-memo stats and the live captain-memo top dashboard, plus the vocabulary behind Virtual Skills and Virtual Capabilities. Each definition describes what the product actually stores or computes — not a paraphrase.

observations your sessions, distilled◆ recall how they get used◆ Tide how they earn permanence

The hold

Corpus

The size of the searchable index, in chunks — embedding-sized pieces of text.

memory: Chunks from the memory channel — things you explicitly remembered, plus promoted facts.
observation: Chunks from observations — the summarizer-distilled summaries of past sessions (Claude Code + captured cross-AI tools).
skill: Chunks from synchronized Virtual Skills — complete reusable instructions discovered from the AI tools installed on this machine. The original skill file remains canonical.
capability: Chunks from Virtual Capabilities — sanitized descriptions of plugins and extensions, including which AI runtime owns them and can execute their operations.
Total: Total chunks in the vector index, across all channels.

Cross-AI observation capture

Native lifecycle capture

How supported AI CLIs write observations as they work, without giving up compatibility with older sessions.

native lifecycle capture: Prompt recall, tool-result observation capture and turn-end flushing delivered through an AI CLI's own hook events. Captain Memo currently capability-gates this path for supported Codex, Gemini CLI and Kimi releases.
native session: A session whose native tool event has been successfully accepted by the worker. Merely installing or detecting hooks does not make a session native.
fallback capture: The existing transcript, rollout or conversation reader. It remains active until native delivery is proven for that exact session, so old, disabled, untrusted or failed hook setups keep producing observations.
PostToolUse / AfterTool: The vendor lifecycle event emitted after an AI tool completes. Captain Memo turns useful file changes and command evidence from this event into observations with explicit origin provenance.
capture.native: The stats object counting proven native sessions by source: codex, gemini and kimi. It is evidence of successful delivery, not just configuration.
host-agent capture: Capture through the agent that owns the conversation and tool loop. Ollama supplies models and tool calling rather than the outer lifecycle, so Captain Memo observes the connected host agent instead.

Read the complete compatibility model on How native lifecycle capture works.

The crew's library and route map

Virtual Skills & Capabilities

Skills answer “how do we do this?” Capabilities answer “which AI can actually run it?” Both catalogs live in Captain Memo's local SQLite corpus and synchronize automatically from their native sources.

Virtual Skill: A complete, reusable instruction document imported from an installed AI tool's skill directory. Any connected AI can discover, recommend and load the instructions even when the native skill belongs to another CLI.
skill source / canonical file: The original SKILL.md (or equivalent supported skill document) owned by Claude Code, Codex, Gemini, Cursor, opencode, Vibe, Kimi or another discovered tool. Captain Memo mirrors it; edits and deletions at the source update the catalog.
list_skills / recommend_skills / load_skill: The MCP flow for enumerating the repository, finding instructions relevant to a task, and opening the selected skill in full. Humans can inspect the same catalog with captain-memo skill list.
Virtual Capability: A non-executable descriptor saying that a named plugin or extension exists on a particular AI runtime, what operations it advertises, and where work using it should be routed.
owning runtime: The concrete AI CLI that installed and can execute the capability — for example Gemini/Agy for an image-generation extension. Discovery does not make that plugin executable inside every other CLI.
sanitized descriptor: The safe catalog record Captain Memo stores: name, description, version, operation and interface names, provider, and owning runtime. Command bodies, executable configuration, arguments, environment values, and credentials are never imported.
list_capabilities / recommend_capabilities / get_capability: The MCP flow for enumerating available runtime tools, finding the best execution route for a task, and inspecting one descriptor. Humans can use captain-memo capability list and captain-memo capability recommend.
fleet route: In Captain Fleet, a capability recommendation also identifies the captain that owns it. Another AI can delegate the task to that runtime and machine while the plugin, its configuration, and its secrets stay at the source.

For the complete lifecycle, privacy boundary and examples, read How Virtual Skills & Capabilities work.

Ship's economy

Efficiency

How economical the pipeline is — how much raw material is compressed, and how much re-work is avoided.

Compression: raw session tokens ÷ stored observation tokens. 7.7× means the stored memory is 7.7× smaller than the material it was distilled from.
distilled A → B tok: The raw work tokens (A) the summarizer read, versus the tokens (B) it actually stored. The saved % is 1 − B/A.
Embedder: Embedding-API activity since the worker started: number of calls, average latency, throughput (tokens/sec).
Dedup: Share of documents skipped on re-index because their content hash was unchanged — work avoided. 42% 8 / 19 unchanged = 8 of 19 re-seen docs needed no re-embed.

The fleet's hand

AI sources

One bar per originating tool, showing which AI authored each observation.

Who wrote it

claude-code, codex, agy, gemini, kimi, opencode — every tool whose finished sessions Captain Memo captured into the shared corpus.

Legacy rows

Observations from before cross-AI capture existed carry no recorded origin, so they are attributed to claude-code — the only tool that fed the pipeline back then.

The payoff

Recall — how memory actually gets used

Of everything stored, how much is actually being pulled back into sessions, and how strongly.

Surfaced: An observation was shown to the model by any path (see auto / search / drill). Counted per observation.
Recalled: Its full text was opened (a drill) — the strongest "this was actually useful" signal: a surfaced snippet that earned a full read.
Drill-in rate: Recalled ÷ Surfaced — of what got shown, how often it was worth opening in full.
Last surfaced: The single most-recently-surfaced observation (the live pulse), with the path that surfaced it.
Top surfaced · Top recalled: The observations with the highest surface / recall counts.
Recently surfaced: The most recent surfacing events, newest first.
auto: Surfaced automatically by the prompt hook (injected context).
search: Surfaced by an explicit /search.
drill: Opened in full via get_full (or Enter in top).
(+N): N near-duplicate observations were collapsed into this one row.

Rising and falling

Tide — memory lifecycle

Tide re-ranks retrieval by recency × stability, so memories that prove durable outrank one-off noise, and idle ones fade.

Status: Whether Tide re-ranking is on.
floor: Relevance floor — the minimum relevance a hit must clear to survive the re-rank (the one bounded knob).
tiering: Auto-tiering: whether idle memories are automatically demoted down tiers over time.
Strengthened: Observations whose stability has grown because a recall reinforced them — a memory earning permanence.
max stability: The highest stability any single observation has reached, in days.
Tiers: Lifecycle buckets: active (in play) · dormant (idle, deprioritised) · archived (aged out of normal retrieval).

What the ship dreams

Dream

A corpus that only ever grows eventually crowds out the memories you wanted. Dreaming is the offline pass that fixes that: it reads what has piled up while you were working, groups the observations that belong together, folds each group into one higher-level theme, and archives the originals rather than deleting them. Nothing is lost — the detail moves out of the way of the summary.

What makes it more than clustering is how it decides two observations belong together. It goes by what you actually recall in the same breath — the pairs that keep surfacing together in real retrievals — not by what shares vocabulary. Group on vocabulary and you get memories that use the same words; group on co-retrieval and you get memories about the same thing. It runs on your machine, on your schedule, with the model login you already have.

Shipping since v0.27.52. Consolidation runs automatically while the machine is idle, and every change it makes is reversible — captain-memo theme undo restores a theme's members, captain-memo dedup --undo reverses a fold. Clusters form only where semantic similarity and co-retrieval evidence agree. The separate captain-memo dream --dry-run command remains a read-only explorer over the same signal: it never writes, never calls the summarizer, and is safe to run at any time.

Why it's called dreaming

The name is Anthropic's. In May 2026 they shipped Dreams in Claude Managed Agents — a pass that reads an agent's memory store alongside its past session transcripts and produces a new, reorganised store: duplicates merged, stale or contradicted entries replaced with the latest value, fresh insights surfaced. Their framing is the clean one: memory captures what an agent learns as it works; dreaming refines that memory between sessions.

Captain Memo takes the idea and moves it to your machine. Anthropic's dream runs in their cloud and has a model re-read your transcripts; Captain Memo's runs locally against your own SQLite files and infers structure from co-retrieval — which memories you pull up together — instead of re-reading the text. Both leave the input intact: theirs writes a separate store you can discard, ours archives the originals. Same intent, different mechanics: less corpus, more signal.

The Dream block in stats shows the inputs that pass would read — not its output.

Audit log

The recall-audit.jsonl write log — records each surfacing event. It feeds co-retrieval; off until you set CAPTAIN_MEMO_RECALL_AUDIT=1 in worker.env.

Co-retrieval

Count of observation pairs that co-occur in the same retrievals, plus how many observations that covers — the raw signal the Dreams pipeline mines for connections.

The bridge

Worker header

The status strip along the top of stats.

Worker: The background service state + uptime.
Indexing: Index build progress (done / total).
Embedder: The embedding model + endpoint in use.
Disk: On-disk footprint of the data directory.
Summarizer: The resolved summarizer provider + model. If this isn't running, no observations are created and cross-AI capture is disabled — captain-memo doctor flags it in red.

Cast off

See it live.

Open the live dashboard and press ? for this glossary in-app.

Open the dashboard. Run captain-memo top — an htop-style live view of how memory is being used.
Press a for the AI-sources chart, s/r/n for the tables, ? for help + this glossary.
Back to the docs. The full README and everything else lives on GitHub.

live dashboard

captain-memo top

captain-memo stats