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.
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.
$ 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
$ 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
What Your Sessions Actually Cost.
Move the slider to your real number. The difference is the product , measured per node type, not benchmarked.
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.
// 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)
THE TOKEN FOLD
Continuous Compression. Zero Intelligence Loss.
Every other tool re-sends your entire context every turn. Anvaya folds it to disk and sends only what earned its place. A three-tier system — Micro, Meso, Macro — that compresses without the LLM summarization tax.
[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]
[WorkingSet: goals, files, decisions]
[preview of relevant artifact + handle]
[your new question]
// Micro-Fold + Meso-Fold handle 90% of compression
// before the LLM is ever asked to summarize
Every large tool output
When a tool returns a big result — a file read, a command output, a diff — the full body is persisted to a disk artifact. Only a preview plus a handle stays in the model's context. If the model needs the full content, it re-fetches via existing tools. The ledger counts every recovery call.
Cross-round old bodies
Verified tool outputs from earlier in the session — outside the recency tail — get folded to disk as byte-identical artifacts. The model keeps tool-aware metadata (tool name, file path, digest) but not the megabytes of output. Runs in shadow mode first: computes the fold but sends the baseline request. Only promotes after quality gates pass.
Last resort
When the context hits 80%/95% of the window, a two-stage LLM summarization collapses the oldest history into a conclusion card (~800-1500 tokens). This is what every other tool does as their ONLY strategy. For Anvaya, it is the last resort — Micro and Meso handle 90% of the compression before Macro is ever needed.
goals: [what the user is trying to achieve]
files: [which files are in play]
decisions: [choices made this session]
failures: [what was tried and did not work]
artifacts: [pointers to offloaded content]
The model sees state, not scrollback. Every turn starts from structure, not from a wall of chat history.
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.
Mind is empty. Every query requires full file reads, no different from any other AI tool.
First bug fixes and decisions captured. Mind starts saving re-reads. Context retrieval begins working.
Causal threads form. Mind's inference engine connects related decisions across sessions.
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.
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.
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.
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 →
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 →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.
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.
Three Layers That Are Hard To Bolt On Later.
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.
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.
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.
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.