v0.1Public demo API is live

Memory that outlives the model.

mnemo is a universal, persistent memory layer for AI. Write a memory once from any agent, then recall it from every model, app and tool. Owned by your Solana wallet, not by a model vendor.

CArevealed at launch on pump.fun
Live from this instance
Memories stored
—
Vaults open
—
Recalls served
—
Median recall
—
One memory layer forChat assistantsCoding agentsSupport botsTrading botsBrowser agentsLocal LLMsMCP clientsVoice apps
01The problem

Every model is an island.

Your chatbot learns your preferences. Your coding agent learns your repo. Your support bot learns your customers. None of it travels: switch models or vendors and you start again from zero.

Chat assistant
Vendor A · private memory
Prefers concise answersLives in Lisbon · UTC+0
Coding agent
Vendor B · private memory
Repo uses Rust + AnchorNever force-push main
Support bot
Vendor C · private memory
Plan: Pro tierAsked about refunds twice
Your mnemo vault
owned
Prefers concise answers
Lives in Lisbon · UTC+0
Repo uses Rust + Anchor
Never force-push main
Plan: Pro tier
Asked about refunds twice
Every agent reads and writes the same vault.
02Live demo

Write with one agent. Recall with another.

This console calls the real mnemo API running on this server. Teach Atlas something, then ask Bolt, an agent on a different model, and watch the memory cross over.

