PMB Review 2026: Local-First Memory Engine for AI Coding Agents

AI coding agents have a memory problem. Claude Code, Codex, OpenCode — they’re brilliant within a single session, but the moment you start a new one, all context evaporates. Every conversation begins from a blank slate. Every bug fix, architectural decision, and hard-won insight from yesterday’s session is gone, forcing you to repeatedly re-teach the agent your codebase’s quirks and conventions. PMB tackles this head-on with a local-first memory engine purpose-built for coding agents.

PMB is not another vector database. It’s a multi-strategy recall system that combines BM25 keyword search, vector embedding similarity, and an entity graph that tracks relationships between symbols, files, and decisions. All of this runs locally on your machine — no cloud dependency, no API calls, and retrieval latency around 35 milliseconds. It exposes memory operations as standard MCP tools, making it plug-and-play with any MCP-compatible agent harness.

What PMB Does

PMB serves as an external memory layer for AI coding agents. As your agent works through a coding session, PMB indexes the context — function signatures, file relationships, decisions made, errors encountered, and fixes applied. When you start a new session, the agent can query PMB to recall what you were working on, which files were involved, and what approaches you tried. The hybrid recall engine ensures that queries find relevant results whether you search by exact keyword (BM25), semantic meaning (vectors), or structural relationship (entity graph).

The MCP-native architecture is a deliberate design choice. Rather than requiring agents to call a proprietary API or learn a custom protocol, PMB speaks the Model Context Protocol — the same standard that Claude Desktop, Cursor, and a growing ecosystem of tools already support. Drop PMB into your MCP client configuration and your agent gains memory capabilities immediately.

Use Cases

Persistent Cross-Session Context for Coding Agents. The primary use case. Work on a feature across multiple sessions without losing context. PMB remembers which files you modified, what bugs you encountered, and which solutions worked — so your agent picks up right where you left off.

Codebase Onboarding. Point a new coding agent at your repository and have PMB pre-loaded with the architecture, key modules, and design patterns. Instead of the agent reading hundreds of files to build context, it queries PMB’s entity graph for a structured overview of how everything connects.

Air-Gapped Development. PMB’s local-first design means it works without internet access. For teams working in secure or air-gapped environments where cloud memory services are prohibited, PMB provides the same memory capabilities without any data leaving the machine.

Agent Decision Logs. Use PMB’s entity graph to track decisions made by coding agents over time. When an agent suggests a refactoring approach, you can query whether similar decisions were made previously and what the outcomes were — building institutional knowledge across agent sessions.

Key Features

Hybrid Recall Engine

The core innovation. PMB runs three retrieval strategies in parallel: BM25 for exact keyword matching (think function names, file paths, error codes), vector embeddings for semantic similarity (conceptual queries like “authentication flow”), and an entity graph for relational queries (“what files import this module?”). Results from all three are merged and ranked, delivering the most relevant context regardless of how you query.

~35ms Retrieval Latency

PMB is engineered for real-time agent decision loops. At 35 milliseconds per query, the memory retrieval adds negligible overhead to agent operations. Your coding agent can check memory before every tool call without perceptible delay — a critical feature when the agent is making dozens of decisions per session.

Entity Graph Layer

Beyond keyword and semantic search, PMB builds a knowledge graph of your codebase entities: files, functions, classes, modules, and the relationships between them. It tracks imports, function calls, inheritance hierarchies, and cross-file dependencies. This enables queries like “show me all functions that call authenticate_user” or “what other modules reference this configuration file?” — structural questions that pure vector search cannot answer.

MCP-Native Integration

PMB exposes its entire tool surface through standard MCP endpoints. Any agent that supports the Model Context Protocol — Claude Desktop, Continue, Cursor, or custom harnesses — can use PMB without additional adapter code. The MCP tools cover memory storage, hybrid search, entity graph queries, and session management.

Local-First, No Cloud Dependency

Everything runs on-device. Memory, indexes, and embeddings stay on your machine. No API keys, no subscription fees, no data leaving your network. The embedding model runs locally (you’ll need adequate RAM), and indexes are stored as local files alongside your project.

Pricing

PMB is free and open source. There is no SaaS tier, no paid plan, and no API key required. Total cost is your local compute resources — CPU and RAM for running the embedding model, plus disk space for indexes. The project is early-stage (discovered via Hacker News), so the license and exact embedding model requirements should be verified in the repository before production use.

Common Questions

How does PMB compare to vector databases like ChromaDB? ChromaDB provides vector-only search — you get semantic similarity but no keyword matching and no entity graph. PMB’s hybrid approach means you can find results by function name (BM25), conceptual similarity (vectors), or structural relationship (graph) — all from a single query. For coding-specific memory, the entity graph is especially valuable since code is fundamentally structured and relational.

Does PMB work with any coding agent? It works with any agent that supports the Model Context Protocol (MCP). Claude Desktop, Cursor, Continue, and many custom agent harnesses are MCP-compatible. Agents that don’t speak MCP would need an adapter layer.

Is 35ms latency realistic at scale? The 35ms claim comes from the project’s documentation. Real-world performance will depend on corpus size, embedding model choice, and hardware. For typical developer-sized codebases (thousands of files), sub-50ms should be achievable. For monorepos with millions of lines of code, you’ll want to benchmark before committing.

Verdict

PMB solves a genuine pain point with a clean architectural approach. The combination of local-first operation, hybrid recall across three strategies, and MCP-native integration is precisely what coding agents need to graduate from session-bound tools to persistent collaborators. The concept is strong, the design decisions are sound, and the 35ms latency target is ambitious but credible.

The main uncertainty is maturity. This is a new project with limited community traction as of mid-2026. Documentation depth, production stability, and the quality of the entity graph extraction across diverse codebases are all open questions. For developers who regularly work with coding agents and are comfortable with early-stage open source tooling, PMB is well worth evaluating. For teams that need battle-tested reliability, watch this space — the architecture is right, but it needs time to prove itself at scale.

Overall: 7.0/10 — A well-architected solution to the agent memory problem with strong technical fundamentals. Early stage, but the conceptual fit with coding agent workflows is excellent.