AI agent memory that remembers the
reasons — and catches itself
contradicting.

Ergo is a memory backend for AI coding agents that stores every decision alongside why it was made — with kill-criteria, conflict detection, and full revision history. It scales from a single agent's local store to a multi-tenant engine — one isolated SQLite silo per team — so one org's decisions can never leak into another's. Stop losing context across sessions.

Get startedRead the docsWhy Ergo

Everything Ergo does, in one place

Six capabilities, one continuous scroll. Keep going to see each one in action — the panel keeps up.

Write time

Store a decision with its reason

Every write carries the reasoning that produced it — --because isn't optional metadata, it's what makes the claim retrievable and checkable later.
store a decision with its reason
Write-time firewall

Four stages stand between a claim and storage

Every new claim is normalized, structurally compared, and run through an NLI model before a judge decides: store it clean, or block it as a contradiction of something already on file.
agent> ergo remember "Docs use Fumadocs for the MDX renderer"
normalize
structural
NLI
judge
Read time

Recall the reason nobody remembers

Ergo stores the why next to the what. Ask why a decision was made and get the reasoning back — so an agent picking up the work weeks later doesn’t re-derive it from scratch or undo it by accident.
surface the reason nobody remembers
Over time

Stale beliefs flag themselves

Every claim can declare the conditions that would make it wrong. Ergo checks those kill-criteria and surfaces beliefs whose reasoning no longer holds — before they quietly mislead the next decision.
stale beliefs flag themselves
Isolation

Isolated by tenant, not by convention

Every tenant gets its own physical SQLite file — not just an org_id column. A dropped filter can't leak claims across tenants, because the rows aren't even in the same database. Tokens are per-principal and hashed at rest; org_id and who resolve from the token server-side, never self-asserted from the request.
acme.db
tenant
acme
— empty —
beta.db
tenant
beta
— empty —

two tenants, two physically separate SQLite files

Everywhere

A drop-in MCP memory server

Ergo is an MCP memory server — a shared agent memory backend scoped per repo and per agent. Claude Code writes it, Opencode reads it: same store, same repo, zero config. Anything that speaks the Model Context Protocol shares the context, so your LLM memory follows the work, not the session.
one memory, every MCP agent

Status

Ergo is under active development. It's currently used in production by the coding agents building it (Claude Code and Opencode) — the memory backend they use is Ergo itself. The multi-tenant engine — silo isolation, control-plane auth, bounded concurrency — is live; a hosted team server deployment is next.

  • Core memory API + MCP toolsLive
  • NLI-based conflict detectionLive
  • Kill-criteria engineLive
  • Multi-tenant engine (silo isolation)Live
  • Control-plane auth + per-tenant tokensLive
  • Bounded concurrent serverLive
  • Hosted team server (multi-tenant deploy)In progress
  • SaaS / hosted offeringPlanned

Frequently asked questions

Common questions about Ergo — AI agent memory, how it compares, and how it runs.

What is Ergo?

Ergo is a memory backend for AI coding agents. It stores every decision alongside the reason behind it, and checks each new claim against what's already stored — catching contradictions at write time instead of letting stale memory silently poison future decisions.

Which AI agents does Ergo work with?

Any agent that speaks the Model Context Protocol (MCP). Claude Code and Opencode use it today, and Ergo runs as a drop-in MCP memory server scoped per repo and per agent, so anything MCP-compatible can share the same memory.

How is Ergo different from a vector database like Pinecone or Chroma?

A vector database gives an agent recall but no judgment: when a decision changes, the old claim stays embedded and retrievable, so a contradiction is treated as just another similar document. Ergo adds a write-time judgment layer — it normalizes, structurally compares, and runs a natural-language-inference check before storing, returning HTTP 409 with the conflicting claim so the agent has to resolve it. It also keeps the reason behind every decision and a full supersede history.

How does Ergo compare to other AI agent memory tools like mem0 or Zep?

Tools like mem0 and Zep are general-purpose agent-memory layers focused on capturing and recalling context. Ergo is narrower and complementary: it is built around a write-time contradiction guard and a reason attached to every decision, aimed at high-stakes, slow-changing choices like conventions, configs, and architecture. Detailed side-by-side comparisons are coming soon.

Can I self-host Ergo?

Ergo is built to be self-hosted — a single Docker container plus one SQLite file, no external services, running fully offline and air-gapped. It is in active development and currently used in production by the coding agents building it; a hosted team server is on the way.

How accurate is Ergo's contradiction detection?

On 105 labeled real-world prose pairs, Ergo's judge runs at roughly 0.80–0.86 precision and about 0.81 recall with zero false hard-blocks, and the engine ships with 500+ offline tests. It normalizes claims first, compares structure, then applies NLI only to the fuzzy residual behind an overlap gate — which beats retrieval or NLI alone.