PUBLIC BETA Q4 2026BUILDS FROM SOURCELOCAL FIRST

Your AI Starts From ZeroEvery Session. We Fixed That.

Cursor and Claude Code re-read your codebase every session. Anvaya remembers everything. A true agentic operating system with 12-25x token compression. Zero API keys.

Get Started →Read the FAQ
12-25x token compression2-4K context vs ~50K raw12.1MB single Rust binary4 providers · 0 API keys
ANV, INTERACTIVE, TRY ITtype a command, try help
$

The Problem

Agents Read. They Don’t Remember.

A single Claude Code session processes 8.59M tokens, 97.2% of them cache hits. That’s not efficiency, it’s noise: the model spends ~90% of its budget re-reading files and only ~10% reasoning. Cheaper tokens, not fewer. And when the session ends, everything it learned evaporates.

For a solo developer running 8 sessions a day, that’s ~50 minutes lost to redundant reads and re-explanations , ~4 hours a week spent teaching the same things to an AI that forgets everything when the terminal closes.

✕ Without Anvaya
// Same query, third time this week
$ cat src/routes/user.rs src/models/user.rs src/auth.rs
$ cat .claude.md  // 2,400 lines, rotting
→ ~28K tokens consumed to re-learn what a fix already taught it
→ no memory of the last time this file broke
90%
of tokens spent on reading, not reasoning
✓ With Anvaya
// Same query, curated knowledge
$ anv mind context --query "user routes"
→ ~2-4K tokens of weighted, linked, decaying knowledge
→ the decisions and fixes that actually matter, injected once
// 12-25x compression, measured per node type
100%
of the model’s budget goes to reasoning

What Your Sessions Actually Cost.

Move the slider to your real number. The difference is the product , measured per node type, not benchmarked.

Raw tokens your sessions re-read slide to your reality
50,000 TOKENS / SESSION

A typical Claude Code session processes ~8.59M tokens, ~90% of them spent re-reading files. This is what one decision-packed query costs without memory.

Without Anvaya50,000 tokens
With Anvaya Mind2,000-4,167 tokens
16.2x COMPRESSION, MIDPOINT
◆ AT 8 SESSIONS/DAY, 5 DAYS/WEEK1,877K tokens saved per weekthat’s 2,000,000 tokens/week without memory → 123,360 with memory

// anv mind context --query "user routes"
◆ packed 3,084 tokens 2,000-4,167 range, weighted, linked, decaying
◆ measured per node type, file 20x · decision 16x · bug fix 24x · thread 25x (Mind README §1)

Memory That Compounds.

Every session feeds the graph. Every fix, decision, and pattern becomes context for the next. Anvaya Mind builds a living knowledge base that gets smarter, not bigger, six node types, each decaying on its own curve. After 50 sessions, your AI has the institutional memory of a senior engineer who’ve been on the project for a year.

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. Mind starts saving re-reads. Context retrieval begins working.

S20
Pattern Recognition

Causal threads form. Mind's inference engine connects related decisions across sessions.

S50+
The Senior Engineer Threshold

Mind knows every major decision, every failed approach, and lets stale ones decay automatically. A solo developer with 50 sessions has institutional knowledge that usually requires a team.

The Loop That Gets Smarter While You Sleep.

Every other tool is stateless, identical on day 1 and day 100. 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. Session N+1 is provably 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.

THE LOOPEXPERIENCE · CALIBRATION · COMPOUNDING01 · EXPERIENCEa session happens, fixes, decisions, patterns02 · CAPTUREMind ingests them as typed, weighted nodes03 · CALIBRATEoutcomes score each node, Beta-Bernoulli04 · SERVEnext turn gets only the context that earned it

Context Is What You Read. Experience Is What You Learned.

The entire industry solves “how to give the model context.” Anvaya solves “how to give the model experience.” The comparison below is about mechanism, how project knowledge is stored, kept honest, and chosen.

Stateless tools (Claude Code, Cursor, Aider, Copilot)Anvaya, Experience-Driven
Where project knowledge lives
A markdown file you write and prune by hand, CLAUDE.md in Claude Code, .cursorrules in Cursor, a conventions file in Aider.
A weighted graph of typed nodes, decisions, bug fixes, patterns, linked by cause and semantic overlap.
When the code moves on
The file keeps asserting the old thing until a human notices and edits it. OpenCode, jcode, and Codex CLI have no drift detection at all.
Content-anchored drift detection measures each node against git and flags what no longer holds.
What reaches the model
The whole instruction file, every turn, plus whatever files get re-read. Claude Code processes ~8.59M tokens per session, 90% re-reading.
A packed context built to a token budget, typically 2-4K where a raw read would spend 20-50K.
How relevance improves
It doesn’t. The file is as good as the last time someone curated it. Copilot’s workspace index retrieves but never learns.
Injected nodes are scored against what the turn actually touched; a Beta-Bernoulli posterior updates per node.
How session N+1 compares to session 1
Identical. Every tool in the industry is the same on day 1 and day 100.
Provably better. The graph compounds, calibrates, and decays, session 50 has institutional memory that session 1 didn’t.
What it costs to run
Per-token billing against a vendor endpoint.
Ollama-first and local by default. No account, no key, no metered tokens.

