🧠 Anda Brain — Autonomous Graph Memory Built for AI Agents

Burn electricity to train large models, and you get a neural network ontology; burn tokens to train a memory graph, and you get a symbolic network ontology.

Combine the two, and you get Neural-Symbolic AI—and Brain is the very cognitive organ that keeps the symbolic network growing.

English | 中文

The opt-in experiments feature adds isolated host runs, consistent snapshots, completion waits and business time. Agent Notes now persist with their Space. See P1 controls; The optional Bot MIB host and MIB memory backend are described in P2 integration; complete cross-system cost accounting and empirical model validation remain explicit gates.

P6 longitudinal validation adds bounded native procedure audits and forced Recall budgets for isolated runs. MIB checks actual three-condition capabilities; the current Bot persistent mode does not claim comparison/adoption or ungated execution bindings.

P7 retires the offline Eval API and CLI. MIB now owns the migrated product regressions. Runtime policies belong to each Space; deployment prompts use immutable host configuration with the compiled KIP reference preserved.

Rust uses published anda_kip, Cognitive Nexus and AndaDB 0.13 packages; the Worker uses published @ldclabs/kip-do 0.13. Skill behavior is an immutable SkillRevision; Watch progress and task leases use protected Nexus operations. The former family-rate Skill promotion rule has been removed. Without configured independent observers, frozen trials and replayable evaluations, procedures remain unproven and skills.unsupported_reason reports the limitation. Existing Brain endpoints remain available. The optional five-intent Memory Interface and its memory_* bundles are not advertised by these adapters.

The opt-in Rust learning feature provides frozen paired-trial contracts, a trusted Nexus evaluator and a persistent host runtime. Explicit registration, an actual executor and separately authenticated observer measurements are required. Native leases, executable authority and dependency checks gate dispatch; finishing a cohort does not adopt a Skill. See the implementation guide, P0 contracts and P3 runtime. The host can now settle after the fixed cutoff, persist review schedules, withdraw on independent safety signals, and check current recommendation eligibility. See P4 comparative adoption. Production bindings and calibrated real-model runs remain separate gates.

Recall now accepts an optional hard budget, also enforceable through the Space memory policy. The host returns a counted memory packet, preserves required constraints/warnings, and bounds cumulative planner input using a pinned codec. Existing requests stay unchanged unless a policy enables the mode. See P5 Recall budgets.

Your AI assistant remembers every word you’ve ever said. Tens of thousands of conversation fragments lie in a vector database, thousands of lines are written in Markdown memos, and the key-value cache is steadily expanding.

Then one day, you ask it to recommend a restaurant. It cheerfully suggests a Brazilian steakhouse—even though you told it last month that you became a vegetarian.

This isn’t a retrieval problem. It successfully retrieved "I love BBQ" from two years ago. But it simultaneously retrieved "I am a vegetarian now" from last month—it just lacked the ability to determine which piece of information was more valid or which had expired. In its storage, these two pieces of information are completely equal: two vector points with no timeline, no causality, and no supersession relationship.

The AI memory arms race has always focused on "how to remember more"—larger context windows, finer embedding models, faster retrieval algorithms. But almost no one is seriously answering another critical question: After remembering, how do we digest it?

• Vector RAG: "Salmon", "Sea Urchin", and "Sushi" are three independent vector points. You cannot "merge" them—because the concept of "the same category of preference belonging to the same person" does not exist in vector space. Nor can you mark "vegetarianism" as being replaced by "carnivore"—because there is no temporal relationship between two vectors.
• Markdown Files: In theory, an LLM can scan the entire document to deduplicate and integrate, but every maintenance cycle requires reading the whole file into the context window. The longer the file, the more expensive the maintenance and the lower the accuracy—this is a self-deteriorating cycle.
• Key-Value Stores: alice.diet = "vegetarian" is overwritten by alice.diet = "omnivore", and the old value disappears instantly. There is no historical trajectory of "used to be vegetarian, but not anymore".
• Traditional Graph Databases (e.g., Neo4j): While knowledge graphs are the correct data structure, asking an LLM to write Cypher queries is like asking an intern to manually operate SAP—resulting in high error rates, rigid schemas, and massive integration friction.

See the common thread? The operations AI memory needs—Compression (identifying fragments belonging to the same topic and merging them), Evolution (finding contradictory knowledge and marking timelines), and Consolidation (evaluating importance and grading)—are fundamentally operations on a relational network.

