Midas enthroned — the concept of governed memory rendered as a golden monument
Governed memory

Midas — governed memory for AI agents

A memory your agent can be trusted to act on. Local, source-traceable, and mechanically blocked from acting on stale or unconfirmed beliefs.

$0
LLM at ingest
0.92
recall@k · LongMemEval-s
0.00
Unsafe-action rate
Apache-2.0
Free forever

Why Midas

Private by default

No LLM at ingest. Your memory stays local unless you choose otherwise.

Safe to act on

A guard blocks stale, superseded, or unconfirmed beliefs before actions.

Auditable

Every memory keeps source, time, provenance, and revision history.

Current Signal

Beyond the hero numbers: second-dataset recall, frontier benchmark, ingest cost, and precision.

See all benchmarks →
LoCoMo
0.73
recall@k · full set, vs 0.05 recency baseline
BEAM 100K
0.56
recall@k · 10M-token frontier, vs 0.00 baseline
Ingest
61 ms
per event · 246,750 turns on CPU, zero LLM calls
Precision
≈2×
relative-relevance floor · ~30–40% fewer context tokens
The Memory Inspector

See & control your memory.

A local inspector shows what your agent remembers, where it came from, and whether it is safe to use.

  • Search every memory with provenance.
  • See belief history and revisions.
  • Check whether memory can authorize an action.
  • Forget with an erasure receipt.
midas-inspector
local only
$ midas inspect
→ http://localhost:7777  ·  local only

# 3,412 memories  ·  belief revisions: 184  ·  pinned: 12
# governance: 7 actions blocked this week (stale or unconfirmed)

? launch_date           "Sept 14"   pinned · confirmed 2026-06-12
? launch_date  (prior)  "Sept 7"    superseded 2026-06-12
? api_key_rotation_sla  "24h"       source: ops/policy.md#L42

forget "draft pricing v1"  →  receipt: sha256:9f2c…b71  ok
Runs on your machine. No telemetry. No remote read.

Architecture

A small memory stack built for trust, not mystery.

Explore architecture →

Ingest

Deterministic, local, source-aware.

Store

Versioned memory with provenance.

Recall

Relevant context, ready for prompts.

Guard

Blocks unsafe memory-based actions.

Get started

Install the SDK

One command. No accounts, no keys, no telemetry. Runs locally against a SQLite file.

Read the install guide →
pip
pip install "midas-memory[all] @ git+https://github.com/vornicx/Midas"
Python
from midas import Memory, LocalEmbedder

mem = Memory(embedder=LocalEmbedder())
mem.remember("Launch is on Nov 12.", kind="fact", importance=5)
print(mem.build_context("When is launch?", token_budget=128))
TypeScript
import { MidasClient } from "midas-memory";

const mem = new MidasClient({ db: "~/.midas/memory.sqlite3" });
await mem.remember("Launch is on Nov 12.", { kind: "fact", importance: 5 });
console.log(await mem.buildContext("When is launch?", { tokenBudget: 128 }));

SDK + MCP

Integrate Midas into your agents and workflows with a simple API or via MCP.

View SDK docs →
from midas import Memory, LocalEmbedder, ContentImportance

mem = Memory(embedder=LocalEmbedder(),
             importance_scorer=ContentImportance())

# Ingest — LLM-free, deterministic.
mem.remember("Quarterly update: revenue grew 23%.",
             kind="fact", importance=5)

# Retrieve — source-traceable, ranked.
hits = mem.recall("What drove revenue growth?",
                  limit=5, filters={"time_range": "30d"})

# Assemble a budgeted, prompt-ready context block.
context = mem.build_context("When do we launch?",
                            token_budget=128)
print(context)
MCP Integrations
  • Claude DesktopReady
  • CursorReady
  • VS CodeReady
  • Custom AgentsHTTP / SSE
Learn more about MCP →

Use cases

Memories that power better agent outcomes.

Support agents

Keep customer context across long conversations.

Research agents

Carry findings and sources across sessions.

GTM agents

Remember account context without leaking data.

Open source

No subscriptions. Ever.

Midas is fully open source under Apache-2.0. Everything — engine, guard, inspector, benchmarks, MCP server, CLI — lives in the repo and stays free.

Free forever

No accounts. No paywalls. No usage limits. Just clone, install, and run.

Local by default

Your memory is a SQLite file on your machine. No telemetry, no cloud, no phoning home.

Apache-2.0

Use it in personal, commercial, or on-prem deployments — the license won't bite.

For teams & regulated orgs

Built to pass a security review.

Shared memory for agent fleets without giving up control. Self-host it inside your perimeter — same Apache-2.0 code, no vendor in the loop.

Scoped memory

Roles, scopes, and team isolation.

Audit trail

Know what memory authorized or blocked.

Provable forgetting

Receipts prove deletion, not hiding.

On-prem / VPC

Deploy inside your perimeter.

FAQ

Short answers to the hard questions.

Where does my data live?

With you: local file, your server, or your VPC.

How is Midas $0 at ingest?

It does not call an LLM to store memory.

What stops an agent from acting on a stale fact?

The guard refuses stale, superseded, or unconfirmed memory.

Can I really delete a memory?

Yes. Forgetting returns an erasure receipt.