Two Tools. One Memory.

Anvaya CLI is the agent that executes. Anvaya Mind is the memory that learns. Three integration modes, from in-process to MCP , so the memory layer works with the agent you already use.

$
Anvaya CLI

Full-screen TUI with 7 panels · 18 native tools · headless mode for CI · 4 providers: Ollama, Anthropic, OpenAI, Siemens · ~12.1MB Rust binary, zero runtime dependencies.

Learn more →
◆
Anvaya Mind

Knowledge graph in SQLite with a hand-written HNSW index · 12-25x token compression · causal inference and thread synthesis · drift detection against git and per-type decay.

Learn more →
Direct · <0.5msMind runs in-process inside the CLI. The fastest path, used when anv owns the session and no other client needs the graph.
IPC · ~2msJSON-RPC over a Unix domain socket to the daemon. Multiple clients share one graph, with the daemon as the single writer.
MCP · ~10msThe daemon behind an MCP server. This is how Claude Code and other MCP clients reach the same memory.

The System

An Operating System For Agentic Development.

One daemon, three transports, everything inspectable. Your tool talks to Mind the way a process talks to a kernel, over a socket, with a protocol, never a rewrite of your workflow.

CLIENTS, YOUR TOOL, WHATEVER IT ISCLAUDE CODEMCP · stdioANV CLIIPC · unix socketYOUR IDEIPC · unix socketANVAYA MIND, THE DAEMONmind-daemonJSON-RPC 2.0 · 25+ methods · 6 background workers · exclusive flockPERSISTENCE, ALL LOCAL, ALL INSPECTABLESQLITEnodes · links · FTSHNSWint8-quantized vectorsTEMPORAL LOGappend-only · crc32

The Deal

A Memory Engine You Can Audit.

A product that remembers your codebase has to earn trust on the mechanism, not the marketing. Here is exactly what stays local, what leaves, and what you can inspect.

◉Your code never leaves your machineMind reads and stores everything under .anvaya/mind/ inside your project. No accounts, no cloud sync, no code in anyone else's hands. The daemon holds an exclusive flock, one writer, always local.
◆What leaves is your choiceWith Ollama, nothing leaves, the whole loop runs on your hardware. The Anthropic, OpenAI, and Siemens providers only exist if you configure a key and opt in. No key, no egress.
✦Everything is inspectableThe graph is files: SQLite in WAL mode, a flat HNSW index, an append-only temporal log, plain-text config. Open the directory, read any node, delete anything. No black boxes.
Default: Ollama, fully localRemote providers (opt-in)
Model inference
On your machine. Embeddings and summarization included. Nothing is transmitted.
Only when you add an API key for Anthropic, OpenAI, or Siemens. No key, no connection.
Memory storage
.anvaya/mind/, SQLite, HNSW index, temporal log. Project-local, gitignored.
Never. The graph is always local even when a remote model is in use.
Telemetry
No code content, no prompts, no metrics about your sessions. The daemon keeps no analytics.
Anvaya Mind has no telemetry channel today. If it ever does, it will be documented here first.

Three Layers That Are Hard To Bolt On Later.

◆
Layer 1 · Compounding Memory

Every session feeds a weighted, linked, decaying graph. Not a file you maintain, a graph that maintains itself. 12-25x compression against raw file reads, measured per node type.

◆ 2-4K context vs ~50K raw
◉
Layer 2 · Experience Calibration

Not everything in the graph is equally useful. Mind measures which nodes each turn actually touched and updates a Beta-Bernoulli posterior per node. The graph learns what helps, from your usage, not a benchmark.

◆ Utility scoring per node
⚡
Layer 3 · Anti-Decay Architecture

Other tools assert stale knowledge until a human notices. Anvaya detects drift against git, decays nodes on type-specific curves (347 days for decisions, 23 for approaches), and consolidates every 60 seconds.

◆ 6 node types, 6 decay constants

Stop Starting From Zero.

One binary. Four providers, Ollama, Anthropic, OpenAI, Siemens. Zero API keys required to start. Mind remembers everything after the first session.

Get Started →Read the FAQ