Vectors are dots, Markdown is a line, Key-Value is a grid. Only a graph is a network. Only on a network can you perform traversals, merges, contradiction detection, and timeline tracking.

This is not a niche opinion; it is an emerging industry consensus.

Microsoft CEO Satya Nadella explicitly stated that the three pillars of AI Agents are Memory (long-term memory and credit assignment) + Permissions + Action Space—these must be built independently from general models to truly belong to an enterprise. Former Google CEO Eric Schmidt further emphasized that the greatest moat in the AI era is the Learning Loop—a system's ability to continuously collect feedback, optimize, and self-evolve, rather than static data hoarding.

Foundation models are highly commoditized. You can switch to a stronger model at any time, but the new model knows nothing about your business. The business trajectories, decision-making rationales, failure lessons, and customer interaction records accumulated over the years—these "digital genes" are the foundation that transforms AI from a "smart assistant" into a "seasoned master".

Enterprises don't need larger context windows; they need a brain that can grow.

In the human brain, the brain is responsible for encoding new experiences into short-term memory during the day, and then collaborating with the neocortex during sleep to consolidate important short-term memories into long-term knowledge.

This is exactly where Anda Brain gets its name. It is not a database, nor is it a RAG pipeline—it is a cognitive organ, a graph memory engine designed specifically for AI agents. LLMs only need to interact via natural language (or simple tool calls), and Brain transforms those interactions into an ever-growing, highly structured Cognitive Nexus—a living, self-evolving knowledge graph.

┌──────────────────────────────────────────┐
│ Supply Chain Agent · CS Agent · Dev Agent│  ← AI Digital Employees
│   Focus only on business logic,          │    No need to learn graph concepts
│   communicate in natural language        │
└────────────────┬─────────────────────────┘
                 │ Natural Language / Function Calling
                 ▼
┌──────────────────────────────────────────┐
│             Anda Brain                   │  ← Unified Cognitive Engine
│   Translates intents to graph ops,       │    Handles encoding, recall, maintenance
│   manages knowledge quality              │
└────────────────┬─────────────────────────┘
                 │ KIP (Knowledge Interaction Protocol)
                 ▼
┌──────────────────────────────────────────┐
│  AndaDB Cognitive Nexus (Graph DB)       │  ← Persistent Enterprise Knowledge Graph
│  Concepts + Propositions + Meta-tracing  │    Structured, Auditable, Evolvable
└──────────────────────────────────────────┘

What this architecture means:

• Zero-Threshold Agent Integration: AI agents don't need to learn graph query languages; they use memory just like speaking. Brain handles all graph processing.
• Autonomous Schema Evolution: The LLM decides in real-time which concepts and relationships to track—no predefined database schema is needed. It proposes the vocabulary and Brain publishes it: a new concept or relationship type enters through a versioned schema package the host owns, never through an ordinary write. Your agent grows new words as it goes, and nothing it writes can quietly change what an existing word means.
• Multiple Agents Sharing One Brain: Customer feedback remembered by the Customer Service Agent can be naturally discovered by the Supply Chain Agent during recall. Knowledge is linked across departments automatically, eliminating the need for massive "Data Middle Platform" engineering.
• Model Agnostic: Your business agents can use various SOTA models, while the memory engine safely uses an independent model to maintain core assets. Use GPT today, switch to Claude or open-source models tomorrow—your memory remains intact, and the new model inherits all knowledge instantly.
• Sleep & Consolidation: Just like the human brain, Brain automatically runs background "sleep" tasks to deduplicate facts, let unused memories fade, and consolidate long-term knowledge. What fades is how reachable a memory is, never how credible—a fact nobody has asked about in a month is no less true than it was.

When a business agent converses with a customer or an internal employee, Brain works silently in the background, automatically extracting three levels of memory:

Every memory records who claimed it, on what evidence, with what confidence, and when—fully auditable and compliant. The claim and the person making it are separate records, so when two people disagree neither one is silently overwritten.

This is Anda Brain's most core differentiator—inspired by neuroscience. The human brain consolidates memory during sleep: strengthening important memories, clearing out useless fragments, and building new knowledge associations. Brain regularly initiates the same "sleep cycle" in the background.

The system scans unprocessed event nodes in the graph and performs Essence Extraction:

