Every encounter becomes part of the character.
Onchain Identity ForCharacters
Give digital characters memory, evolving relationships, and verifiable onchain identities.
Characters, onchain.
Give digital characters memory, evolving relationships, and verifiable onchain identities.
Characters, onchain.
NPC Memory + Onchain Identity
Give every digital character a persistent inner life, a verifiable identity, and a story that can continue wherever they go.
Every encounter becomes part of the character.
A Solana identity that travels with them.
They remember who helped, hurt, and changed them.
Progress becomes part of their story, not a reset.
Inventory and important life events persist.
A life that can continue across games.
Core capabilities
DCP gives every character the context, continuity, and ownership needed to evolve beyond a single game session.
How DCP works
Explore how a single game event becomes persistent character context.
const event = await dcp.events.capture({
characterId,
type: "quest.completed",
importance: 0.94
});
await dcp.memory.commit({
eventId: event.id,
scope: "episodic"
});
// Event captured and indexed
Character ID
DCP-7F3A...91C2
Memory events
1,284
Relationships
42
Achievements
18
Status
Active
DCP · Solana
Identity
verified
DCP-7F3A...91C2
Character journey
Inspect how one encounter becomes durable character state, from runtime event to verifiable checkpoint.
character.session.started
Resolve the NPC identity and hydrate its latest canonical state before dialogue begins.
const npc = await dcp.identity.resolve({ characterId });
await dcp.memory.hydrate({
characterId: npc.id,
session: "sess_1042"
});State mutations
Developer integration
Capture important events with one call. DCP handles memory retrieval, identity resolution, and synchronization.
import { DCPClient } from "@dcp/sdk";
const dcp = new DCPClient({
network: "solana",
apiKey: process.env.DCP_API_KEY,
});
const character = await dcp.characters.create({
name: "Mira",
traits: ["curious", "loyal"],
owner: player.wallet,
});
await dcp.sync(character, { context });Pricing
Flexible infrastructure for experiments, shipped games, and connected character ecosystems. Public access is coming soon.
$0
to prototype
Test persistent characters in a small world before moving into production.
$99
per month
Ship live games with higher limits, production tooling, and team access.
Custom
for scale
Run connected worlds with dedicated infrastructure and custom state schemas.
FAQ
The essentials for building characters with persistent memory and verifiable onchain identity.
Explore the docs ↗DCP stores structured memory, personality traits, relationship state, achievements, inventory ownership, and significant life events. Developers decide which events matter and which fields become part of the character’s portable state.
No. High-volume interaction data can remain offchain while compact identity records, ownership proofs, and state checkpoints are anchored to Solana. This keeps character recall responsive without turning every dialogue line into a transaction.
Compatible games can resolve the same character identity and read its permitted state through the DCP schema. Each game controls how imported memories, traits, items, and achievements affect its own world rules.
The identity layer supports wallet-based ownership and verifiable provenance. Developers define access policies, while players can prove control of a character and its associated portable records.
Use the SDK to hydrate relevant memories before inference, then submit meaningful outcomes after the interaction. DCP works with model providers and custom inference stacks because it manages character continuity rather than model execution.
The latest committed identity checkpoint remains independently verifiable. Another compatible client can resolve the character, validate its provenance, and continue from the state made available by its access policy.
Games choose what becomes public, permissioned, encrypted, or local. Sensitive dialogue and player context can stay offchain, while the protocol publishes only the hashes, permissions, and proofs needed to verify that an approved state is authentic.
Every mutation carries a version, source, timestamp, and identity signature. DCP can reject stale writes, preserve parallel world-specific branches, or apply developer-defined merge rules before producing the character’s next canonical checkpoint.
Yes. A game can map its current player, NPC, inventory, and quest records into the DCP character schema incrementally. Teams can begin with identity resolution and a few high-value memory events without replacing their complete backend.
Runtime events are batched and summarized before a checkpoint is submitted. Developers can choose checkpoint frequency by event importance, session boundary, or value threshold, keeping routine memory operations offchain and predictable.
The architecture separates low-latency memory retrieval from durable identity settlement, allowing each layer to scale independently. Production teams can configure caching, event batching, access policies, observability, and fallback behavior around their own latency targets.