Why Anvaya · THE MECHANISMS

Every Other AI ToolStarts From Zero.Anvaya Doesn’t.

Claude Code, Cursor, and Copilot all lean on hand-maintained context files. Storing project knowledge that way is easy, a markdown file does that. Keeping it true as the code moves, and choosing what deserves the context window, is the hard part. That’s the whole product.

The Mechanisms

Four Things That Are Hard To Bolt On Later.

01Knowledge decays on a curveEvery node carries an exponential decay term against its type's λ. A decision half-lives at roughly 347 days; an approach at about 23. Nothing has to be manually pruned, because relevance is a function of time rather than a chore.

02Stale knowledge is detected, not assumedEach node keeps content anchors into the source it came from. The daemon measures those anchors against current git state and marks nodes whose ground truth has moved. A flat instruction file has no equivalent, it asserts the old thing until a human notices.

03Usefulness is measured, not guessedWhen context is injected, the IDs go with it. The harness records which of those nodes the turn actually touched and reports the outcome back. A Beta-Bernoulli posterior per node turns that into a calibrated utility estimate, the graph learns what helps.

04It runs on your machineOllama-first by design. No account, no API key, no per-token bill, and no requirement that your codebase leave the building. The Anthropic, OpenAI, and Siemens providers are there when you want them, not because anything breaks without them.

The Curve Is The Point.

A stateless tool is equally useful on session 1 and session 100. Anvaya is deliberately worse than that on day one and better every week after, because the graph is accumulating decisions you would otherwise have re-explained.

50KTokens a typical session spends reading, without memory

2-4KWhat the same session needs once Mind is packing context

347dHalf-life of a decision node, architecture ages slowly

60sConsolidation interval, decay and confidence recomputed

50 Sessions. One Engineer. Institutional Knowledge.

A team has Slack channels, PR reviews, and onboarding docs that force knowledge retention. A solo developer has an AI that forgets everything when the session ends. Anvaya changes that equation.

× Without Anvaya

Session 1: “We decided to use JWT for auth.”
Session 2: “Wait, which auth approach?” [re-reads 30K tokens]
Session 3: “Let me check what changed in auth.” [re-reads 28K tokens]
Session 47: Still re-explaining the same architecture.

You are the project manager AND the institutional memory.

&check; With Anvaya

Session 1: Decision captured as a typed node.
Session 2: Mind injects it automatically, 2K tokens, not 30K.
Session 3: Bug fix recorded; linked to the decision.
Session 47: Mind knows every decision, every failure, every pattern.

The model has institutional knowledge. You focus on building.

What Anvaya Isn’t.

If you’re evaluating this seriously, these will matter more than the feature list.

Pre-1.0 and unreleased. You build both repos from source; there is no installer, no Homebrew tap, no crates.io publish yet.

Memory has to warm up. On a fresh project the graph is empty and Anvaya behaves like any other tool, the compounding only starts once sessions accumulate.

Mind is a Unix-socket daemon. Linux and macOS are the supported surface today.

The 12-25x figure is compression against raw file reads on a typical session, not a benchmark score. Your ratio depends on how much of your work repeats.

Stop Starting From Zero.

One binary. 11+9 Rust crates. 545 tests. Hand-written HNSW index. Three transport modes. Four providers, Ollama, Anthropic, OpenAI, Siemens. Zero API keys required to start. Mind remembers everything after the first session.

Get Started →Read the FAQ