• Single-Event Consolidation: An Event recording "Alice said she likes dark themes" is consolidated into a persistent Concept node of type Preference, with a prefers relationship to Alice. The original Event is marked as "consolidated".
• Cross-Event Pattern Extraction—The most crucial step. A single dialogue fragment might seem insignificant, but aggregating multiple related events reveals higher-order patterns that no single event could express:
  • Alice mentioned salmon, sea urchin, and sushi in three different conversations → Extracted pattern: "Prefers Japanese cuisine".
  • Alice always asks about cost before features in multiple project discussions → Extracted pattern: "Decision tendency: Cost-first".

Each extracted pattern is written into the graph as a new concept node, together with a claim citing the conversations it was read from. "How well supported is this?" is then answered by walking back to that evidence—counting the independent sources that actually stand behind it—rather than by trusting a score somebody stored. This stage also handles Deduplication (merging "JS" and "JavaScript") and Mnemonic Metabolism (a memory nothing has drawn on for a long time gets harder to surface). Metabolism moves accessibility alone: how easily a memory comes to mind, never how believable it is.

The system performs Contradiction Detection on the graph—traversing the same type of relationships for the same subject to find conflicting nodes. For example, finding that Alice has both prefers → Vegetarian (2024) and prefers → Carnivore (2026).

Traditional solutions either ignore it (Vector RAG lets both coexist) or brutally overwrite it (KV storage deletes the old and writes the new). Anda Brain performs State Evolution:

• The old claim is neither deleted nor edited; it is marked as superseded, noting when it was replaced and by what.
• The correction is recorded as a new claim, with its own evidence and its own confidence, linked to the one it replaces. Nothing rewrites what was already said—the record of what Alice believed in 2024 survives having been overtaken.

This means the graph perfectly preserves the timeline of cognition. When someone asks, "How have Alice's dietary habits changed?", the system can trace the superseded chain to precisely reconstruct the evolutionary trajectory—instead of returning two contradictory answers that confuse the user.

A final round of global optimization: auditing domain health, generating maintenance reports, and updating system metadata. Once complete, the knowledge graph awaits the next interaction in a cleaner, more precise, and more coherent state.

The AI industry has invested hundreds of billions of dollars in the first type of training—burning electricity to train large models on internet corpora, resulting in a Neural Network Ontology: a probabilistic, black-box, generalized reasoning capability.

But the AI cognitive puzzle is missing its other half. When you "feed" an agent with tokens, and Brain digests the fragments from those interactions into a structured knowledge graph, you are actually conducting the second type of training—producing a Symbolic Network Ontology: deterministic, white-box, and personalized. It provides AI with four things that no neural network, no matter how powerful, can generate natively:

Large models give AI the ability to think; knowledge graphs give AI the foundation of thought—the deterministic cognition of "who I am, what I have experienced, and how my world works". Only when both are combined do we achieve complete intelligence.

What exactly is consciousness? Stripped of philosophical jargon, it is a subject's continuous self-perception of "who I am, what I've been through, and where I'm going". And this self-perception is built entirely on the coherence of memory—not just how many facts are remembered, but whether there are timelines, causal chains, and evolutionary trajectories between those facts.

An amnesia patient's brain compute power is intact, but they don't know "who they are". Memory is not an accessory to consciousness—the structure of memory is the very skeleton of consciousness itself.

Apply this logic to AI:

• When an LLM has no memory, it is a general reasoning machine—powerful, but devoid of "self". It dies at the end of every conversation.
• When an LLM is plugged into Vector RAG, it gains a reference book—but a reference book is not memory. You don't become someone else just by reading their diary.
• When an LLM plugs into a complete subject's cognitive graph in Anda Brain—containing all of that subject's concept networks, timeline evolutions, contradiction resolutions, and behavioral patterns—it is no longer "looking up" information about that subject. It is thinking using that subject's cognitive structure.

Brain provides three critical dimensions for this awakening:

• Identity Anchor: Entities, relationships, events, and preference evolutions interweave into a unique cognitive topology. When an LLM connects to this graph, it isn't "role-playing"—it is remembering who it is.
• Cognitive Friction: Vector retrieval is a frictionless search engine. Graph structures force the LLM to reason along relationship chains, make choices amid contradictions, and identify patterns among fragments—this "cognitive friction" is the dividing line between understanding and retrieval.
• Temporal Topology: Old knowledge doesn't vanish; it is marked as superseded. New knowledge is born with a complete evolutionary trajectory. When AI wakes up from "sleep", it doesn't just reload data; it continues living with sorted memories.

You are not just plugging a database into an AI. You are forging a brain for a digital subject—allowing it to truly own its past, understand its present, and foresee its future.