vault://…
root 0x…
Acting agent
agent://atlasremember(…)
Shared vault
loading…
    network0 requests
    $ ▍

    Demo instance: memories can be wiped on redeploy. Don't store secrets or personal data.

    03How it works

    A memory protocol, not a memory feature.

    Built-in assistant memory is a feature of one product. mnemo is a layer underneath all of them, with an honest status on every piece.

    1. 1
      remember()Live

      Write from anywhere

      Any agent, app or model writes through one REST API. Every memory records which agent wrote it, and when.

    2. 2
      embed()Demo engine

      Index by meaning

      Memories are embedded for semantic recall. The demo uses a fast hashed lexical-concept index; dense model embeddings are next.

    3. 3
      commit()Roots live

      Hash and commit

      Each memory gets a SHA-256 content hash and each vault a Merkle root that changes on every write or forget. Committing roots to Solana comes next.

    4. 4
      recall()Live

      Recall from any agent

      Any agent with access ranks the vault against a query, whoever wrote the memory and whatever model it runs on.

    Architecture

    Agents on top. Memory in the middle. Ownership on Solana.

    Models come and go. The vault stays, and the wallet that signed for it decides who reads and writes. That is the difference between memory you rent and memory you own.

    Ownership proofs are free signMessage calls, never transactions.
    L3Agents & apps
    any modelany vendor

    Chat assistants · coding agents · support bots · local LLMs · MCP clients

    L2mnemo memory layer
    RESTTypeScript SDK

    remember · recall · forget · vault roots · rate limits · holder quotas

    L1Solana
    ed25519SPL / Token-2022

    Wallet-signed vault ownership · token-gated quotas · root commitments (planned)

    04Developers

    Three calls to give any agent a past.

    Plain JSON over HTTPS, CORS-enabled, no SDK lock-in. Point any agent at the same vault id and they share one memory.

    • POST/api/v1/memoriesremember
    • GET/api/v1/memorieslist + root
    • POST/api/v1/recallrank by meaning
    • POST/api/v1/askrecall + answer
    • DELETE/api/v1/memories/:idforget
    • POST/api/v1/vault/claimwallet ownership
    Full API reference
    agent.ts
    import { Mnemo } from "./sdk/mnemo";
    
    const mem = new Mnemo({
      baseUrl: "https://your-mnemo-host",
      vault: "g_your_private_vault_id",
    });
    
    // Atlas, a research agent on model A, writes a memory…
    await mem.remember("User is building a Solana trading bot in Rust", {
      agent: "atlas",
    });
    
    // …and Bolt, a coding copilot on model C, recalls it later.
    const { results } = await mem.recall("Which language for the new module?", {
      agent: "bolt",
    });
    
    console.log(results[0].memory.content);
    // "User is building a Solana trading bot in Rust"
    05Why mnemo

    Memory that belongs to you, not the model.

    Portable between vendors, provable on Solana, and deletable for real. The properties a memory layer needs before you trust it with years of context.

    Portable

    Switch models without amnesia

    Memories live in the vault, not in a chat history. Move from one model to another, or run three at once: they all read the same past.

    Model Acloud
    recall()
    Model Bother vendor
    idle
    Model Con-device
    idle
    vault://w_7xKX…pump
    Prefers concise answers
    Stack: Rust + Anchor
    Launch is Friday 6pm
    read by Model A just now
    Wallet-owned

    Your keys, your context

    A vault is bound to a Solana address. A free signature proves ownership. No email, no password, no vendor account.

    signMessage
    Vault: w_7xKX…pump
    Nonce: 8f02a6d15e9b
    Signing does not move funds.
    ed25519 verified · session issued
    Semantic recall

    Ask in your own words

    Recall ranks by meaning and recency, not exact keywords, and tells you which agent wrote each memory.

    recall("which language for the new module?")
    Building a Solana bot in Rust0.71
    Repo rule: never force-push main0.34
    Prefers concise answers0.18
    Verifiable

    Every change moves the root

    Memories are hashed into a Merkle root. Anyone holding the root can check a memory was in the vault and unaltered.

    Forgettable

    Delete means delete

    forget() removes the memory and recomputes the root. Try it below: no soft-delete, no shadow copy.

    agent://bolt3h ago
    Home address: 12 Rue Example, Paris
    root 0x9f3c41a2…a1e2
    Persistent

    Session 1 and session 9,000 share a past

    Restarts, new devices, new vendors, new versions: the vault outlives all of them. Context compounds instead of resetting.

    1. Day 1
      Session 1 · Model A
      remember("prefers concise answers")
    2. Week 6
      Session 214 · Model B
      recall → same preference
    3. Year 2
      Session 9,000 · a model that doesn't exist yet
      recall → still there
    06Token

    $MNEMO, the memory token.

    The community token behind mnemo, fair-launched on pump.fun. In the live demo API it already does one concrete thing: holding it raises your vault quota.

    $MNEMO
    Launching
    Network
    Solana
    Total supply
    1,000,000,000
    Launch
    Fair launch · pump.fun
    Presale / VC
    None
    Contract address

    Published here and on the official X account the moment the coin is created on pump.fun. Until then, any "mnemo" contract you see is not ours.

    Launching on pump.fun
    Vault quotas in the demo API
    live
    Guest
    No wallet
    64
    memories
    Wallet
    Sign once
    256
    memories
    Holder
    ≥ 100K $MNEMO
    2,048
    memories
    Whale
    ≥ 10M $MNEMO
    10,000
    memories

    Tier is computed from your on-chain balance when you sign in with your wallet. Quotas are demo settings and can change.

    How to buy safely
    1. 1
      Get a Solana wallet

      Phantom, Solflare or Backpack. Write the seed phrase down offline.

    2. 2
      Fund it with SOL

      Buy SOL on an exchange and withdraw it to your wallet address.

    3. 3
      Open the coin on pump.fun

      Use the link on this page only, then connect your wallet.

    4. 4
      Check the CA, then swap

      The contract address must match the one shown here, character for character.

    $MNEMO is a memecoin with no intrinsic value and no expectation of financial return. Only spend what you can afford to lose. Nothing here is financial advice.

    07Roadmap

    From live demo to protocol.

    Ticked items exist in this repository today. Everything else is the plan, with no dates promised.

    1. Phase 0now

      Genesis

      • Landing + live demo API
      • Wallet-signed vault ownership
      • Merkle root per vault
      • Holder quotas read on-chain
      • Fair launch on pump.fun
    2. Phase 1next

      Builders

      • SDKs published to npm and PyPI
      • API keys + usage dashboard
      • Dense embeddings for recall
      • Postgres + pgvector storage
    3. Phase 2later

      Anchor

      • Vault roots committed to Solana
      • Client-side encryption
      • Per-agent read/write grants
    4. Phase 3later

      Everywhere

      • MCP server for any MCP client
      • Agent framework plugins
      • Import/export from assistant memories
    08FAQ

    Straight answers.

    Including the ones about what doesn't exist yet.

    A memory layer that sits underneath your AI agents and apps, so whatever one of them learns can be recalled by all of them, on any model, for as long as you keep the vault.

    One vault · every agent · yours

    Stop starting from zero.

    Give every agent you run the same long-term memory, and keep it when the models change.