Memzi Protocol
The Decentralized Memory Protocol for Lifelong AI Agents
Abstract
In the agent economy of 2026, AI systems have achieved autonomous planning, multi-step execution, and real-time tool use — yet they remain fundamentally amnesiac. Every session reset erases hard-won context, preferences, and learned behaviors. Centralized memory services offer temporary relief but create vendor lock-in, surveillance exposure, and single points of failure. Pure on-chain approaches sacrifice latency and usability.
Memzi is a universal, user-sovereign memory protocol that gives every AI agent persistent, portable recall while placing full ownership in the hands of the user. Built as a local-first hybrid architecture, Memzi combines sub-5ms on-device retrieval with permanent, censorship-resistant storage on IPFS and Arweave — syncing only encrypted ciphertext, anchored by wallet-derived cryptographic proofs.
The result: agents that evolve into true digital companions — portable across frameworks, verifiable on-chain, and economically composable — without ever compromising sovereignty or speed. Memzi is not a vector store. It is the missing infrastructure primitive for the agent economy: a protocol that transforms memory into an ownable, shareable, and intrinsically valuable asset class.
Problem Statement
Current AI agent infrastructure suffers from three structural failures that prevent the emergence of truly persistent, user-aligned intelligence.
Session Amnesia
Context windows expire. Agents restart from zero every session. Long-term learning, user preferences, and accumulated expertise evaporate at each boundary. Multi-session workflows require users to manually reconstruct context — a tax on intelligence that scales linearly with agent utility.
Centralized Fragility
Existing memory layers (Mem0, Zep, Letta) store agent memories in third-party clouds. This creates vendor lock-in by design: migrating an agent's learned context between providers is either impossible or prohibitively complex. Users face surveillance risk, single points of failure, and no true data portability.
The Sovereignty Paradox
Early web3 memory experiments provide on-chain persistence but sacrifice usability. Network-first storage introduces latency that breaks real-time agent loops. Public-by-default architectures expose sensitive memories. Users are forced to choose between sovereignty and performance — a false binary Memzi eliminates.
Users want agents that remember them forever, across every device and platform. Developers want a single SDK call that works across frameworks. Enterprises need verifiable provenance and compliance. No existing solution delivers all three simultaneously.
Protocol Architecture
Memzi implements a three-layer hybrid architecture engineered to resolve the trilemma of speed, sovereignty, and persistence. Each layer is independently useful; together, they form a complete memory stack.
Every interaction is ingested, embedded, and stored on-device first using a hybrid vector + graph database (LanceDB / DuckDB). Client-side AES-256 encryption ensures plaintext never leaves user control. Retrieval latency is sub-5ms.
User-initiated or policy-driven replication to IPFS (via Helia) and Arweave occurs only after encryption. Wallet-derived keys and optional soulbound NFTs provide cryptographic ownership proofs. This layer guarantees permanence.
A standardized memory schema enables seamless import/export across LangGraph, CrewAI, Letta, AutoGen, on-chain agent runtimes, and future frameworks. Granular access controls and ZK proofs allow selective memory sharing.
Developer Interface
Memzi exposes a minimal, framework-agnostic SDK. Two primitives — remember and recall — abstract the entire memory lifecycle. The protocol handles encryption, embedding, deduplication, importance scoring, and sync automatically.
import { Memzi } from '@memzi/sdk';
// Initialize with wallet or passkey auth
const memzi = new Memzi({
auth: 'wallet', // or 'passkey' for web2 fallback
sync: 'arweave', // 'ipfs' | 'arweave' | 'local-only'
encrypt: true, // AES-256, wallet-derived key
});
// Store a memory with semantic metadata
await memzi.remember({
content: 'User prefers concise responses under 200 words',
tags: ['preference', 'style'],
importance: 'high',
ttl: null, // null = permanent
});
// Retrieve context-optimized memories with provenance
const context = await memzi.recall({
query: 'How does this user like to communicate?',
topK: 5,
filters: { tags: ['preference'] },
});
// Each memory includes cryptographic provenance
context.memories[0].proof // → { hash, wallet, timestamp, chain }Framework adapters for LangChain, LangGraph, CrewAI, AutoGen, and Letta wrap the core SDK with idiomatic integrations. A single memzi.recall() call returns context-ranked results with full provenance metadata.
Technical Specification
Storage Engine
Local layer uses LanceDB for vector similarity (1536-dim embeddings, cosine distance) paired with a lightweight property graph for relational traversal. Memories are chunked, deduplicated via MinHash, and indexed with HNSW for sub-5ms ANN retrieval on datasets up to 10M vectors per device.
Encryption & Key Management
AES-256-GCM with wallet-derived keys (BIP-44 path derivation). Optional integration with Lit Protocol for programmable key management and threshold decryption. Passkey-based fallback for web2 users via WebAuthn. Key rotation supported via re-encryption envelopes without re-uploading ciphertext.
Retrieval Pipeline
Hybrid retrieval combines dense vector search with graph-based traversal and BM25 sparse matching. Memories carry importance scores (decayed over time, boosted by access frequency). Auto-summarization compresses old memories into distilled knowledge nodes.
Authentication
Primary: WalletConnect + Sign-In With Ethereum (SIWE / EIP-4361). Secondary: passkey-based auth via WebAuthn for non-crypto-native users. All memory operations are signed by the authenticated identity — providing an immutable audit trail.
Sync Protocol
Encrypted memory diffs are synced via Helia (IPFS) for availability or Arweave for permanent archival. CRDTs (Automerge) handle multi-device conflict resolution. Sync is eventually consistent with configurable policies: real-time, batched, or manual.
Competitive Analysis
The agent memory landscape fragments into centralized developer tools and decentralized experiments. Neither camp fully addresses the trilemma of speed, sovereignty, and usability.
| Capability | Mem0 | Zep | Membase | Ori | Memzi |
|---|---|---|---|---|---|
| Local-First Storage | |||||
| E2E Encryption Default | |||||
| Wallet-Owned Identity | |||||
| Sub-5ms Retrieval | |||||
| Permanent Storage | |||||
| Framework Agnostic SDK | |||||
| ZK-Proof Sharing | |||||
| Consumer UX / Dashboard |
Token Economics
The $MEMZI token aligns incentives across the protocol's three constituencies: users who generate memories, developers who build integrations, and node operators who provide decentralized infrastructure.
Storage Staking: Users stake $MEMZI to reserve persistent Arweave storage quotas. Staked tokens are not consumed — they represent capacity commitments redeemable upon unstake.
Access Governance: Token-gated access to premium retrieval features and protocol governance proposals.
Memory Marketplace: Opt-in marketplace where anonymized, ZK-verified memory subsets can be shared or sold. Creators receive $MEMZI; buyers pay $MEMZI. Protocol takes 2.5% directed to DAO treasury.
Total Supply: 1,000,000,000 $MEMZI (fixed, non-inflationary). Initial Circulating: ~8% at TGE. Deflationary pressure via marketplace fee burns (50% of protocol fees burned, 50% to DAO).
Roadmap
Foundation
Open-source SDK launch (TypeScript + Python). Local-only mode with LanceDB. LangChain and CrewAI adapters. Passkey + WalletConnect auth. Developer preview with 500 builders.
Decentralized Sync
Encrypted IPFS and Arweave sync. CRDT-based multi-device resolution. Agent Soul Dashboard v1. Soulbound NFT ownership proofs. Testnet token launch.
Interoperability & Marketplace
Open memory schema specification. ZK-proof selective sharing. Memory marketplace beta. AutoGen, Letta, and on-chain runtime adapters. Enterprise API with audit trails. Mainnet token launch.
Autonomous Memory Economy
Agent-to-agent memory exchange protocol. Federated retrieval across user-sovereign nodes. DAO-governed protocol upgrades. Multi-modal memory (vision, audio, spatial). Mobile-native SDKs.
Governance & DAO
Memzi transitions to full DAO governance following mainnet launch. The governance framework is designed to prevent plutocratic capture while ensuring protocol evolution remains responsive to the community that creates and consumes memories.
Proposal Authority: Any address holding ≥10,000 $MEMZI (0.001% of supply) can submit governance proposals. Proposals require a 72-hour discussion period followed by a 5-day voting window.
Voting Power: Quadratic voting weighted by both token holdings and protocol usage (memory volume, SDK integrations). Active participants have outsized voice relative to passive speculators.
Governance Scope: Protocol fee parameters, marketplace policies, treasury allocation, schema specification upgrades, and privacy policy changes. Core encryption and ownership primitives are immutable by design — no governance action can weaken user sovereignty.
Risks & Mitigations
Key Loss:
Wallet-derived keys create a single point of failure. Mitigation: social recovery via Lit Protocol threshold schemes, optional passkey backup, and encrypted key escrow to user-designated guardians.
Adoption Chicken-and-Egg:
The memory marketplace requires critical mass. Mitigation: Phase 1 delivers standalone value as a local-only SDK (no token, no marketplace required). The marketplace is additive, not prerequisite.
Regulatory Uncertainty:
Token classification varies by jurisdiction. Mitigation: $MEMZI is designed as a utility token with clear functional use. No yield, no revenue sharing, no equity-like properties. Legal counsel across US, EU, and APAC jurisdictions.
Arweave/IPFS Dependency:
Local-first architecture means the protocol remains fully functional without decentralized sync. Cold storage is optional durability insurance, not a runtime dependency.
Privacy Under Adversarial Conditions:
Encrypted ciphertext on public networks may be vulnerable to future quantum attacks. Mitigation: key rotation support, migration path to post-quantum encryption (Kyber/CRYSTALS), and architecture that allows re-encryption without re-upload.
Conclusion
Agents are not tools — they are becoming extensions of human intent. For them to reach their full potential, they must possess memory that is persistent, portable, private, and provably owned by the user.
By combining local-first engineering with decentralized permanence and world-class product design, Memzi creates the foundation for lifelong, sovereign AI agents that evolve with their users across every platform and future.
The agent economy needs infrastructure that compounds value over time rather than rents it monthly. Memzi is that infrastructure.
Memory is the new primitive.
Own it. Verify it. Take it everywhere.
Build the agent economy on Memzi.
References
[1] Kleppmann, M. et al. "Local-First Software: You Own Your Data, in Spite of the Cloud." Onward! 2019.
[2] EIP-4361: Sign-In With Ethereum. Ethereum Foundation, 2021.
[3] Williams, S. "Arweave: A Protocol for Economically Sustainable Information Permanence." Arweave Yellow Paper, 2020.
[4] Protocol Labs. "IPFS — Content Addressed, Versioned, P2P File System." 2015.
[5] Lit Protocol. "Programmable Key Management for Decentralized Applications." 2023.
[6] Malkov, Y. & Yashunin, D. "Efficient and Robust Approximate Nearest Neighbor Using HNSW." IEEE TPAMI, 2020.
[7] Automerge: A Library of Data Structures for Building Collaborative Applications. Ink & Switch, 2022.
[8] NIST Post-Quantum Cryptography Standardization: CRYSTALS-Kyber. 2024.
[9] Buterin, V. "Soulbound Tokens: Building Blocks for a Decentralized Society." 2022.