CLI 01Mind 02Ecosystem 03Why Anvaya 04FAQ 05Changelog 06Get Started 00

PUBLIC BETA · Q4 2026  ·  BUILDS FROM SOURCE  ·  LOCAL-FIRST

Your AI Starts FromZero Every Session.We Fixed That.

Claude Code, Cursor, and Copilot re-read your codebase every session and forget what they learned when the session ends. Anvaya is a true agentic development operating system — a Rust agentic harness that executes, and a self-evolving memory engine that compounds decisions, bug fixes, and patterns across sessions. 12-25x token compression. Zero API keys required.

Get Started →Read the FAQ
✓ You’re on the list. We’ll email you at launch.Enter a valid email address.
12-25x token compression2-4K context vs ~50K raw12.1MB single Rust binary4 providers · 0 API keys
ANV — INTERACTIVEtype a command · 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.

✕ 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

The Math

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

// 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)

Self-Evolving Memory

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.

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+
Senior Engineer Threshold

Mind knows every major decision, every failed approach — and lets stale ones decay automatically. Your AI is project-aware from turn 1.

Experience-Driven Learning

Every Session Feeds The Loop That Learns.

Anvaya is experience-driven: it doesn’t just store what happened — it learns from the outcome. Each session becomes experience, Mind captures it as 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. 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

The Difference

Not Another Agent. The Memory Underneath One.

Anvaya isn’t trying to win a fight with the tool you already like. Mind attaches to it over MCP. The comparison below is about mechanism — how project knowledge is stored, kept honest, and chosen.

Hand-maintained context filesAnvaya Mind
Where project knowledge lives
A markdown file you write and prune by hand — CLAUDE.md, .cursorrules, a README section.
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.
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 to answer the question.
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.
Injected nodes are scored against what the turn actually touched; a Beta-Bernoulli posterior updates per node.
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.

The Ecosystem

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.

The Moat

What Makes Anvaya Different.

◆
Knowledge That Compounds

Unlike flat files that rot over time, Mind builds a weighted, linked, decaying graph. Every session makes every future session smarter.

◉
Zero API Keys Required

Ollama-first by design. Run entirely locally. No accounts, no tokens, no monthly bills.

⚡
Rust-Native Performance

~12.1MB binary, zero runtime dependencies, SIMD vector math. A tool that stays out of your way.

✦
Self-Evolving Intelligence

Mind learns which knowledge is useful, detects stale content via git drift, and synthesizes related insights.

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