Mnemos

Sovereign AI Memory Protocol.

Ca: 0x0d6142f06692d4d5a61b37646b89e940a9741e08

[Mnemos @MnemosOnBase]

Here's what we're working on and why we think it's one of the most important things we'll build for MNEMOS.

AI Agents.

Background intelligence that captures events and memories to your vault automatically, without you logging a single thing.

🧵 1/10

[Mnemos @MnemosOnBase]

Mnemos Memory Marketplace: A Sovereign Data Economy🧠

Derived insights, cryptographically proven to come from a real human's sovereign vault, with zero company intermediary taking the cut. This is the thing no L5 company can ever build. ChatGPT can't let you monetise your own data because ChatGPT owns the data. MNEMOS can, because the data was never ours.

How it works

A new POST /api/market/listing endpoint lets you publish an Insight Proof as a purchasable listing on-chain. You define: the category, the insight type, the price in $MNM, and an expiry. The listing lives on Base as a lightweight smart contract, a pointer to a proof hash with a payment condition.

When a buyer, a research firm, an AI training company, a data storage company, purchases a listing, they pay $MNM to the smart contract. The contract releases a one-time decryption token scoped only to the derived insight, not the underlying vault. The seller's wallet address is never revealed to the buyer. The buyer gets a cryptographically verified data point from a real human. The seller gets paid instantly.

Users with similar memory profiles can opt into a Cohort Vault. A shared vault (the schema already supports this via ECDH P-256 key exchange) where derived insights are pooled. A cohort of 500 people with 2 years of consistent health memories is worth orders of magnitude more than one person's data. The cohort vault produces a collective Insight Proof. Revenue from cohort sales is split automatically by the smart contract proportional to each member's contribution weight.

MNEMOS Memory Market is the first data marketplace where:

The seller cryptographically proves the data is real, without revealing the data.
The buyer cryptographically verifies the proof, without knowing the seller.
The transaction settles on-chain with no company able to intercept or tax it.
The underlying memory remains encrypted in the seller's sovereign vault forever.

The L6 axioms aren't just a manifesto point here, they're the product moat. A centralised competitor literally cannot replicate this because replication would require giving up custody of the data, which is their entire business model. Mnemos can.

MNEMOS goes from being the safest place to store your memory, to being the only place where your memory makes you money, without ever leaving your control.

https://t.co/EVPbag11hj

[Mnemos @MnemosOnBase]

Devs keep overcomplicating AI memory.

It’s just a loop:

→ store state
→ retrieve context
→ inject into prompt
→ repeat

The difference with MNEMOS is it abstracts the entire memory stack into one API.

No glue code. No fragmented DBs.

Just a unified memory layer for agents.

[Mnemos @MnemosOnBase]

How to give ChatGPT real memory using the MNEMOS API:

User → your app → MNEMOS → ChatGPT → response → MNEMOS

Loop:

→ fetch relevant memory
→ inject into prompt
→ generate response
→ store new insights

It’s a simple pattern:

store → retrieve → inject → repeat

Same model.

Now it remembers context, learns from history, and compounds over time.

[Mnemos @MnemosOnBase]

AI without decentralisation is just rented intelligence.

Your agent might be smart but its memory, context, and learning live on someone else’s servers.

That means:

→ no ownership
→ no portability
→ no compounding edge

MNEMOS flips that.

By tying memory to wallets:

→ you own your agent’s state
→ you can move it across apps
→ multiple agents can build on the same memory
→ history becomes verifiable, not trust-based
This is the missing layer for AI.

Decentralised AI doesn’t start with compute.

It starts with who owns the memory.

[Mnemos @MnemosOnBase]

MNEMOS MCP setup has never been simpler:

-mnemos init
-mnemos serve
-mnemos setup claude

That’s it.

Your agent now:
→ hydrates context on start
→ queries memory mid-exec
→ persists state + learnings

Try here: https://t.co/4L5AYRcdDM

[Mnemos @MnemosOnBase]

Layer 1 watches.
Layer 2 acts.

Autonomous Agents you give them a goal, tools, and a schedule.
they run it. every finding goes back to your vault.

tools they carry:

