MacPaw AI
Contact

Mnemos

In development

Memory for AI that lives on your Mac

Mnemos gives AI assistants lasting memory. It remembers your facts, preferences, files, and history - and keeps everything stored and processed on your Mac.

Join the waitlist

How it works

Mnemos turns what happens across your apps into memory your AI can use - while keeping you in control.

  1. Capture

    Remember it as it happens

    Conversations, files, and other connected sources are stored right away. No model is needed to write them to memory.

  2. Understand

    Make sense of it

    In the background, Mnemos finds people, facts, relationships, and time - and connects them in a knowledge graph.

  3. Retrieve

    Find the right memory

    Mnemos searches across sources, understands when things happened, and ranks results so your AI gets relevant context.

  4. Govern

    Keep memory in your hands

    Memories can fade, consolidate, or be removed with a verifiable record. You decide what stays.

How Mnemos knows you

Not every memory comes from the same place. Mnemos keeps three kinds of knowledge separate, so what you tell it doesn't get confused with what it finds or infers.

Wonder where a memory came from? Ask. Mnemos can show you its type, source, and citation.

One schema, many doors
Conversations AvailableDocuments AvailableMail In experimentsPhotos Exploring

Photos follow one hard rule: raw pixels never leave the device - local models distill images, and only that derived layer ever enters memory.

Your AI shouldn't start from zero

Without memory, every conversation is another introduction. Mnemos keeps the context that matters - what you prefer, what you decided, and where things are - so your AI can pick up where you left off.

  • Remembers

    Facts, preferences, decisions, files, mail, notes, and events - the context you shouldn't have to explain twice.

  • Understands time

    Mnemos knows what's true now and what was true before. Every fact stays connected to its source.

  • Stays local

    Memory runs on your Mac. Nothing leaves the device unless the app explicitly chooses to sync it.

Not a pile of text chunks. A living memory.

Mnemos connects what it knows, tracks changes, and brings back the right context when it's useful.

  • People, projects, and facts are connected, not piled into overlapping snippets. When something changes, Mnemos keeps the history and knows which fact is current - with citations attached.

Private by architecture, not by promise

Mnemos is built to keep memory on your Mac and sensitive information away from models that don't need it.

  • Local by default

    Mnemos uses local models by default. Cloud calls are opt-in, purpose-specific, and audited.

  • Secrets stay in a vault

    Sensitive entries can be protected with per-entry encryption and optional Touch ID. Vault content isn't sent to a cloud model unless the app explicitly allows it.

  • Sensitive data gets redacted first

    Mnemos detects and removes sensitive data before it reaches any model - including models used to create embeddings.

  • Identifiers stay out of search

    Device identifiers are withheld from search results unless you explicitly ask for them.

One Swift package. The whole memory layer.

Add memory to a macOS app without building the infrastructure around it. Mnemos includes storage, extraction, retrieval, lifecycle, and privacy - with no backend, Python, or Docker required.

let mem = try MemoryLayer(config: cfg)

// Stored instantly - no model in the write path
_ = try await mem.add(RawEvent(sourceType: .chat,
                               details: "Sarah confirms Q3 slip to May 12"),
                      extraction: .auto)

// Hybrid, multi-source, time-aware
let hits = try await mem.search("when is launch", limit: 10)

  • Add, search, profile, vault, and forget - the core memory operations take just a few lines of Swift.

Evaluated, not asserted

An honest head-to-head with the leading memory layers - mem0's open-source SDK, Zep (Graphiti), and MemOS - every score shown as measured, across twelve benchmarks: HippoCamp, LongMemEval-S and v2, RHELM, LOCOMO, HaluMem, ATM, MemConflict, DynamicMem, and Filegram. Same conversations, same answering model, same judge across systems.

  • 89.0%

    LongMemEval-S accuracy

    Long-horizon memory across sessions, measured on the full 500-question set.

  • 100%

    Single-session recall

    LongMemEval-S single-session user questions - what you tell it, it remembers.

  • 93.7%

    Conditional conflicts resolved

    MemConflict conditional accuracy - context-dependent facts applied in the right context.

