Anvaya Mind  ·  THE EXPERIENCE LAYER

Experience ThatCompounds AcrossEvery Session.

Most memory layers give an agent a place to store facts. Mind is built around a different idea: the lifecycle a junior engineer actually goes through on the way to senior. It captures what was decided, what broke, what pattern held, the dos and don’ts and the domain knowledge the repo never states. It runs locally, stores everything under .anvaya/mind/, and hands back a packed context sized to whatever budget you give it. It also exposes that experience to Claude Code, Cursor, or any MCP client through an MCP server, so the graph serves the agent you already use.

The Shape Of It

Not A File. A Graph.

Six node types, each with its own decay constant. A decision about your auth model should outlive the bug fix you shipped last Tuesday, so it does, by roughly fifteen times.

Decision λ 0.002Why a path was chosen. Half-life ≈ 347 days, decisions age slowly.
Synthesis λ 0.001Insight condensed from several nodes. The slowest to decay.
Pattern λ 0.005A recurring shape in the codebase.
Concept λ 0.008A domain idea the project depends on.
BugFix λ 0.015A specific defect and its resolution. Ages faster, code moves.
Approach λ 0.030A tactic tried. Decays fastest; most are superseded.

Six Stages Between Question And Context.

Every query runs the same pipeline. The expensive part isn’t finding related nodes, it’s deciding which ones still deserve your token budget.

01RecallCandidate nodes are pulled by semantic similarity through the HNSW index and by keyword through SQLite FTS.
02Link expansionTyped edges are walked, causal successors, thread continuations, semantic overlap, to pull in what the seed nodes imply.
03GravitasEach node is scored by exponential decay against its type's λ, combined with a confidence term.
04InvalidationContent anchors are measured against current git state. Nodes whose source has drifted are flagged low-confidence.
05UtilityA Beta-Bernoulli posterior per node, updated from whether past injections were actually used, reweights the ranking.
06QuorumA submodular budgeted pack selects the final set, maximum coverage, minimum redundancy, under your token budget.

Where The 12–25x Estimate Comes From.

Per-node compression is a design estimate from Anvaya’s memory design work, each node type stores a fraction of the raw tokens that produced it, not a benchmark result. The measured end-to-end lever today is −11.0% median uncached tokens (micro-fold, n=5, verification 19/19); Phase 6 measures the compounding curve itself.

20xA file read, replaced by what was learned from it
16xA decision, against the discussion that produced it
24xA bug fix, against the session that found it
25xA thread, against the sessions it spans

Experience That Compounds.

A memory layer stores what you tell it. Anvaya Mind captures what a project teaches you: the debugging session, the decision, the pattern, the dos and don’ts, the domain history the repo never writes down. Every session feeds the graph, six node types each decaying on its own curve, with drift checked against git, so the agent compounds toward seniority instead of restarting cold. The compounding claim (session N+1 costing less and knowing more) is the thesis Phase 6 of the benchmark program exists to measure.

S1
Blank Slate

Mind is empty. Every query requires full file reads, no different from any other AI tool.

S5
Early Memory

First bug fixes and decisions captured as typed nodes. Retrieval starts replacing repeat reads.

S20
Cross-Session Recall

Decisions, patterns and bug fixes accumulate with per-type decay. Causal-thread materialization is implemented but default-off, so this stage is a design target until it is promoted.

S50+
The Compounding Target

The thesis: a solo developer's graph holds the decisions and failed approaches a team would remember. No longitudinal study exists yet: Phase 6 of the benchmark program measures whether session N+1 costs less and knows more than session N.

Everything Local, Everything Inspectable.

One directory inside your project, gitignored by default. SQLite in WAL mode for nodes, links, sessions and full-text search; a separate file for the Int8-quantized HNSW index. Nine background workers and an optional MCP listener keep it consolidated.

.anvaya/mind/memory daemon
├── mind.db        nodes, links, sessions, FTS
├── mind.vectors   HNSW index (Int8-quantized)
├── mind.sock     JSON-RPC over a Unix socket
├── mind.log      append-only temporal log
└── config.json   your overrides

Run Agents That Fit On Your Laptop.

25.6 MB median RSS. 25 agents ran in parallel on a Core 2 Duo with 4 GB RAM. Hundreds on your machine. Zero cloud required on the Ollama path.

Requires Rust/cargo to build from source. Linux and macOS today, Windows not yet supported. Pre-1.0, public beta. Pricing TBD.