moorcheh-ai/memanto

Memory that AI Agents Love!

What it solves

Memanto is a "Memory Agent" designed to manage the long-term memory of a fleet of AI agents. While standard vector stores simply persist data, Memanto actively curates it—resolving contradictions, merging duplicates, and expiring stale information—to prevent the "noise" that typically accumulates in long-term agentic memory.

How it works

Instead of acting as a simple API or library, Memanto runs as a companion agent that observes interaction streams and performs six core behaviors:

  • Extraction: Pulls durable knowledge (decisions, preferences, facts) from ephemeral chat logs.
  • Consolidation: Merges fragments and duplicates into a canonical estate.
  • Reconciliation: Supersedes old knowledge with new information when contradictions occur.
  • Forgetting: Executes expiry policies to remove stale data based on user-defined rules.
  • Briefing: Provides agents with a minimal, relevant slice of memory before they act.
  • Portability: Uses the Open Knowledge Format (OKF), which stores memory as portable, human-readable Markdown files.

Who it’s for

Developers building fleets of AI agents across different frameworks (e.g., Claude Code, Cursor, Windsurf) who need a shared, managed memory estate that is not locked into a single vendor's proprietary storage.

Highlights

  • Vendor Agnostic: Connects to various tools like Claude Code, Cursor, and GitHub Copilot via a single command.
  • Policy-Based Expiry: Allows users to set retention tables and specific rules to pin or expire memories.
  • Fully Local Option: Can run entirely on-prem via Docker and Ollama with no outbound calls.
  • Typed Memory: Categorizes memories into 13 types (e.g., decision, preference, goal) for precise filtering.
  • Open Format: Memory is stored in OKF (Markdown), making it diffable and committable to version control.

Related

  • Project
    24kchengYe/MemoMind

    MemoMind is a locally hosted, GPU‑accelerated memory system for AI coding agents. It stores extracted facts from chats, documents, and daily life events in PostgreSQL + pgvector, builds a knowledge graph, and offers fast 4‑way hybrid retrieval (semantic, BM25, graph, temporal). The agent can retain new information, recall relevant memories, and reflect across the whole store. All data stays on the user’s machine, works with any OpenAI‑compatible LLM, and includes a web dashboard for browsing and exporting memories.

  • Project
    MemTensor/MemOS

    MemOS 2.0 is a Memory Operating System for LLM‑based AI agents. It offers a unified API to store, retrieve, edit, and delete multi‑modal memories (text, images, tool traces) organized as a graph. The system can run as a hosted cloud service (API‑key access) or be self‑hosted via Docker (Neo4j + Qdrant) or a local SQLite plugin. Ready‑made plugins integrate MemOS with OpenClaw, Hermes, and DeepSeek Harness. Benchmarks show it outperforms existing commercial memory products. Licensed under Apache 2.0.

  • Dispatch
    Mnemo: Local-First AI Memory Layer for LLMs

    Mnemo is a local-first AI memory layer written in Rust that uses a persistent knowledge graph and SQLite to provide LLMs with persistent, structured memory without cloud dependencies.

  • Project
    yuruotong1/autoMate

    autoMate is a locally hosted service that gives AI chat clients persistent personal storage (notes, files, reminders, long‑term memory) and a toolbox of real‑world actions (shell, browser, SaaS APIs). It talks to clients via an MCP‑over‑HTTP bridge, works with OpenClaw, Claude Desktop, Cursor, Cline, etc., and can also be used through its own web chat, Chrome extension, Docker container, or binary.

  • Project
    mnemon-dev/mnemon

    Mnemon is a cross‑platform CLI that adds persistent, graph‑based memory to LLM agents. The host LLM supervises what to remember, link, or forget, while Mnemon handles deterministic storage, decay, deduplication, and optional vector search. It integrates with many AI coding tools (Claude Code, Codex, Cursor, etc.) via one‑click setup, requiring only a single local binary and no extra API keys.