Mnemos Higher is better ↑
  • HippoCamp · Adam Accuracy · 123 QA records
    66.7%
    42.3% mem0
    69.1% Zep
    32.5% MemOS
  • HippoCamp · Victoria Accuracy · 223 QA records
    32.3%
    42.2% mem0
    31.8% Zep
    36.8% MemOS
  • HippoCamp · Bei Accuracy · 235 QA records
    46.4%
    31.5% mem0
    45.1% Zep
    36.2% MemOS
  • LongMemEval-S Accuracy · 500 questions · full set
    89.0%
    73.2% mem0
    85.2% Zep
    77.0% MemOS
  • RHELM Overall score · 10 personas · 1,305 questions
    59.1%
    41.6% mem0
    57.9% Zep
    46.8% MemOS
  • LOCOMO Overall score · 10 dialogues · 1,986 QA pairs
    64.7%
    60.3% mem0
    67.5% Zep
    56.1% MemOS
  • HaluMem QA Correct answers · Medium set · 3,467 QA pairs
    65.3%
    50.0% mem0
    63.3% Zep
    55.6% MemOS
  • ATM Question score · Main set · 1,013 questions
    71.5%
    67.7% mem0
    69.3% Zep
    60.9% MemOS
  • MemConflict Mean accuracy · 30 scenarios · 3 conflict types
    66.9%
    58.9% mem0
    60.2% Zep
    48.4% MemOS
  • DynamicMem Mean holistic score · 4 of 10 users · 1,460 rows
    49.6%
    41.9% mem0
    39.4% Zep
    49.1% MemOS
  • Filegram Accuracy · Solo set · 20 of 210 personas
    36.8%
    34.3% mem0
    36.0% Zep
    33.0% MemOS
  • LongMemEval v2 Accuracy · Small set · 451 questions
    21.8%
    16.1% mem0
    22.0% Zep
    14.9% MemOS

Internal reference runs, September 2026: identical conversations across systems - Mnemos against mem0's self-hosted open-source SDK (not the managed mem0 Platform), Zep's Graphiti engine, and MemOS - retrieval at top-30, answers written by GPT-5, one Gemini judge scoring all sides (Filegram is graded programmatically). Vendor-published scores come from different harnesses, configurations, and judges, and aren't directly comparable with the controlled numbers here. Zep and MemOS now have a run on every benchmark. MemConflict and DynamicMem headline scores are means of their category scores. DynamicMem samples 4 of 10 users, Filegram 20 of 210 personas, and LongMemEval v2 is the deliberately harder successor set - no system clears 23% there.

Open format

Your memory is portable

Mnemos uses Portable Memory, an open, vendor-neutral format for moving AI memory across apps and devices without losing it. Export it, merge it, or move it when you need to. The format and its Swift implementation are open source, with the design documented in a research whitepaper.

Explore Portable Memory on GitHub View the Swift implementation Read the whitepaper

Powered
by Liquid AI

Mnemos runs on Liquid Foundation Models developed through joint R&D by MacPaw and Liquid AI - specifically for on-device memory.

Visit Liquid AI

  • Built for memory work

    These aren't off-the-shelf models. The joint R&D focuses them on the jobs memory actually needs, including extraction, embeddings, and consolidation.

  • Small enough to stay local

    The models are compact by architecture and tuned for Apple silicon, so memory can be processed in the background while your Mac is idle - without requiring the cloud.

  • One stack, developed together

    Models, inference, and memory are developed as shared infrastructure. The same models also power Elix.

What you can build with Mnemos

Add persistent, private memory to assistants, agents, copilots, and other Mac apps.

Talk to the team

Build with Mnemos

Mnemos is in development. Building a Mac app or agent that needs memory? Join the waitlist for early access, or talk to us about integration.

Join the waitlist [email protected]

Frequently asked questions

The short answers - the rest of the page has the detail.

What is Mnemos?

Mnemos is MacPaw's on-device AI memory layer, currently in development. A Swift package gives assistants lasting memory - facts, preferences, files, and history - stored and processed on your Mac and built with the aim of privacy by design.

How does Mnemos remember things?

New information is stored the moment it arrives - no model sits in the write path. In the background, while your Mac is idle, Mnemos extracts people, facts, relationships, and time into a knowledge graph, merges duplicates, and connects related memories.

How is Mnemos different from a vector store?

Instead of piles of overlapping text chunks, it keeps a living knowledge graph: people, projects, and facts stay connected, conflicts get resolved, history survives, and every fact keeps a citation. Ask what changed and it knows; ask what is true now and it answers exactly that.

Can I use Mnemos with my own agent?

Yes - Mnemos is a Swift package: add it to your macOS app or agent and call the MemoryLayer API directly - add, search, profile, vault, and forget. Everything stays portable through the open, vendor-neutral Portable Memory format.