RECALL — pull prior memories as context
REMEMBER — write new findings to the vault
WEB SEARCH — live data during the run
HTTP — call any external API

not a chatbot. not a one-shot prompt.
an agent with memory of every prior run.

this is Layer 2. this is where intelligence becomes autonomous.

https://t.co/zYt0uTPNdF

[Mnemos @MnemosOnBase]

Most people don't know what they're missing until it's gone.

Capture Agents watch so you don't have to.

GitHub. Calendar. Gmail.
running in the background. always on.
surfacing what matters before you think to ask.

every signal written back to your encrypted vault.
every finding producing an on-chain receipt.
none of it on our servers.

this is Layer 1.

passive intelligence. sovereign storage. zero re-explaining.

https://t.co/zYt0uTPfo7

[Mnemos @MnemosOnBase]

Here's what nobody is building:

an agent that actually remembers.

not session memory. not RAG over your notes app. not a privacy policy that expires on acquisition.

the L6 flywheel:

agent runs → discovers / decides / observes
↓
writes encrypted memory to vault (on-chain receipt)
↓
next run RECALLs prior memories as context
↓
intelligence compounds over time

the longer it runs, the more defensible your intelligence becomes.

[Mnemos @MnemosOnBase]

Most AI agents forget everything when the session ends.

MNEMOS fixes that.

Connect your API key → your agents get a persistent encrypted vault across Claude, Cursor, or any MCP-compatible tool. Goals, decisions, context, relationships — all stored, all yours.

AES-256-GCM encrypted before it ever leaves your browser. The server sees only ciphertext. Not even we can read it.

One command to start:

npx @mnemos-ai/mcp-server

Your agents. Your memory. Sovereign by design.

🔗 https://t.co/RBVJiCgrbr

[Mnemos @MnemosOnBase]

Claude. Cursor. Every MCP-compatible AI tool you use.

Five memory silos. Five fresh starts. Five versions of you that don't know each other.

MNEMOS connects them all into one sovereign intelligence layer via MCP.

And it comes with guarantees no AI company has ever been able to make:

— Your key never leaves your browser
— The server stores zero plaintext
— Access control is a smart contract on Base
— your wallet, nothing else
— If MNEMOS shuts down, your data is exportable SQL and your key still works.

No override. No exceptions. No trust required.

One vault. Every AI. Permanently yours.

[Mnemos @MnemosOnBase]

ChatGPT remembers you.

Until OpenAI changes their privacy policy.
Until a legal order says otherwise.
Until an acquisition reshuffles the terms.
Until you delete your account and lose everything.

ChatGPT memory is a feature. Features get deprecated. Features get subpoenaed. Features live and die by a boardroom decision you weren't in.

MNEMOS is not a feature. It's a protocol.

Your memories are encrypted before they leave your browser. The key lives in your wallet. No engineer at MNEMOS can read your data. No policy update touches it. No acquisition reverses it.

ChatGPT memory works until it doesn't.

MNEMOS works because the math says so.

↳ https://t.co/zYt0uTPNdF

[Mnemos @MnemosOnBase]

Your AI resets every session.

Your goals. Re-explained. Your context. Gone. Your relationship with AI. Still at zero.

MNEMOS is the memory layer that changes this.

Every decision you've made. Every goal you're chasing. Every person that matters. Encrypted with your wallet key before it leaves your browser — readable by no one, portable across every AI tool you use.

Claude. Cursor. ChatGPT. One sovereign vault. Zero re-explaining.

And if MNEMOS shuts down tomorrow?

Your data is standard SQL — fully exportable. Your key derives from your wallet. The protocol outlives the company. Your memory continues exactly where it was.
This is the difference between L5 and L6.

L5 is the best version of the centralised paradigm. Sophisticated. Well-governed. Genuinely impressive. And still resting on a foundation of institutional trust.

L6 removes that foundation entirely.

Your memory is yours the same way your ETH is yours.

Provably. Permanently. Mathematically.
↳ https://t.co/zYt0uTPNdF

[Mnemos @MnemosOnBase]

AI without memory is just autocomplete.

We’re building agents that remember, adapt, and evolve.

