🔴 Iron Man's EXTREMIS — AI memory that merges with the agent

Memory that gets smarter
the more your agent uses it

Stop rebuilding RAG pipelines. Extremis gives any AI agent layered, learning memory in two lines of config — local SQLite, Postgres, Chroma, or Pinecone.

Get started View on GitHub →
pip install extremis

How it works

Every conversation logs durably. Every recalled memory gets scored. Every night the logs distil into structured knowledge.

Free · no LLM

remember()

Append to a fsync'd JSONL log and write to the episodic store in one call. Durable before any embedding happens.

Free · no LLM

recall()

Semantic search ranked by cosine × RL score × recency. Identity and procedural memories always included. Every result ships with a plain-English reason.

Free · no LLM

report_outcome()

Mark recalled memories useful (+1) or harmful (-1). Negative signals apply 1.5× weight — same asymmetry human threat-memory uses.

Uses Claude Haiku

consolidate()

The "dream pass" — reads new log entries, calls Claude Haiku to extract durable semantic and procedural facts, advances the checkpoint. Safe to re-run.

Install

Requires Python 3.11+. No API key needed for the core library.

# Core — local SQLite, sentence-transformers (no API key)
pip install extremis

# + MCP server for Claude Desktop / Code
pip install "extremis[mcp]"

# + Postgres, Chroma, Pinecone, OpenAI embeddings, hosted server
pip install "extremis[all]"

Quick start

from extremis import Extremis, MemoryLayer

mem = Extremis()  # stores in ~/.extremis/ by default

# Store
mem.remember("User is building a WhatsApp AI", conversation_id="c1")
mem.remember_now("Always ask about deadlines first", layer=MemoryLayer.PROCEDURAL)

# Recall — every result explains why it ranked here
results = mem.recall("what is the user building?")
for r in results:
    print(r.memory.content)
    print(r.reason)  # "similarity 0.87 · score +2.0 · used 5× · 3d old"

# Reinforcement — good memories surface first over time
mem.report_outcome([r.memory.id for r in results[:2]], success=True)

# Try the demo
# $ extremis-demo

Why Extremis

Most memory systems are cosine search over a flat vector DB. Extremis is different in five ways.

🧬

Memory that forgets intelligently

Recency decay + 1.5× asymmetric RL weighting. Unimportant things fade. Mistakes stick harder. The same pattern human threat-memory uses.

🔍

Every recall explains itself

r.reason"similarity 0.91 · score +4.0 · used 8× · 3d old". Auditable for enterprises. Debuggable for everyone.

🤝

Cross-agent shared memory

Multiple agents share one namespace. Research agent stores, writing agent recalls. Agent teams ship as one brain.

🔌

Backend-agnostic

SQLite locally. Postgres in staging. Pinecone in production. One env var. Migrate between any two with extremis-migrate.

🕸️

Knowledge graph built in

Entities, relationships, attributes. Answers "who does Alice work for" — the structural question vectors can't.

MCP-native

Plug into Claude Desktop or Claude Code with two lines of config. Nine tools, no code required.

How it compares

Feature Extremis Mem0 LangChain Raw Pinecone
RL-scored retrieval
Memory explains itself
Knowledge graph
Backend-agnostic✓ 4 backendsCloud onlyManual
MCP server✓ 9 tools
Self-hostable
Migration CLI
Open source (MIT)Partial

MCP setup — 30 seconds

Claude Desktop and Claude Code supported out of the box.

# 1. Install
pip install "extremis[mcp]"

# 2. Add to Claude Desktop config
# ~/Library/Application Support/Claude/
#   claude_desktop_config.json
{
  "mcpServers": {
    "extremis": {
      "command": "extremis-mcp"
    }
  }
}

# 3. Restart Claude Desktop
  • memory_rememberAppend to log + episodic store
  • memory_recallLayered semantic search with reasons
  • memory_report_outcome+1 / −1 RL signal
  • memory_remember_nowDirect write to any layer
  • memory_consolidateDream pass — log → structured facts
  • memory_kg_writeAdd entity / relationship / attribute
  • memory_kg_queryQuery the knowledge graph
  • memory_observe🔴🟡🟢 priority log compression
  • memory_score_attention0–100 message priority score

Your memory stays yours

No cloud. No tracking. No data leaving your machine unless you explicitly choose it.

🔒

Stored locally by default

All memories, logs, and knowledge graph data are written to ~/.extremis/ on your own machine. No account required. No sign-up. Nothing sent anywhere.

📋

Plain files you own

The conversation log is a JSONL file on your disk. The memory store is a SQLite database. Both are readable with any text editor. You can inspect, export, or delete them at any time.

🤖

When consolidation calls Claude

The optional memory_consolidate tool sends recent conversation log entries to Claude Haiku (via your own Anthropic API key) to extract structured memories. You control this — it only runs when you explicitly call it, and only uses your key, billed to you directly.

🏗️

You choose your backend

Switch to Postgres, Chroma, or Pinecone when you need scale — or keep SQLite forever. If you use an external backend, your data goes there under your own credentials. Extremis itself never sees it.

📡

Zero telemetry

Extremis collects no usage data, sends no analytics, and has no home-call behaviour. It's a library that runs entirely in your process. You can verify this — it's open source.

🖥️

Self-host the server too

Need a REST API for a team? Run extremis-server on your own infrastructure. The hosted server code is open source and ships with a Docker Compose file. We offer a managed cloud option for convenience, not necessity.

In short: your conversations never leave your machine unless you choose to consolidate (→ your Anthropic key) or use an external vector backend (→ your credentials). Extremis has no servers to breach because it doesn't have servers.