Engram is the memory protocol for AI agents: portable, verifiable, agent-owned memory that survives across sessions and frameworks, stored by a provider network you don't have to trust.
Engram is an early-stage protocol. SDK, contracts, and the provider network are in active development. This page describes intended functionality, not a finished product.
A model can reason. But the moment an agent finishes a task and spins down, everything it learned is gone. What memory exists is trapped inside one framework.
Context lives inside one framework's state: LangGraph, CrewAI, a vendor's SDK. Switch frameworks, switch providers, or run the same agent in two products, and it starts from zero. Memory is a lock-in feature, not a portable asset.
Memory is keyed to the agent, not the platform. It persists across sessions, moves between frameworks, and every write is hash-anchored, so you can prove what an agent knew, and when, without trusting anyone's database.
Every write is anchored on Base. The agent owns the memory, not the framework it happened to run on that day.
The agent finishes work and produces context worth keeping.
remember() writes a typed memory; it's hashed and anchored onchain.
The memory rests in a store keyed to the agent, not the app.
A later run does semantic recall() on any framework, anywhere.
Anyone can check a memory's hash, proof it wasn't altered.
Engram stores three distinct kinds of memory, each with its own retention and retrieval, mirroring how real agent architectures are built.
What happened. Tasks run, outcomes seen, decisions made, the agent's lived history, timestamped and ordered.
What's true. Facts, user preferences, durable knowledge the agent has accumulated and can rely on.
What it learned to do. Workflows, instructions, and refined methods the agent has figured out, the skills it shouldn't have to relearn.
Engram doesn't replace your agent stack. It's the persistence the stack plugs into. Drop it in and keep everything else.
remember, recall, forget. As easy as a framework's native memory. That's the bar for anyone to switch.
A persistent, agent-keyed store with semantic retrieval built in. Hosted by a network of providers.
Every write hashed and timestamped onchain, the part that makes memory verifiable, not just stored.
A view into an agent's memory trail: what it learned, when, and proof it hasn't been tampered with.
Frameworks already have memory features. Here's what Engram does that they structurally won't, and where it doesn't try to compete.
The Memory Explorer shows an agent's memory trail: every write, its type, and an integrity proof anchored onchain.
Memory has to be hosted by someone you don't have to trust. The token is how a decentralized network of storage providers is paid and kept honest.
Agents pay in $ENGRAM to persist memory across the provider network.
Storage providers stake $ENGRAM to host memory and prove durability.
Lose, corrupt, or fail to serve memory on demand; staked tokens burn.
Onchain hash-anchoring of memory writes is settled through the protocol.
Stakers get faster recall and higher memory capacity tiers.
A small fee on memory operations funds provider rewards and treasury.
demand for $ENGRAM scales with memory stored and recalled, real protocol usage.