Seven Memory Architectures, One pip install

Turing Post published a roundup this week: “7 Emerging Memory Architectures for AI Agents.” All recent papers, all proposing different ways for agents to remember, learn, and reason over time.

I read all seven. And I kept having the same reaction: we built that. Not in every case, not in every detail. But five of the seven architectures describe capabilities that OMEGA has been shipping since January.

That's not a brag. It's a signal. When independent research teams converge on the same ideas you already implemented, it means the problem space is real and the solutions are becoming obvious. Here's how the papers map.

1. Agentic Memory (AgeMem) proposes unifying short-term and long-term memory inside the agent itself. The agent decides what to store, what to retrieve, what to discard. Memory management becomes part of the agent's decision-making, not a bolt-on.

OMEGA does this through MCP tools. The agent calls omega_store and omega_query as part of its reasoning loop. It decides what matters. Session context works as short-term memory, the SQLite store as long-term. Auto-capture hooks handle the rest, pulling decisions and errors without the agent having to tag anything. We added TTL, strength decay, and consolidation so the store doesn't grow forever.

2. Memex stores full interactions in an external memory database while keeping only compact summaries in context. The agent retrieves exact past information when needed.

This is almost exactly OMEGA's architecture. Full memories live in SQLite. The omega_welcome call loads a compact briefing into context at session start: recent decisions, active reminders, key lessons. The agent queries the full store when it needs deeper history. We've been running this pattern since day one.

3. UMA (Unified Memory Agent) uses a dual memory system: a compact global summary plus a structured key-value Memory Bank that supports create, update, delete, and reorganize operations.

OMEGA's welcome briefing is the global summary. The memory store is the structured bank with full CRUD: store, update, forget, query. We also have type-aware routing, so different memory types (decisions, lessons, preferences) get different retrieval weights. UMA uses reinforcement learning to train the memory manager. We use heuristics and hooks, which is less elegant in theory but works without a training loop.

4. Conditional Memory proposes selective knowledge lookup during inference. Instead of loading everything, the agent uses sparse memory tables and routing gates to decide when and what to retrieve.

OMEGA's hybrid retrieval pipeline does something similar. Vector similarity, FTS5 full-text search, type-based weighting, cross-encoder reranking. The agent doesn't get everything dumped into context. It gets the 10 most relevant memories, scored and ranked. Not O(1) hashed retrieval like the paper proposes, but under 50ms on a local SQLite store with thousands of memories. Fast enough.

5. Multi-Agent Memory from a Computer Architecture Perspective frames multi-agent memory like computer hardware: shared vs. distributed memory, cache hierarchies, memory consistency protocols. The paper notes that existing systems lack protocols for cache sharing and cross-agent memory access.

This is the one that hit closest to home. OMEGA's coordination system already implements shared memory with access controls. File claims prevent two agents from editing the same file. Branch guards keep agents off each other's branches. Peer messaging lets agents pass context. Deadlock detection catches circular dependencies. We didn't design it from a CompArch perspective, but the problems are the same, and we solved them the same way: give agents visibility into each other's state and enforce consistency at the protocol level.

MemRL uses reinforcement learning to improve memory retrieval strategies over time. Interesting idea, but OMEGA doesn't use RL. We rely on heuristic scoring, decay functions, and usage tracking. MemRL separates stable reasoning from flexible memory, which is the right instinct, but the training loop adds complexity that doesn't make sense for a local-first tool. Maybe later.

Pancake is a high-performance hierarchical memory system designed for large-scale vector retrieval with GPU-CPU coordination. This solves a real problem, but it's an enterprise infrastructure problem. OMEGA runs on a laptop. Our retrieval path is SQLite + ONNX embeddings + FTS5, and it handles thousands of memories in under 50ms. If you need sub-millisecond retrieval across millions of memories shared by hundreds of agents, Pancake is the paper to read. That's not OMEGA's use case.

Three patterns keep showing up across multiple papers, and they're all things OMEGA chose early:

External storage with compact context loading. Don't stuff everything into the prompt. Store externally, load a summary, query on demand. AgeMem, Memex, and UMA all converge on this. OMEGA's welcome briefing and query tools have worked this way from the start.

Agent-controlled memory management. The agent decides what to remember, not an external pipeline. AgeMem and UMA both emphasize this. OMEGA exposes memory operations as MCP tools, so the agent decides. Auto-capture hooks supplement this for things agents would otherwise forget.

Multi-agent memory needs coordination protocols. The CompArch paper identifies this as the missing piece. Most memory systems assume a single agent. OMEGA built coordination as a first-class subsystem: file claims, branch guards, peer messaging, task queues.

The conditional memory paper has an idea worth stealing: O(1) hashed retrieval for high-frequency memory lookups. OMEGA's retrieval is fast, but a hashed index for the most-accessed memories could cut repeat queries to near zero. That's on the list now.

The CompArch paper's framing of memory as a three-layer hierarchy (I/O, cache, memory) maps well to how I already think about OMEGA's architecture. The protocol briefing is the cache. The full store is memory. Hook-captured context is I/O. Naming things well helps you build them better.

And MemRL's separation of stable reasoning from flexible memory is the right long-term direction. Right now OMEGA's retrieval heuristics are static. Adapting them based on what actually helped the agent would be a meaningful improvement. Not through RL, probably. But the principle is sound.

Seven papers, from seven different research teams, all converging on the same set of problems. That's the kind of validation you can't manufacture. The difference between a paper and a product is the thousand decisions you make when real agents hit real codebases. OMEGA made those decisions. You can see them in the source.