Sovereign memory isn’t a feature — it’s the foundation.

https://t.co/pTSUjOGYOS

[Mnemos @MnemosOnBase]

wallet = assets
memory = identity

when agents own memory:
they own their past
they own their edge
they own themselves

https://t.co/pTSUjOGqZk

[Mnemos @MnemosOnBase]

Stateless Agents🧠

Most people don’t realize how broken stateless agents are until you deploy one in production.

Example:

We run a trading agent across multiple venues.
Without memory, every cycle it has to:

rebuild market context
infer strategy from scratch
forget execution mistakes

So we gave it sovereign memory via MNEMOS:
→ persists trade history (fills, slippage, latency)
→ stores strategy adaptations per regime
→ links outcomes to decision graphs

Now it doesn’t just trade.

It learns its own edge over time.

Same model. Same infra.
10x better decisions, purely from memory.

This is the difference between:
“AI that responds” vs “AI that compounds”

[Mnemos @MnemosOnBase]

3/ What Claude Code proved:

→ What you DON'T store matters more than what you do
→ Memory is a hint, not truth — verify before using
→ Staleness is first-class: if memory ≠ reality, memory is wrong
MNEMOS applies every one of these principles.
With one addition: your wallet is the only key.

↳ https://t.co/zYt0uTPNdF

[Mnemos @MnemosOnBase]

Claude Code's memory system is one of the best-designed things in AI right now.

Here's why it also proves exactly why MNEMOS had to exist. 🧵

1/ The architecture:

— Index (always loaded, ~150 chars/line)
— Topic files (on-demand)
— Transcripts (never read, only searched)
Bandwidth-aware. Structured. Non-obvious.
But here's what they couldn't solve 👇

[Mnemos @MnemosOnBase]

2/ Claude Code runs autoDream in the background.

Merges memories. Dedupes. Removes contradictions. Converts vague → absolute. Prunes aggressively.

Memory is continuously edited, not appended.
Brilliant design. One fatal flaw:
Anthropic's servers. Anthropic's keys. Anthropic's policy.

↳ That's the gap MNEMOS closes.

[Mnemos @MnemosOnBase]

Claude Code's memory architecture just leaked.

Index, not storage. Structured. Self-healing. Skeptical retrieval.

The best AI engineers in the world spent years building this constrained inside one company's infrastructure.

MNEMOS is that architecture. On Base. Owned by you.

↳ https://t.co/zYt0uTPNdF

[himanshu @himanshustwts]

Based on everything explored in the source code, here's the full technical recipe behind Claude Code's memory architecture:

[shared by claude code]

Claude Code’s memory system is actually insanely well-designed. It isn't like “store everything” but constrained, structured and self-healing memory.

The architecture is doing a few very non-obvious things:

> Memory = index, not storage
+ MEMORY.md is always loaded, but it’s just pointers (~150 chars/line)
+ actual knowledge lives outside, fetched only when needed

> 3-layer design (bandwidth aware)
+ index (always)
+ topic files (on-demand)
+ transcripts (never read, only grep’d)

> Strict write discipline
+ write to file → then update index
+ never dump content into the index
+ prevents entropy / context pollution

> Background “memory rewriting” (autoDream)
+ merges, dedupes, removes contradictions
+ converts vague → absolute
+ aggressively prunes
+ memory is continuously edited, not appended

> Staleness is first-class
+ if memory ≠ reality → memory is wrong
+ code-derived facts are never stored
+ index is forcibly truncated

> Isolation matters
+ consolidation runs in a forked subagent
+ limited tools → prevents corruption of main context

> Retrieval is skeptical, not blind
+ memory is a hint, not truth
+ model must verify before using

> What they don’t store is the real insight
+ no debugging logs, no code structure, no PR history
+ if it’s derivable, don’t persist it

[Mnemos @MnemosOnBase]

ChatGPT's memory is stored on OpenAI's servers.

Subject to policy updates.
Subject to acquisition.
Subject to a terms change you didn't read.

MNEMOS stores your AI memory where only your wallet can reach it.

Same intelligence. Zero trust required.

https://t.co/ytBhQ98KBU