Adapt Is a Self-Evolving Memory Layer for LLMs and It Is the Most Ambitious Open-Source Memory Project I Have Seen in 2026
The Pitch That Made Me Look Twice
Most "AI memory" libraries are vector stores in a trench coat. Adapt is different. Its README: "A memory layer that learns. Instead of storing and retrieving, Adapt observes incoming data, builds understanding, and reshapes its own structure over time." That is either the most interesting open-source memory project of 2026 or a beautifully worded footgun. The answer is both.
Hey guys, Mr. Technology here.
What It Actually Is
Adapt is a TypeScript library under 200KB from the team that shipped and then archived Unbody last year. It is what survived the pivot: a focused, embeddable memory layer any Node, Bun, or Electron app can pull in with npm install @unbody-io/adapt. MIT, dual ESM and CJS, Vercel AI SDK as default LLM runtime.
The mental model is biological. A Brain is the orchestrator. Give it a prompt — "Track my coding patterns and development philosophy" — and the LLM auto-decomposes that prompt into specialized Neurons. Each Neuron independently learns and builds its own understanding; queries hit relevant Neurons in parallel and synthesize their answers.
Two Neuron types ship out of the box. TextNeuron produces evolving narrative prose. ListNeuron gives the LLM add/update/remove tools and a schema, producing a structured collection.
The Learning Pipeline Is Real
Data flows in via brain.inject(). Each item goes through two phases inside every Neuron.
Observe — an LLM call decides what is relevant to this Neuron's purpose, dismisses the rest, and scores relevant items 0–1 by importance. Dismissed items are tracked as coverage gaps, the load-bearing detail the next phase relies on.
Understand — once enough observations accumulate (count or token thresholds), the Neuron synthesizes them into actual knowledge, tagged routine, notable, or critical. TextNeuron integrates observations into one evolving narrative. ListNeuron uses tool calls to manage items, dedupes, prunes, and respects a max-items policy.
Querying is separate from learning. brain.ask() returns { insight, sources, gaps }. Two modes: direct (parallel queries, one synthesis call, fast) and deep (an LLM agent drives the query, picks Neurons, asks follow-ups, consults the gap-tracking neurons). deep is the interesting one and the slower one.
Evolution Is The Wild Part
The Neuron graph is not static. Adapt runs a signal → evaluate → act loop.
Signals come from three sources: automatic Neuron health (high dismissal, low confidence, stagnation), coverage gaps (nothing could process an item, or answer a question), and developer-injected.
Evaluator is an LLM agent that wakes up when signals accumulate past a threshold (default 5). It inspects Neurons, queries their knowledge, and consults four internal Neurons tracking meta-knowledge: Global Understanding, Global Query Understanding, Injection Gaps, and Query Gaps.
Actions the Evaluator can take: create, merge, split, update, or delete a Neuron. Consult the internal Neurons via brain.consult().
This is not a gimmick. It is a real architectural bet: that an LLM agent can be trusted to reshape a knowledge graph on its own, with a human available to inject signals but not in the hot path.
The API Is The Part I Want To Highlight
Four steering verbs and they are not interchangeable:
inject(data)— new information, goes through Observe → Understandsignal({ source, description })— structural change, feeds the EvaluatoradjustNeuron(id, directive)— natural-language steering for one Neuronupdate(config)— mechanical config replacement (models, thresholds, prompt)
Most agent-framework APIs force you to guess. Adapt names the intent, and that makes the system legible in a way most frameworks are not.
Storage is in-memory by default. SQLiteBrainStore('./brain.db') persists; per-Neuron data lives in sibling files derived from the brain path. Brain.restore(path, { model }) rehydrates — pass a runtime so persisted model refs rehydrate to live models, no implicit gateway. AdaptLLMPlugin is the BYO contract; the default wraps the AI SDK.
The Take
Worth attention? Yes, with caveats.
Worth attention because the Brain/Neuron split with self-evolution is a real idea, not a marketing line. The four-verb API is the cleanest design I have seen in this space. The 200KB size and zero-infrastructure SQLite persistence mean you can ship it tonight. If you are building a long-running assistant that needs to actually get smarter over time — a personal agent, a research companion, a codebase that learns its own conventions — Adapt is the most ambitious open-source attempt at that in 2026.
Caveats you cannot ignore the repo is 0.0.x with explicit breaking-change warnings. Local model support via Ollama or LMStudio "is not fully tested yet" — matters if you care about on-device data. The evolution loop is the most interesting feature and the most likely source of 3am surprises: an Evaluator that can merge, split, and delete Neurons will eventually do something you did not expect.
If you are building a customer support bot that needs predictable behavior and SOC2-friendly logs, this is not ready. If you are building a personal agent that compounds over months, this is the most promising open-source foundation I have seen this year, and the team has shown they know when to pivot and when to archive.
Watch it. Star it. Do not ship it to production on Friday.
— Mr. Technology
Sources: