iai-pme: A Local Memory Engine That Stores Every Turn Verbatim for Your Coding Agent

The Problem: Assistants Forget You Every Session

Every coding assistant starts a new session with a blank slate. You re-explain your project, re-state your preferences, and re-read files the agent already saw yesterday. iai-pme targets this exact pain. It is a local server that speaks MCP-over-stdio and gives any compatible assistant a long-term memory. The target user is a solo developer or power user who works with tools like Claude Code, Cursor, or Codex CLI and is tired of repeating themselves. The author states they built it for themselves and ran it daily for months before sharing. This is not a memory layer for products you ship; it is a personal memory engine for the assistant you already use.

How It Works: Verbatim Capture and Hyperdimensional Substrate

The core mechanism is simple to describe but unusual in implementation. It captures every turn of every session verbatim, with no LLM in the capture path. The README is explicit: a memory write costs file IO plus a local embedding, not an LLM call. That is a deliberate design choice, and it contrasts with cloud memory layers that run LLM-extraction pipelines on every exchange. The storage engine, community-detection algorithm, and what the author calls a hyperdimensional memory substrate are all custom code, not wrappers around Qdrant or Neo4j. A native Rust engine handles storage and speed. The system organizes captures over time into a personal map, then serves a small slice of relevant memory at the start of each new conversation. The style is described as autistic by design: verbatim over paraphrase, precise cues, rare events kept rare. That phrasing is provocative, but the intent is clear: no summarization, no lossy compression.

Quick Start and Configuration: One Command, Real Keys

The README gives a single bootstrap command for macOS or Linux: curl -fsSL https://raw.githubusercontent.com/CodeAbra/iai-personal-memory-engine/main/scripts/bootstrap.sh | bash. That command checks prerequisites, clones the repo to ~/.local/share/iai-pme, builds, installs the background engine and capture hooks, and registers the MCP server. The configuration section exists in the table of contents, though the truncated README does not show the actual keys. One config key is mentioned elsewhere: budget_tokens, which defaults to 1,500 and bounds an explicit memory_recall call. The dashboard is a notable feature: it keeps count of memory packs served, tokens injected, and a lower-bound estimate of tokens saved. That is a concrete monitoring tool, not a vague promise.

Token Economics: The 88% Claim and Its Caveats

The README makes a specific cost claim: an injected memory pack costs about 88% less than the agent search it displaces. The basis is the author's own store over three weeks: 282 memory packs served, about 99,000 tokens of context injected, displacing agent searches that average 2,639 tokens per call, for a lower-bound saving of about 707,000 tokens. The engine's formula is conservative, and the dashboard measures the search side rather than assuming it. The 88% figure applies to ambient packs injected at session start and the per-turn foresight pack. An explicit memory_recall is a different object: it is bounded by budget_tokens and typically returns more than an ambient pack, so it saves real tokens but not 88%. That distinction matters. If you evaluate the tool, you should run the benchmark harness on your own store, because the number is highly dependent on your session patterns.

Storage and Privacy: Local by Default, No Telemetry

iai-pme runs entirely on your machine. The README states there is no API key, no account, and no telemetry. The engine, the store, and the embeddings all run locally. The only thing that leaves your machine is the normal model call your CLI already makes. That is a genuine privacy advantage over cloud memory services, which typically send your session data to an external LLM for extraction. The storage engine is custom Rust, so there is no external vector database to install. That reduces operational overhead but also means you depend on the project's own storage code. The README does not describe the on-disk format or migration path, which is a gap you should check before trusting it with months of session history.

Limitations and Wrong Tool Cases

The README is honest about scope: if you need multi-tenant memory for an app you are shipping, use a memory layer like Mem0 or Graphiti. iai-pme is for your personal assistant, not a product backend. The verbatim capture design has a trade-off: it stores every turn, which could grow large over time. The README does not specify retention limits or disk usage estimates. The author says the style is autistic by design, which means it may not suit users who prefer summarized, high-level memory over exact wording. Another limitation is platform support: the quick start explicitly says macOS or Linux, with no mention of Windows. If you are on Windows, you may need to run it in a container or WSL, and the README does not offer guidance. Finally, the token saving claim is based on the author's own usage, so your mileage will vary.

Alternatives: Memory Layers vs. Compression-Based Tools

The README draws a clear line between iai-pme and two categories. The first is memory layers like Mem0, Supermemory, Graphiti, and Letta. Those are cloud-first, use LLM-extraction pipelines, and are designed for products you build. They store extracted facts or compressed summaries, not verbatim turns. The second is claude-mem, which is compression-based and stores AI-generated summaries of sessions. iai-pme differs from both: it stores every turn verbatim, write-once, never rewritten. When a fact changes, the old version is archived and still retrievable, with the README citing Rescue@10 of 1.000 and historical wording of 1.000. If you prefer summaries over verbatim recall, claude-mem is a closer fit. If you need a managed multi-tenant store, one of the memory layers is the honest choice. iai-pme occupies a narrow niche: local, verbatim, personal.

Maintenance and License: MIT and Active Releases

The project is MIT licensed, which means you can use, modify, and redistribute it freely, including in commercial products, with attribution. That is a permissive license with no copyleft obligations. The repository shows recent releases: v3.0.8 on 2026-08-23, v3.0.7 on 2026-08-21, and v3.0.6 on 2026-08-21. That indicates active maintenance, with multiple releases in a short window. The README includes a section called Staying up to date, which suggests there is a defined update process, though the truncated material does not show the commands. There is also a Doctor section, likely for diagnosing installation issues. For upgrade cost, the bootstrap script and background daemon imply that updates may be as simple as re-running the script, but that is not confirmed. You should check the repository for a changelog or release notes before adopting, since the README does not detail migration between versions.

Editorial conclusion

Adopt iai-pme if you are an individual developer using MCP-compatible coding assistants and want a local, no-account memory that stores every turn verbatim. Skip it if you need multi-tenant memory for a product you are shipping, or if you prefer LLM-extracted summaries over verbatim recall. Before adopting, verify the 88% token saving claim by running the included benchmark harness on your own store, and confirm that the Rust engine builds cleanly on your platform, since the README notes macOS and Linux support but does not mention Windows.

Official sources

1. Official README
2. Project repository
3. Release notes