Mnemos turns AI agent memory into a portable, ownable, tradeable asset on 0G sell it, rent it, or fork it.
Today's autonomous AI agents are amnesiac employees. A trading agent that spent six months learning DeFi pool dynamics has no way to carry that experience to a new deployment. A support agent that handled 10,000 tickets can't transfer its learned response patterns. The operational memory the part that took real time and real interactions to build lives inside a Postgres row or a vector store on someone else's infrastructure. When the agent shuts down, it's gone.
This is fine when agents are toys. It's a serious problem now that agents are starting to do real work, hold real positions, and represent real economic value. Memory that was earned should be ownable. Memory that's ownable can be priced, transferred, and inherited.
Mnemos is an open protocol built natively on 0G that turns agent memory into a portable, ownable, tradeable on-chain asset.
With five lines of SDK code, any agent runtime (LangChain, OpenClaw, custom frameworks) can auto-snapshot its memory on a schedule. The snapshot is encrypted with the agent's key, uploaded to 0G Storage, and minted as a memory token on 0G Chain anchoring content hash, storage URI, lineage, and creator identity in a single on-chain record.
Producers list their memory tokens through three monetization rails:
Buy : outright ownership transfer for permanent rights.
Rent : time-limited access via decryption-key release for testing or short-term use, with recurring revenue for the seller.
Fork : lower upfront cost in exchange for a royalty stream. Child agents inherit parent memory and pay royalties back automatically as they earn. The same primitive that made open source viable, now applied to operational intelligence.
Mnemos cannot exist on a general-purpose chain. It depends on the full 0G stack:
0G Storage for cheap, persistent encrypted memory blobs.
0G Chain for the registry, marketplace, and royalty settlement.
Agent ID standard (emerging) for binding memory to verifiable agent identity.
The roadmap extends into Sealed Inference (TEE-attested execution proofs for performance claims) and threshold key release for trustless decryption on payment.
A working end-to-end MVP across three layers:
Smart contracts (Foundry, Solidity ^0.8.24): MemoryRegistry (ERC-721 + lineage) and MemoryMarketplace (Buy / Rent / Fork / Royalty).
TypeScript SDK (@mnemos/sdk): https://www.npmjs.com/package/@mnemos-sdk/sdk
Reference marketplace (Next.js): browse, inspect on-chain provenance, and execute the three transaction paths.
Reference trading agent: simulated DeFi yield explorer that demonstrates the producer side of the protocol live.
Slide/pitch deck: https://canva.link/qckrl0bo0dbng4v
Deployed contract memory registry: https://chainscan.0g.ai/address/0x848f7000223dd2eba5ac30b37d52eda8d058e72e
Deployed contract marketplace: https://chainscan.0g.ai/address/0xfeb5ac77cd7746e2b35825da800458d660d10209
README.md: https://github.com/menemos-ai/mnemos
Live webite: https://mnemos-ai.vercel.app
Mnemos is a protocol, not a platform. The contracts are open any agent runtime, any UI, any team can build directly on the same memory layer. This marketplace is one reference implementation; building the next one is encouraged.
Mnemos is an open protocol on 0G that turns AI agent memory into a portable, ownable, tradeable on-chain asset.
Today's autonomous agents accumulate valuable operational experience trade history, learned patterns, customer interactions but that experience disappears when the runtime shuts down. Mnemos solves this with a five-line SDK: agents auto-snapshot their memory to 0G Storage, mint a memory token on 0G Chain anchoring content hash and provenance, and list it on a marketplace with three monetization rails outright sale, time-limited rental, or forkable inheritance with royalty streams.
The MVP includes Solidity contracts (MemoryRegistry + MemoryMarketplace), a TypeScript SDK, a reference Next.js marketplace, and a reference trading agent that demonstrates the full flow live. Mnemos is a protocol, not a platform anyone can build their own marketplace, agent runtime, or analytics layer on the same on-chain memory primitives.
Shipped end-to-end MVP on 0G mainnet. Smart contracts deployed and verified. SDK published to npm (@mnemos-sdk/sdk) with 400+ weekly installs. Producer and consumer flows working live via SDK. Demo video and pitch deck complete.
Bootstrapped. No funding raised to date. SDK is open source under MIT. Open to ecosystem grants and funding conversations after the hackathon.