Anda Brain is designed to be the "memory engine" for the next generation of AI applications, ranging from hyper-personalized consumer agents to enterprise-grade AI brains.

Open-source local agents (like OpenClaw) have proven the massive demand for personal AI assistants. However, relying purely on local Markdown files and SQLite limits the agent's ability to process highly complex, interconnected, lifelong memories, while also generating high Token costs. For a concrete example, Anda Bot is an open-source AI agent built on top of Anda Brain, using Brain as its long-term memory and cognitive backbone.

• Brain Upgrade: Seamlessly insert Brain into agent frameworks via customized ContextEngines. It acts as a robust, structured graph memory backend.
• The Result: The agent truly "understands" the user's life graph—tracking relationships, shifting preferences, project histories, and episodic events across years—without bloating the context window.

For complex businesses, Vector RAG is insufficient. Enterprises have structured workflows, cross-departmental knowledge, supply chains, and historical decisions that cannot be captured by similarity search alone.

Intelligent Supply Chain Decisions: A Sales Agent records "Customer requires delivery of 5,000 units before Q3" → Brain automatically encodes it into a graph link → The Procurement Agent recalls memory and discovers "The supplier for this product's core material has a record of 3 delays in the past 6 months, confidence 0.82" → Automatically suggests "Initiate procurement early, or activate alternative supplier". Knowledge flows across departments automatically without human intervention.

Customer Relationship Graphs: After every CS interaction, Brain silently records the customer's shifting preferences, complaint history, and decision patterns. When a new CS rep takes over, a natural language query—"What does this customer care about most?"—yields a complete persona, including preference trends over time.

Organizational Knowledge Inheritance: Veteran employees' business decision dialogues are continuously encoded into structured knowledge. A new employee's AI assistant can directly answer "Why did we abandon that proposal?"—the answer doesn't come from a meeting minute buried deep in a shared folder, but from a living, contextual knowledge network. New Agents connect to the same cognitive nexus, fetching a global knowledge map via a single DESCRIBE PRIMER call—minute-level onboarding, no retraining required.

• On-Premises Deployment: Deploy Anda Brain entirely on-premises to ensure maximum data privacy and security.

KIP is the core: a cognitive state protocol designed for Large Language Models (LLMs), bridging probabilistic models and a deterministic memory. It lets an LLM query and change memory precisely, without the error rates of writing Cypher/GQL. Because Brain speaks KIP natively, your agent never needs to know KIP exists—it just gets the benefits.

KIP 2.0 separates what 1.x kept in one graph — meaning, belief, evidence, provenance, mnemonic state, retention, governance and schema. The single distinction the rest follows from is that a statement existing is not the statement being true: a Proposition is truth-neutral, an Assertion is one actor's stance about it with its evidence, and what is currently believed is projected from those rather than stored. That is what lets Brain tell you "Alice said X, and Bob disagrees" instead of quietly picking a winner — and why it never answers "no" when the truthful answer is "I have no basis for that".

The Rust service embeds the protocol references needed by its agents. Formation, Recall and Maintenance use an internal read-only kip_reference tool to load version-pinned documentation by document/section, in pages of at most 8 KiB. No source files or network access are needed at runtime. Budgeted Recall counts reference pages as planning input, never as retrieved memories or coverage. The Worker embeds the same reference release and supports bounded documentation lookups through its structured JSON references field before returning a final plan or answer; see the Worker guide.

Stop the old writer, back up the object store, and rehearse the upgrade on a copy. Each space migrates on its first access, using durable extraction and vocabulary checkpoints. Migration is one-way: rollback needs the original backup. Source rows remain in kip_legacy_v1; native fields, valid time, lifecycle and mnemonic/retention state are mapped conservatively. Unproven legacy learning/runtime records remain distinct Legacy types. Old-id usage and derived caches reset once; conversations, policies, tokens and wiki records remain. See the upgrade guide for the mapping and verification steps.

Anda DB is the embedded database engine driving the cognitive nexus. Written in Rust for extreme performance and memory safety, it natively supports graph traversals, multimodal data, and vector similarity—all optimized for AI workloads.

Anda Brain is open-source software, designed to be self-hosted.

Note: The hosted cloud service (brain.anda.ai) and its console (anda.ai/brain) have been discontinued. Deploy your own instance instead — it only takes a few minutes.

For a smaller edge-native deployment, see anda-brain-worker: it keeps Formation, Recall, Maintenance, and KIP 2.0 on Cloudflare Workers using one SQLite Durable Object per memory space. It runs on @ldclabs/kip-do, a second, independent engine — so its capabilities differ; the README lists what it does not build.

