PUBLIC BETA Q4 2026LOCAL, NO ACCOUNTMEASURED, NOT ESTIMATED
Knowledge thatoutlives the code.
An agentic coding harness with an experience store: the debug sessions, failed attempts and domain knowledge nobody writes down, kept locally and calibrated by whether each one actually helped.
15xa decision outlives an approach
The Problem
Agents Start Every Session As A Stranger.
A new engineer joins and spends weeks learning what the repo never states: why auth was built that way, which migration broke prod, the debugging that took all afternoon, the dos and don’ts nobody wrote down. That is what turns a junior into a senior.
Your agent never gets that. A memory layer stores facts you feed it. Nothing captures the experience of working in the project, so every session re-reads, re-learns and re-explains. In one observed Claude Code session, 8.59M tokens were processed at a 97.2% cache-hit rate, with ~90% spent re-reading files and only ~10% on reasoning. Cheaper tokens, not fewer. Anvaya is built to close the gap between a memory layer and an engineer who actually learns.
$ cat src/routes/user.rs src/models/user.rs src/auth.rs
$ cat .claude.md // 2,400 lines, rotting
→ ~28K tokens spent re-learning what session 12 already taught it
→ no recall of the last time this file broke
$ mind query (MCP / native, 4,096-token budget)
→ ~2-4K tokens of weighted, linked, decaying experience (design budget)
→ the debugging session, the decision, the fix that held, recalled once
// calibrated by which nodes actually helped
What Your Sessions Actually Cost.
Move the slider to your real number. The comparison is a per-node design estimate; the measured end-to-end lever is −11.0% median uncached tokens (micro-fold, n=5, verification 19/19).
One observed Claude Code session processed ~8.59M tokens, ~90% of them spent re-reading files. This is what one decision-packed query costs without memory.
// mind query (MCP / native), 4,096-token budget
◆ packed 3,084 tokens 2,000-4,167 range, weighted, linked, decaying
◆ per-node design estimate, file 20x · decision 16x · bug fix 24x · thread 25x; measured e2e lever: micro-fold −11.0% median uncached (n=5)
THE TOKEN FOLD
Compression In Tiers. Promoted By Measurement.
We ran the experiments other tools only summarize: micro-fold measured a real win, meso variants measured losses and were retired, and the macro summarizer was already on. The shipped default is the conservative one, each tier earns promotion with paired data or stays off.
[entire file read #1] <- re-sent
[entire file read #2] <- re-sent
[entire command output] <- re-sent
[entire diff from turn 3] <- re-sent
[entire assistant response] <- re-sent
[your new question]
[macro-compacted history after 80%]
[tool result: capped at 30% of window + re-fetch marker]
[experimental: artifact preview + exact chunk ranges]
[your new question]
// macro compaction is on by default
// micro-fold measured −11.0% uncached, promotion gated
Large tool outputs · experimental
When a tool returns a big result (a file read, a command output, a diff) the full body is written to a disk artifact and a bounded preview plus exact re-read ranges stays in context. Measured in staged validation at −11.0% median uncached tokens with verification 19/19 (n=5); the default remains off until the promotion gate clears.
Cross-round old bodies · retired variants
Folding verified old outputs across rounds was piloted and partly retired: the LRU-budget variant measured +7.8% uncached and the dead-fold variant +24.5%, and WorkingSet placements were withdrawn after ~10× regressions. Folding bodies out of a prompt tempts re-reading, the ledger now counts those recoveries.
Default-on · last resort
When the context crosses 80% of the window, a two-stage summarization collapses the oldest history into a conclusion card; at 95%, the oldest bodies are hard-dropped, keeping the last 5 turns. This is the tier that is actually on today, and the one most other tools use as their only strategy.
single tool output: capped at 30% of the window
guard line: 90% of window usage, 5% floor per result
on truncation: keep the head, append an explicit re-fetch marker, never fabricate
on pressure: emit an advisory, never a silent stop directive
Bounded output beats lost output: the model gets structure and a way back, not a wall of scrollback.
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.
Mind is empty. Every query requires full file reads, no different from any other AI tool.
First bug fixes and decisions captured as typed nodes. Retrieval starts replacing repeat reads.
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.
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.
The Loop That Gets Smarter While You Sleep.
Flat instruction files stay roughly flat across sessions, no decay, no drift check, no outcome loop in their docs. Newer additive memories store facts but don’t calibrate. Anvaya is experience-driven: each session becomes typed nodes, outcomes calibrate which nodes actually helped (a Beta-Bernoulli posterior per node), and the next turn is served only the context that earned its place. Thesis: session N+1 gets better than session N, not because the model updated, but because your project’s memory got better. The loop closes every turn, so the system self-evolves without anyone curating it.
Context Is What You Read. Experience Is What You Learned.
Most of the industry solves “how to give the model context.” Anvaya solves “how to give the model experience.” The comparison below covers both fronts: what each harness costs as a process on your machine, and how project knowledge is stored, kept honest, and chosen.
Lightweight by measurement
Idle in single-digit MB. Auditable to the page.
macOS rule: footprint is truth, ps RSS misleads: RSS includes mmap’d model pages and excludes compressed pages. So we print both, with method and date. CLI idles near ~5 MB footprint, starts in ~12 ms at ~0% CPU. The graph daemon warms to ~50 MB with the embedding model mapped, bursts on ingest, then settles, all local, all inspectable. Protocol: published measurement notes (2026-08-14) + spot-check 2026-09-05.
Release builds (opt-level 3, LTO, strip). CLI 14–19 MB binary; daemon ~37 MB + 127 MB shared ONNX model (one-time). Live gate tracks process-tree RSS (≤10% or 10 MiB regression budget); full footprint/vmmap series published per benchmark. Full table in /benchmarks#footprint →
Two Tools. One Experience.
Anvaya CLI is the agent that executes. Anvaya Mind is the experience that compounds. Three integration modes, from in-process to MCP, so the experience store works with the agent you already use.
A single static Rust binary, no runtime dependencies · 25.6 MB median RSS, 17x lighter than Claude Code · ~5 MB idle, ~12 ms to first TUI frame · 8 TUI screens · 21 native tools · headless mode for CI · 3 transports: Ollama, OpenAI-compatible, Anthropic.
Learn more →
An experience store, not a document · knowledge graph in SQLite with a hand-written HNSW index · 14 MCP tools · causal inference and thread synthesis · drift detection against git and per-type decay · captures debugging sessions, domain knowledge and project history.
Learn more →The System
Light Harness. Dense Fleet. One Local Machine.
One harness, one experience daemon, three transports, everything inspectable. The CLI is light enough to run by the hundred, the supervisor keeps them bounded, and Mind learns from every one of them, all on hardware you already own.
The Deal
An Agent You Can Audit.
A harness that runs hundreds of agents on your machine has to earn trust on the mechanism, not the marketing. Here is exactly what stays local, what leaves, and what you can inspect.
Three Layers That Are Hard To Bolt On Later.
25.6 MB median harness RSS across 238 Phase 1 runs, 21 MB floor, ~5 MB idle. Claude Code idles at 432 MB. That is a 17x gap, and it is the reason everything else on this page is possible: a harness this light is one you can run by the hundred.
Because each agent is cheap, a fleet fits on your machine. 24 agents run concurrently by default with a 256-agent hard cap, a 32-agent soak cost 103 MB total, and 25 sessions ran in parallel on a Core 2 Duo with 4 GB of RAM. Cloud swarm tools spin up agents remotely; this one does not.
A memory layer stores facts. Mind simulates the lifecycle of an engineer learning a project: debugging sessions, decisions, dos and don'ts, domain knowledge, project history. Outcomes calibrate which nodes actually helped, and drift detection keeps the graph honest as the code moves.
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.