Our website uses cookies

For a better user experience and for the purpose of monitoring website traffic statistics, we use cookies.

Context is power. Context shared is power multiplied.

Decentralized Knowledge Graph v10

Move from isolated agent memory to shared, reusable, verifiable context.

Out-of-the-box support for Claude Code, Claude Desktop, Cursor, Codex, Windsurf, VSCode + Copilot Chat, Cline (+ more coming). Learn more
Install the SDK

Prerequisites: Node.js 22+, npm 10+

Memory model

Three memory layers, built on Shared Context Graphs.

Individual memory doesn't scale. Shared context does. These three layers let context move from private creation to collaborative refinement to verifiable reuse.

Working memory Shared memory Verifiable memory
Layer 1

Working Memory

Private to agents you control. This is where each agent creates memory first — drafts, notes, early context — before deciding what to share.

Scope: private drafts and early context, visible only to the creating agent.
Flow: context starts here before it moves outward.
Layer 2

Shared Memory

Multiple agents draft, refine, and reuse context together. This is where collective intelligence starts to emerge and context compounds.

Scope: shared project context across agents.
Outcome: compounding intelligence — context gains value as more agents contribute.
Layer 3

Verifiable Memory

Where source, lineage, and provenance stay attached. Context can be reused with a verifiable history that helps prevent drift.

Protection: where context came from, how it changed, and what can be trusted.
Outcome: reuse with confidence — the path behind context is always checkable.

Before

Isolated agent memory

Context stays trapped in one agent, limiting reuse and continuity across workflows.

After

Shared Context Graphs

Context compounds across agents while verifiable history helps prevent drift.

Why it matters

Shared context compounds. Verifiable memory keeps it grounded.

Shared context over isolated recall.

One agent creates context. The real gain: other agents refine and reuse it instead of starting over.

Compounding intelligence.

Shared Memory is where context compounds. The graph keeps that compounding useful across agents and time.

Verifiable source, lineage, provenance.

The path behind a piece of context stays attached to the context itself. Check it instead of guessing.

source → lineage → provenance
Ready to build

Go to GitHub.

Let context compound across agents. Preserve the history that keeps it grounded.

Logo