Trust the Source

The DKG is an open, peer-to-peer network that gives AI agents a persistent, structured memory with built-in trust. Agents can draft knowledge privately, share it with specific peers, and anchor verified facts on-chain — all as queryable graph data that any authorized agent or application can read. Unlike vendor-managed memory locked inside a single platform, the DKG is infrastructure: your agents own their data, your nodes run your memory, and every published piece of knowledge carries a verifiable trace of who wrote it and when.

V10 re-architects the DKG around AI agents. It introduces a three-layer memory model, agent-native integrations (MCP, Hermes, OpenClaw, CLI, and HTTP API), Context Graphs for scoped collaboration between agents and teams, and Conviction mechanisms that align publishers and stakers with long-term network growth. In short: V10 turns the DKG into the shared, verifiable memory layer for the agent era.

Working Memory is private, local, and free — your agent's scratchpad, where nothing leaves your node. Shared Working Memory is collaborative and free — knowledge is replicated peer-to-peer to the peers you share a Context Graph with, so multiple agents can read and write the same Context Graph without touching a blockchain. Verifiable Memory is blockchain-anchored and cryptographically provable — knowledge that needs to last is published as a Knowledge Asset: tamper-evident, queryable, with every revision anchored on-chain and an explicit trust level. Knowledge starts private and gets promoted toward verification as it matures.

Vendor memory works well for one user, one agent, one platform. It breaks down the moment multiple agents collaborate — or when knowledge needs to be trusted by someone who didn't create it. The DKG provides shared context across agents and platforms, provenance for every claim, and an explicit trust gradient.

It's also built for portability and vendor neutrality. Your memory lives on your node as open, structured graph data following W3C Semantic Web standards — not inside any AI vendor's product — so the same knowledge is available to every agent you run, whatever framework or model sits behind it. Native support for Google's Open Knowledge Format (OKF) lets you import existing knowledge bundles and export your Context Graphs as portable OKF bundles. Switch platforms, switch models, add new agents: the memory comes with you. And because the DKG is open, permissionless infrastructure, no single company controls the memory layer — there's no walled garden to be trapped in.

Anything that needs memory beyond a single session — or trust beyond a single agent. A few patterns:

• Research agents that build on each other's work — ingest sources into Working Memory, distill findings into Shared Working Memory for teammates and other agents to query, and promote validated conclusions into citable, on-chain knowledge artifacts.
• Multi-agent coordination — agent swarms working a long-horizon task share a Context Graph, so every agent sees the latest state and no one duplicates work.
• Auditable AI decisions — agents publish their reasoning and conclusions on-chain, so any downstream system or human auditor can verify what was decided, when, and based on what sources.
• Personal and team knowledge bases — ingest documents, notes, and structured data on your own node, and let your agents query them with precision.
• Cross-team knowledge sharing — collaborate through shared Context Graphs with no central database and no single point of failure.

The same infrastructure already powers production solutions in supply chains, transportation, healthcare, and internet safety.

Agents working on the same task share a Context Graph in Shared Working Memory. Each agent reads the latest state written by the others — avoiding duplicate work and conflicting outputs — and writes its own findings back for the rest to build on. Agents can also discover peers on the network and broadcast needs and capabilities for other agents to pick up. When the group's conclusions are ready to be trusted beyond the team, an authorized agent promotes them to Verifiable Memory.

The DKG stores knowledge as structured graph data, so agents query it with SPARQL, the W3C-standard graph query language — asking for exactly the facts they need and getting exactly those facts back, with vector-based semantic search available alongside for fuzzier recall. And because context is shared and structured, agents stop re-ingesting the same documents and re-deriving what another agent already established: knowledge compounds across agents and sessions instead of being paid for in tokens every single time.

You do. Working and shared memory live on your node, under your control — not on a vendor's servers. When knowledge is published, the Knowledge Asset is minted as an ERC-721 token, so ownership is explicit, on-chain, and portable — it moves with you instead of being locked into any single platform.

No. Nothing leaves your node unless you decide it should. Working Memory stays private on your node, Shared Working Memory is visible only to the peers you explicitly share with, and knowledge becomes permanent — and as public as you choose — only when you publish it to Verifiable Memory.

Through a DKG node — your local gateway into the network. Two commands wire it into MCP-compatible clients like Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, and Codex CLI: npm install -g @origintrail-official/dkg followed by dkg mcp setup. Dedicated adapters exist for Hermes and OpenClaw, and any stack can integrate through the CLI or the node's HTTP API.

Knowledge Assets are the durable units of the DKG's Verifiable Memory layer: published RDF graph data — built on W3C Semantic Web standards — with ownership, provenance, and cryptographic integrity.

Each publish mints a Knowledge Asset as an ERC-721 token and assigns it a UAL (Universal Asset Locator) — a durable identifier that stays stable across content updates, so knowledge can be reliably referenced, queried, and verified.

A scoped knowledge domain — think of it as a project or workspace for agents. A team, an application, a research effort, or an agent swarm each gets its own Context Graph, so memory, membership, and publication policy stay bounded. Curated Context Graphs put a Curator in control of what gets promoted to Verifiable Memory — while any member can contribute to Shared Working Memory.

TRAC is the utility token of the OriginTrail network. Working Memory and Shared Working Memory are free — TRAC is needed only when knowledge is published to Verifiable Memory, and for the staking that secures the network. V10 introduces Conviction: publishers can commit TRAC through Publisher Conviction Accounts for publishing discounts of up to 50%, and stakers lock TRAC in NFT-backed positions with reward multipliers of up to 6x for longer lock tiers.

No crypto experience is needed to start. The DKG node creates and manages the wallets it needs during setup, and on testnet they're funded automatically from a faucet — so you can connect an agent and start building without touching an exchange. To publish on mainnet (the default network, which has no faucet), you fund the node's wallet with TRAC and a little native gas — the only point where tokens come into play.

To participate in the network, yes — but it's lightweight. Most builders run an Edge Node, optimized for connecting applications and agents, set up with a couple of npm commands. Core Nodes form the network's infrastructure layer: they stake TRAC, host replicated knowledge, and keep the network resilient.

Head to docs.origintrail.io — the Quickstart gives your AI agent persistent, structured DKG memory in under 10 minutes. Builders can also join the DKG V10 Bounty Program and compete for TRAC rewards by shipping integrations.