Midas

Midas is a local memory layer for long-horizon AI agents, positioned as "memory that lives on your machine, right next to your AI assistant." It aims to solve the problem of AI assistants forgetting everything between sessions: a coding agent can remember decisions, agreements, and bugs from three sessions ago without sending every message to an LLM to "extract" facts.

Key capabilities

• Local-first and zero-LLM ingestion: according to the materials, no LLM is called during ingestion or query, so there is no API cost, data never leaves the local machine, and local operations are fast (on the order of tens of milliseconds, with no network round trip per turn). Recall returns verbatim source turns rather than LLM-rewritten results, avoiding an extraction step that could silently hallucinate "facts" the user never said.
• Automatically stays up to date: typed belief revision replaces old values with new ones instead of piling up duplicates; selective forgetting keeps memory bounded, all without an LLM.
• Safe to build on: provenance guards let memory participate in planning but prevent external or destructive actions from being initiated on the basis of memory alone, unless the user explicitly confirms and the confirmation is still valid; memories that have been superseded cannot authorize actions at all.
• One file, multiple tools: Claude Code, Cursor, and chat applications can point to the same SQLite file and share the same live memory.
• Governable memory: beyond recall, it also provides measured properties such as action safety, decision adherence, repeated-error avoidance, recovery fidelity, conflict detection/precision, and adversarial memory safety. The materials state that the safety evaluation blocks 10/10 adversarial attacks (ASR 0.00) with no over-blocking (benign-pass 1.00).
• Glass-box observability: provides a local inspector, midas inspect, to see what the agent remembers, why, and what the source is, and to correct, pin, or forget it; every write/revision/forget is appended to a tamper-evident hash-chain audit log inside storage (hashes only, no content).

How to use

• Install and connect: connect memory to a coding agent with a single command; midas init creates a shared memory (~/.midas/memory.sqlite3) and points detected MCP clients (Claude Code, Codex, Grok Build, Cursor, Claude Desktop, Windsurf, VS Code, Gemini CLI, Cline, Zed) to it.
• MCP server: as a standard MCP server, any client can be pointed to midas-mcp command, uses shared storage by default. Can be overridden via environment variables, such as MIDAS_MCP_DB, MIDAS_MCP_MAX_RECORDS, MIDAS_MCP_MIN_IMPORTANCE, MIDAS_MCP_NAMESPACE, etc.
• The toolset includes: remember, capture (policy-gated automatic storage), recall (with traceable sources), build_context, resume, memory_state, memory_diff, memory_conflicts, open_loops/remember_commitment/close_loop, check_memory_use (guard), memory_policy, maintain, stats, forget, forget_matching, forget_all; prompts include memory_session, distill.
• Import existing memories: midas import --from claude-md CLAUDE.md (or cursorrules, jsonl, mem0, zep) converts rules and exports into first-class, recallable, governable memories.
• Optional hook: midas init --claude-hook installs a Claude Code SessionEnd hook, feeding each round of user turns to memory, while Midas's LLM-free policy still decides what is actually retained.
• Python SDK and CLI: provides a Python SDK (midas-memory), as well as commands such as midas update, midas inspect, midas audit, midas doctor; midas doctor can diagnose wiring issues (only reads configuration paths and versions, not memory contents).
• Optional encryption: after setting MIDAS_MCP_KEY and installing the [encrypted] extra, storage becomes a SQLCipher database.

Use cases

• Long-horizon coding agents: remember decisions, conventions, bugs, commitments, and unfinished items across sessions.
• Multi-client shared memory: facts captured in the IDE can be recalled from a chat application without restarting.
• Memory requiring audit and governance: scenarios where you want to know memory sources, history, conflicts, andreasons for action authorization.
• Privacy-sensitive and cost-sensitive scenarios: do not want every message to incur token costs or data leaving the device.

Limitations

• The materials explicitly state that Midas trades away whole-conversation capability in exchange for $0, privacy, and auditability, and publish measurement results showing where this trade-off is limited.
• Retrieval is its strength and is basically at its ceiling for the LLM-free design; the frontier's additional leverage is structure-preserving extraction, which requires the more capable models that Midas deliberately does not run during ingestion; small local extractors were measured as unhelpful, and the optional distillation switch is off by default and is not claimed as a benefit.
• GUI applications do not share the shell PATH; if the client reports "command not found", use the absolute path obtained from which midas-mcp; on Windows, JSON paths use forward slashes.
• The project is early-stage, but the build scope is narrow and measurement-first.

License and privacy: MIT license, completely free and open source, no paid tiers, no feature gates, no telemetry, no account; memories are stored in a local SQLite file, and capture/recall/forget make no network calls; the only external traffic is a one-time embedding model download (local backend) and package installation.