Two Pools, One Record: The Architecture of a Memory Engine for AI Agents

2026-06-23 · Source: Towards AI - Medium · Field: Technology & Digital — Artificial Intelligence & Machine Learning, Software Development & Engineering, Robotics & Autonomous Systems · Depth: Advanced, long

Summary

A new memory engine architecture for AI agents, currently under development, proposes a "Two Pools, One Record" design to address common memory challenges. This standalone, local-first library separates personal memory (about the user) from project memory (about a codebase), joining them via a pointer. All memory items conform to one typed record with five kinds (fact, note, edge, procedure reference, persona), incorporating two timelines and provenance. Model intelligence operates asynchronously on the write path, extracting, enriching, and routing memories. The read path features three depths—HOT (~50 ms, 500-token profile), WARM (on-demand search), and DEEP (archive dive)—with zero model calls. Forgetting is a reversible score, and access control is handled by an external identity layer, not the engine itself. Crucially, the system is designed to grow skills from repeated successful procedures, storing references to external SKILL.md files. Project memory leverages Git refs for serverless team sharing, with an op-log ensuring merge-free collaboration. The design is complete, with core components currently in build.

Key takeaway

For AI Architects designing agent memory systems, prioritize a "Two Pools, One Record" architecture. This approach ensures data privacy and lifecycle management by separating personal and project contexts, while asynchronous model processing on writes maintains read performance. You should integrate an external identity layer for access control and utilize Git refs for seamless, serverless team memory sharing. Focus on enabling skill growth, not just fact recall, to maximize agent utility.

Key insights

AI agent memory benefits from distinct personal and project pools, asynchronous model processing, and skill-growing capabilities.

Principles

• Separate personal and project memory pools.
• Model intelligence should be asynchronous on writes.
• Memory must honor external access grants.

Method

The engine extracts, enriches, embeds, routes, stamps provenance, checks for skill candidates, and reconciles memories asynchronously. Reads use three depths: HOT (profile), WARM (search), DEEP (archive).

In practice

• Implement bitemporal data models for history.
• Use Git refs for serverless team memory sharing.

Topics

• AI Agent Memory
• Memory Architecture
• Bitemporal Data
• Skill Learning
• Git-based Storage
• Access Control

Code references

• git-bug/git-bug

Best for: AI Scientist, Research Scientist, AI Architect, AI Engineer, Machine Learning Engineer

Related on AIssential

• 7 Emerging Memory Architectures for AI Agents — Advanced memory architectures are crucial for AI agents to manage context and learn from past experiences in complex tasks.
• AI Agent Memory Explained in 3 Levels of Difficulty — Effective AI agent memory transforms stateless LLMs into persistent, adaptive, and context-aware systems.
• Governed Memory: A Production Architecture for Multi-Agent Workflows — Governed Memory provides a shared memory and governance layer for multi-agent systems, enhancing recall and reducing token usage.
• Agent memory resolved? — A git-like memory framework significantly enhances coding agent performance and context persistence across sessions.
• OpenClaw Architecture - Part 3: Memory and State Ownership — Agent "memory" is state ownership and rehydration, not model learning, requiring durable storage and explicit retrieval.
• Building the AI Memory Stack: Layered Storage, Async Extraction and Atomic Persistence — Production AI agents require a layered, asynchronously updated, and robustly persisted memory system to maintain context.

Open in AIssential →

Editorial summary, takeaway, and curation by AIssential. Original article published by Towards AI - Medium.