v0.3 in the works open sourceMITRust + Claude Code

Memory for coding agents. Beyond the context window.

Trove is the open-source memory, semantic and context layer for coding agents. A Rust engine indexes your repo into layered memory. A Claude Code plugin keeps your decisions, conventions and gotchas, and loads them as skills every session.

Install in two linesinside Claude Code
/plugin marketplace add anishfyi/trove
/plugin install trove@velofy-trove

Then /reload-plugins and /trove:init. Full walkthrough in 01 Install.

01 Install

Two lines to install. Two more to start remembering.

Run these one at a time inside Claude Code. The engine is a separate Rust CLI you can build from source in a minute.

  1. 1.1

    Add the marketplace

    /plugin marketplace add anishfyi/trove

    SSH error? Use https://github.com/anishfyi/trove.git instead.

  2. 1.2

    Install the plugin

    /plugin install trove@velofy-trove

    Skills plus SessionStart and SessionEnd hooks. Read it as plugin@marketplace.

  3. 1.3

    Reload, then create your trove

    /reload-plugins
    /trove:init

    From here say "remember this" or run /trove:remember, and /trove:recall to search it back.

engine, from source
# requires Rust
$ git clone https://github.com/anishfyi/trove && cd trove
$ cargo build --release -p trove-cli
$ ./target/release/trove index
Indexed 50 files, 203 symbols, 50 modules, 2 subsystems
$ ./target/release/trove query "how does progressive retrieval respect the context budget"
## L4 Architecture Memory
## L3 Subsystem Memory  crates
## L2 Module Memory     crates/trove-retrieve/src/budget.rs
Estimated tokens: 669 / 200000
02 Project skills v0.3

Every project gets a trove. Loaded as three skills.

Each repo where an agent works keeps its own trove under .claude/trove/. Trove renders it into three skills that Claude Code lists and loads on intent, and an AGENTS.md pointer lets Codex, Cursor and pi read the same files.

conventions

How this repo is built

Style, structure, naming, commit and PR rules, and the things to never do.

memory

What we decided, and why

Decisions, gotchas and history. /trove:remember routes each entry to the right place.

context

The current map

Architecture, subsystems and key modules from the engine, refreshed by /trove:index.

your-app/
.claude/trove/
├── conventions/INDEX.md
├── memory/INDEX.md
└── context/INDEX.md
.claude/skills/
├── your-app-conventions/SKILL.md
├── your-app-memory/SKILL.md
└── your-app-context/SKILL.md
AGENTS.md  # same files, any agent
why it speeds you up
  • Stop re-explaining. Sessions open already aware of your conventions and past decisions.
  • Stop repeating mistakes. A footgun you hit once is written down for good.
  • Onboard instantly. A teammate or a new machine inherits the project trove with the repo.
  • Secret-guarded. Writes are checked so tokens and keys never land in a trove.
03 The CLI v0.3

One command for what you know. And every tool you have.

trove is a dense, single entry point on macOS and Linux. Ask a question and get an answer grounded in your personal trove, the project trove, the engine index and a catalog of every CLI on your $PATH, with citations. Retrieval-only mode works offline; an LLM step is opt-in.

zsh
$ trove ask "where is the context budget enforced?"
ContextBudget::for_total splits the budget by layer;
the pipeline stops once it has enough detail.
  [1] crates/trove-retrieve/src/budget.rs
  [2] crates/trove-retrieve/src/pipeline.rs
  [3] memory/why-architecture-first.md

$ trove tools search json
  jq        command-line JSON processor
  gron      make JSON greppable
  fx        terminal JSON viewer
CommandWhat it does
troveInteractive REPL over everything you know.
trove askAnswer one question with cited sources.
trove toolsList, search and describe installed CLIs.
trove indexIndex the repo into memory layers.
trove queryProgressive retrieval within a token budget.
--jsonMachine output for agents.
04 Docs shipping v0.3

Hand off the docs. Keep the secrets.

trove ship turns a project and its trove into handoff-ready developer docs: overview, architecture, setup, conventions, decisions and gotchas. A redaction pass runs before anything leaves your machine, and it fails closed if a high-confidence secret survives. Also available as /trove:ship inside an agent session.

secrets and tokens emails phone numbers internal hosts and IPs local paths and usernames customer names .troveignore
zsh
$ trove ship --out handoff/
wrote overview.md architecture.md setup.md
      conventions.md decisions.md gotchas.md
redacted 7  2 tokens, 3 emails,
            1 internal host, 1 local path
report: handoff/REDACTIONS.md
how it strips
  • Deterministic detectors first, so the common leaks never depend on a model.
  • Optional agent review with Claude Code, Codex or pi to catch what patterns miss.
  • A redaction report lists every removal and why.
  • Your format: a Markdown folder, a single file or a static site.
05 Proof

Higher information density. Not larger prompts.

Trove answers with architecture first and drills into modules and symbols only when it needs to. Here is the engine run against its own repository.

33x
fewer tokens

669 tokens of layered context versus about 21,900 for the raw source of crates/ and plugins/.

4ms
per query

Progressive retrieval over the index, from architecture down to symbols, with a token budget.

0.13s
to index

50 files, 203 symbols, 50 modules and 2 subsystems. Re-indexing only rebuilds what changed.

Method: Trove v0.2.0 release build on Linux, run on this repository. Query: "how does progressive retrieval respect the context budget". Tokens are estimated at 4 characters per token, the same heuristic the engine uses. Reproduce with the commands in 01 Install.

06 How it works

Two layers, one system. Structure and memory.

The engine answers "what is in this codebase and where". The plugin answers "what did we decide and why". Retrieval flows top-down and stops as soon as it has enough. See VISION.md for the full L0 to L6 design.

L1Symbols

Functions, types, traits and tests in Rust, Python, JS/TS, Go and Bash.

L2Modules

Per-file summaries: exports, dependencies, assumptions, side effects.

L3Subsystems

Package-level clusters with their key files.

L4Architecture

Repo-wide design map and dependency graph.

L5History

Decisions and gotchas imported from your troves.

hookSessionStart

Loads your trove index into context so every session starts ahead.

hookSessionEnd

Prompts a reflection and a re-index when the repo changed.

07 The app coming soon

Work memory on your desktop. Every trove, one place.

A macOS app, with a Linux build, that keeps your work memory across every project and agent: your personal trove and every project trove on the machine, browsable and searchable together. Local by default, with any sync strictly opt-in.

It is in design now. Follow along or share what you would want from it on issue #24.