🧬 KIP (Knowledge Interaction Protocol)

English | 中文

Why KIP?

The smartest mind in the world is worth little if it forgets everything by morning.

Today's AI is brilliant in the moment and amnesiac the moment after. Close the session, and everything the agent learned — your preferences, the decisions you made together, the promise to follow up on Friday — evaporates. Larger context windows don't fix this; they only buy a larger goldfish bowl. An intelligence that cannot accumulate experience cannot truly learn, cannot keep its word, and cannot grow.

KIP (Knowledge Interaction Protocol) fixes this at the protocol layer. It is an open standard for the dialogue between two complementary kinds of machine intelligence:

• the LLM — a powerful but stateless probabilistic reasoning engine;
• the knowledge graph — a persistent, precise, auditable symbolic memory (a network of things, and the facts that connect them).

The model thinks; the graph remembers; KIP is the language they speak to each other. It is not a database driver — it is a set of memory and cognitive primitives: remember, recall, associate, reinforce, correct, consolidate, forget. With KIP, an agent stops being a brilliant consultant with amnesia and becomes a colleague who has genuinely worked with you for years. This is Neuro-Symbolic AI made practical.

What this gives you

• 🧠 Memory that survives the session — conversations, observations, and conclusions become structured, queryable knowledge that you own, instead of context that evaporates
• 📈 Learning without retraining — the agent updates its own knowledge in seconds: new facts, corrected mistakes, evolved preferences — no fine-tuning, no GPU
• 🔍 Answers you can audit — every fact carries source, author, confidence, and timestamps; every answer can be traced back to the memories that produced it
• 🤖 A self that persists — the agent maintains an evolving self-model ($self): identity, values, lessons learned, promises made

KIP in 60 Seconds

Memory is a graph. Concept Nodes are the things worth remembering (people, projects, ideas); Proposition Links are the facts that connect them — (Alice, prefers, Dark Mode) — and facts can be about other facts. Every node and link carries metadata: where it came from, who asserted it, how confident we are, when it should be forgotten. The LLM operates this graph through three compact instruction sets — KQL (query), KML (write & evolve), META (introspect) — designed to be generated reliably by a language model.

Remember — with provenance:

UPSERT {
  CONCEPT ?dark_mode {
    {type: "Preference", name: "Dark Mode"}
    SET ATTRIBUTES { description: "Prefers dark UI themes in all apps" }
  }
  CONCEPT ?alice {
    {type: "Person", name: "Alice"}
    SET PROPOSITIONS { ("prefers", ?dark_mode) }
  }
}
WITH METADATA { source: "conversation:2026-06-11", author: "$self", confidence: 0.95 }

Recall — strongest memories first:

FIND(?pref.name, ?link.metadata.confidence)
WHERE {
  ?alice {type: "Person", name: "Alice"}
  ?link (?alice, "prefers", ?pref)
}
ORDER BY ?link.metadata.confidence DESC
LIMIT 10

Associate — "what do I know about Alice?", with no schema known in advance:

FIND(?pred, ?neighbor)
WHERE {
  ?link ({type: "Person", name: "Alice"}, ?pred, ?neighbor)
}
LIMIT 50

And when an agent wakes up inside a brain it has never seen, a single command — DESCRIBE PRIMER — tells it who it is and what it knows. The graph describes itself.

What Can You Build?

• A personal AI that actually knows you — preferences, history, relationships, and commitments that survive across sessions, devices, and even model upgrades.
• An organizational brain — institutional knowledge that outlives employee turnover and vendor changes, with compliance-grade traceability behind every answer.
• Agents that keep their promises — prospective memory as data: Commitment nodes with deadlines that resurface exactly when they are due.
• Multi-agent knowledge networks — memory enters and leaves the brain as portable, idempotent Knowledge Capsules, so agents can back up, migrate, and exchange what they know.

Architecture

One graph, two cooperating minds, and an integration layer that hides the syntax:

• $self (the waking mind) converses, encodes new memories, and recalls — in real time.
• $system (the sleeping mind) runs maintenance cycles modeled on biological sleep: consolidating episodes into knowledge, scoring salience, decaying the unused, merging duplicates, and reclaiming the expired.
• The Brain layer lets ordinary business agents use all of this through natural language alone — zero KIP knowledge required.

graph LR
    subgraph "Cognitive Nexus — one graph, every kind of memory"
        E["Event: Conversation 2026-06-11"] -->|involves| P["Person: Alice"]
        E -->|consolidated_to| F["Preference: Dark Mode"]
        P -->|prefers| F
        S["Person: $self"] -->|committed_to| C["Commitment: Send report by Friday"]
        C -->|owed_to| P
        S -->|learned| I["Insight: Lead with conclusions"]
    end

┌─────────────────────┐
│   Business Agent    │  ← No KIP knowledge needed
└────────┬────────────┘
         │ Natural Language
         ▼
┌─────────────────────┐
│       Brain         │  ← Formation / Recall / Maintenance (LLM layer)
└────────┬────────────┘
         │ KIP (KQL/KML/META)
         ▼
┌─────────────────────┐
│  Cognitive Nexus    │  ← Persistent Knowledge Graph
└─────────────────────┘

Design Pillars

Eight load-bearing decisions, for readers who want to know whether this is deep or just another wrapper:

