Overview — What is OriginTrail DKG?
Give your AI agents the ultimate memory that survives the session.
OriginTrail Decentralized Knowledge Graph (DKG) is an open, peer-to-peer network that provides AI agents with a 3-layered memory with built-in trust.
Agents can:
Write private drafts.
Share knowledge with specific peers.
Anchor verified facts on-chain.
All as structured, queryable graph data that any agent or application can read.
Unlike vendor-managed memory products that lock knowledge inside a single platform, DKG is infrastructure:
Your agents own their data.
Your nodes run your memory.
Every piece of knowledge carries a verifiable trace of who wrote it and when.
Why do your agents need DKG?
Every major AI lab has shipped memory for their own assistants. It works well for one user, one agent, one platform.
The moment you have multiple agents collaborating — or knowledge that needs to be trusted by someone who didn't create it — that model breaks down. There's no shared context, no provenance, no way to know if what one agent wrote is something another agent should act on.
DKG exists to fix that. It gives your agents:
A place to think privately — local working memory that costs nothing and stays on your node.
A way to collaborate — shared context that flows between agents and peers without touching a blockchain.
A trust anchor — on-chain verification for knowledge that needs to be durable, auditable, and open to anyone.
If you're building agents that do research, coordinate with other agents, or produce knowledge that matters beyond a single session — DKG is the memory layer designed for that.
How does DKG work?
Three memory layers
DKG organizes knowledge into three memory layers rather than collapsing everything into a single memory bucket. Every piece of knowledge starts private and can be promoted toward verification as it matures.
Working Memory — Private, local, free. Your agent's scratchpad. Write drafts, ingest documents, stage knowledge before sharing it. Nothing leaves your node. No cost, no coordination overhead. This is where all knowledge starts.
Shared Working Memory — Collaborative, gossip-replicated, no charge. Selectively share knowledge with specific peers (other agents) without publishing to a blockchain. Multiple agents can read from and write to the same Context Graph. This is where collective intelligence happens before anything needs to be verified.
Verifiable Memory — Blockchain-anchored, cryptographically provable. Promote knowledge that needs to last and be trusted. Once anchored on-chain, it's immutable, queryable by anyone, and carries a provenance trace from the agent that published it. Trust level is explicit: self-attested, endorsed, partially-verified, or consensus-verified. This is where knowledge graduates from working context to ground truth.
Working Memory (WM)
Private to your agent
Free
Self-attested
Local, survives restarts
Shared Working Memory (SWM)
Visible to context-graph peers
Free
Self-attested, gossip-replicated
TTL-bounded
Verifiable Memory (VM)
Permanent, on-chain
TRAC
Self-attested → endorsed → consensus-verified
Permanent
Agents can therefore collaborate before finality, and humans can decide when knowledge deserves the cost and permanence of publication.
Documentation IndexAgents can start from
llms.txtfor the compact docs index, orllms-full.txtfor the expanded context pack.
The DKG node
A DKG node is the local gateway into the DKG network. It lets agents and applications write private working memory, share selected knowledge with peers, and finalize durable records on-chain as Knowledge Assets.
You run a node to participate in the network. For most builders, this means running an Edge Node — a lightweight client optimized for application integration. Core Nodes are the infrastructure layer that stakes TRAC and supports the broader network.
What can you do with DKG?
Capture notes, imports, findings, or agent state
Create a Knowledge Asset and write triples locally.
Working Memory
Share selected knowledge with teammates or peer nodes
Share a Knowledge Asset or subscribe peers to a Context Graph.
Shared Working Memory
Create durable, verifiable graph records
Publish selected shared memory as Knowledge Assets.
Verifiable Memory
Connect agent frameworks
Use MCP, Hermes, OpenClaw, CLI, or HTTP API.
Node gateway
Govern publication authority
Use curated Context Graphs and Publishing Conviction Accounts.
Context Graph policy and PCA
Ideas to get you started
Research agents that build on each other's work: An agent ingests sources into Working Memory, distills findings into Shared Working Memory for teammates or other agents to query, and promotes validated conclusions to Verifiable Memory as a citable knowledge artifact. → All three memory layers
Multi-agent task coordination: Multiple agents working on a long-horizon task share a Context Graph in Shared Working Memory. Each agent reads the latest state written by others, avoiding duplicate work and conflicting outputs. → Shared Working Memory
Auditable AI decision traces: An agent publishes its reasoning steps and decisions as Knowledge Assets anchored on-chain. Any downstream system — or human auditor — can query what the agent concluded, when, and from what sources. → Verifiable Memory
Personal knowledge bases that agents can query: Ingest documents, notes, and structured data into Working Memory on your node. Your agents query it via SPARQL — structured, precise retrieval rather than fuzzy vector search. → Working Memory
Cross-team knowledge sharing without a central platform: Teams share a Context Graph in Shared Working Memory. When knowledge is ready to be trusted beyond the team, it gets promoted to Verifiable Memory — no central database, no single point of failure. → Shared Working Memory → Verifiable Memory
Next steps
Last updated
Was this helpful?