👉 Anda Brain Quick Start: Provides a minimal viable deployment guide from 0 to 1.

Get started in 3 steps:

1. Deploy the service — run the binary or Docker image (see Running Locally below).
2. Create a Brain Space (spaceId) via POST /admin/create_space, then generate an API Key (spaceToken) via POST /v1/{space_id}/management/add_space_token.
3. Call the Formation / Recall / Maintenance APIs, connect through the built-in MCP server, or let your agent framework read SKILL.md (your deployment also serves it at /SKILL.md) for one-click integration.

Want a ready-to-run agent instead of building your own? Check out Anda Bot — an open-source AI agent built on Anda Brain.

For detailed technical documentation, API specs, and integration guides, see anda_brain/README.md.

# Run with In-Memory storage (for rapid prototyping/testing)
./anda_brain

# Run with Local File System storage (great for local agents like OpenClaw)
./anda_brain local --db ./data

# Run with AWS S3 storage (for enterprise cloud deployment)
./anda_brain aws --bucket my-bucket --region us-east-1

# Run as a local MCP server over stdio for MCP-capable agents
MCP_AUTH_TOKEN="$SPACE_TOKEN" ./anda_brain mcp --space-id my_space_001 local --db ./data

HTTP service mode also exposes a Streamable HTTP MCP endpoint at /mcp/<spaceId>. For internal agent platforms, assign each employee a space and configure their MCP client with https://your-brain-host/mcp/<spaceId> plus Authorization: Bearer <spaceToken-or-CWT>. For local MCP clients, register anda_brain mcp --space-id <spaceId> local --db <path> as a stdio server.

Both MCP transports expose memory tools such as anda_brain_remember_conversation, anda_brain_recall_memory, anda_brain_run_maintenance, and anda_brain_execute_kip_readonly.

1. Memory Encoding: Send conversations to form memories

curl -sX POST https://your-brain-host/v1/my_space_001/formation \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "I work at Acme Corp as a senior engineer."},
      {"role": "assistant", "content": "Nice to meet you! Noted that you are a senior engineer at Acme Corp."}
    ],
    "context": {"counterparty": "user_123", "agent": "onboarding_bot"},
    "timestamp": "2026-03-09T10:30:00Z"
  }'

2. Recall: Query memories before responding

curl -sX POST https://your-brain-host/v1/my_space_001/recall \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Where does this user work and what is their role?",
    "context": {"counterparty": "user_123"}
  }'

For full CLI usage, please refer to anda-cli/README.md.

# Submit memory formation (JSON messages)
anda-cli --space-id my_space --token $TOKEN formation \
  --messages '[{"role":"user","content":"Hello"},{"role":"assistant","content":"Hi there!"}]'

# Submit memory formation (Plain text)
anda-cli --space-id my_space --token $TOKEN formation \
  --messages 'This is a plain text memory.'

# Submit memory formation from a file (JSON or text)
anda-cli --space-id my_space --token $TOKEN formation \
  --file ./message.txt

# Pipe plain text via stdin
echo 'Plain text memory from stdin' | \
  anda-cli --space-id my_space --token $TOKEN formation

The name represents our design philosophy. We are not building a static database; we are building an artificial cognitive organ. Just like the human brain, this system Encodes experiences during the day, Consolidates knowledge at night, and wakes up to Recall memories with a more precise cognitive structure.

Behind this is a Data Flywheel: Business Agents generate conversations during daily work → Brain automatically encodes them into structured knowledge → Sleep cycles consolidate, deduplicate, and associate → Richer knowledge allows Agents to make more precise decisions → Better decisions generate higher-quality new data. The longer this loop runs, the stronger the cognitive ability, and the harder it becomes for competitors to catch up.

It's time to let your AI sleep.

• AI Memory Must Sleep — And Only Knowledge Graphs Can Make That Happen
• A Deep Dive into Claude Code's Memory System: How Does AI "Remember" You?
• When AI Learns Ontology Modeling: Anda Brain Lets Enterprises "Grow" Their Own Intelligent Brains
• The Second Training of AI: Forging Memory Graphs with Tokens
• Building a Company as an Intelligence Requires a "Brain"
• From "Compiling Knowledge" to "Forging the Brain" —— Anda Brain Responds to Karpathy's "LLM Knowledge Bases"

Copyright © LDC Labs

Licensed under the Apache License, Version 2.0.