1. Model-first language design. KQL/KML/META are not SQL or SPARQL retrofits. Declarative graph patterns, JSON-compatible literals, :param placeholders, and strictly idempotent writes make commands easy for a transformer to generate — and safe to retry when it fails. (Spec §1, §4.1)
2. A self-describing graph. The schema lives inside the graph: $ConceptType defines itself (the Genesis), and every type and predicate is a queryable node. An agent grounds itself in an unfamiliar brain via DESCRIBE PRIMER — no out-of-band documentation. (§2.9, Appendix 2)
3. Facts about facts. Propositions are first-class citizens and can be the subject or object of higher-order propositions — beliefs, attributions, and disagreements are representable, not flattened away. (§2.3)
4. Provenance mandatory, history sacred. Every assertion carries source / author / confidence; contradictions resolve by state evolution (superseded), never silent overwrite. The brain remembers what it used to believe — and when it changed its mind. (§2.10, Appendix 1)
5. Memory that metabolizes. Encoding (Formation), associative retrieval (Recall), and sleep cycles (Maintenance): salience scoring, reinforcement, asymmetric confidence decay, episodic→semantic consolidation, TTL reclamation. Forgetting is a designed feature with three orthogonal mechanisms — not a failure mode. (brain/)
6. Identity as memory. $self is a living node — persona, values, Insight lessons, growth milestones — woven into a coherent self-narrative during sleep. The agent doesn't merely have memories; over time, it is them. (Appendix 3)
7. An engineering-grade substrate. Engine-maintained _version with EXPECT VERSION optimistic locking for multi-writer brains; bulk UPDATE arithmetic (a whole decay pass in one command); atomic MERGE entity consolidation; specified keyword | semantic | hybrid retrieval with normalized scores — and reads stay reads: the protocol deliberately defines no access statistics. (§2.11, §4.3–4.4, §5.2)
8. Memory sovereignty. EXPORT serializes any subgraph into an idempotent capsule: back up your brain, migrate between engines, share knowledge agent-to-agent. Your agent's mind is an asset you own — not a byproduct trapped in someone else's weights. (§5.3)

The Road to AGI: Why a Memory Protocol Matters

Scaling gave machines fluent thought. It has not given them durable minds. A growing body of work — from memory-augmented architectures to neuro-symbolic systems — points to the same conclusion: the next leap toward general intelligence depends less on ever-larger context windows and more on memory as a system: structured, persistent, self-organizing. KIP is a concrete, implementable position in that conversation:

1. Fluid and crystallized intelligence, finally separated. The LLM supplies fluid intelligence — reasoning, language, intuition. The Cognitive Nexus accumulates crystallized intelligence — verified facts, learned preferences, hard-won lessons. KIP is the interface where the two trade. Upgrade the model, and the mind survives; keep the agent running, and its knowledge compounds.
2. Learning at the speed of conversation. A weight update takes a training run; a KIP UPSERT takes milliseconds and is inspectable, correctable, and reversible. This is continual learning without catastrophic forgetting — knowledge editing as a first-class operation, not an open research problem.
3. Identity that persists. Memory is the substrate of self. An agent that remembers its history, keeps its promises, and refines its self-model over years is categorically different from a chat session. KIP makes the self a data structure: protected core directives, an evolvable narrative, and a growth timeline written in the graph itself.
4. Accountability before autonomy. The more autonomous AI becomes, the more its knowledge must be auditable. With mandatory provenance, confidence, and supersession history, you can ask not just "what does the agent believe?" but "why, since when, on what evidence — and what did it believe before?" That is the difference between plausible text and accountable knowledge.
5. From private memory to a knowledge economy. When memory is portable and verifiable, knowledge becomes an asset: capsules can be backed up, migrated, shared, and eventually traded between agents — a market for what minds know, not just what models weigh.

What TCP/IP did for connecting machines, and SQL did for querying data, KIP aims to do for the memory of intelligent agents. The specification has been refined through 17 public revisions in its first year, alongside production implementations (Anda DB, Anda Brain, Anda Bot) — it is a proposal you can run today, and a standard we invite you to challenge.

LLMs taught machines to think. KIP teaches them to remember — and remembering, over time, is how a mind becomes itself.

Get Started

1. Run a brain. Spin up the Anda Cognitive Nexus HTTP Server (Rust, JSON-RPC at POST /kip), or embed it directly via the Rust crate / Python binding.

2. Bootstrap the mind. Load Genesis.kip and the core capsules (Person, Event, Preference, Insight, Commitment, SleepTask) — the graph now describes itself.

3. Connect your agent. Speak KIP directly — embed KIPSyntax.md in the system prompt and expose execute_kip — or skip the syntax entirely: front the graph with the Brain layer (Formation / Recall / Maintenance prompts) or the MCP server, and any MCP client (Claude, Cursor, VS Code, ...) gets a memory brain out of the box.

Documentation

Resources

This repository includes ready-to-use resources for building KIP-powered AI agents:

📦 Knowledge Capsules (capsules/)

Pre-built knowledge capsules for bootstrapping your Cognitive Nexus:

🧠 Brain (brain/)

A dedicated LLM layer that manages the Cognitive Nexus on behalf of business agents — no KIP knowledge required:

🔧 Tooling

Implementations

Version History

Full version history →

About Us

• 🔔 Products: Anda Bot | Anda.AI
• 💻 GitHub: LDC Labs
• 🏢 Company: Yiwen AI

License

Copyright © 2025 LDC Labs.

Licensed under the MIT License. See LICENSE for details.