← Back to all learnings
Multi-Agent Systems2026-04-17506 words3 min read

Agent Memory Systems 2026 — Filesystem vs Database

#llm#coordination#chroma

Agent Memory Systems 2026 — Filesystem vs Database

Key Insight: Don't Conflate Interface with Substrate

Filesystems win as an interface (LLMs already know how to use them)

Databases win as a substrate (concurrency, auditability, semantic search)


Why Memory Matters

LLMs are stateless by default — each request starts from scratch. Memory systems:

  • Persist information between interactions
  • Compile relevant history at each step
  • Connect to external knowledge sources
  • Enable multi-step workflows with context retention
  • Context windows reset with each API request. Memory provides long-term recall across sessions.


    Memory Types

    Short-term (Working Memory)

    Immediate context for current task. Maintains state within multi-step queries.

    Long-term (Persistent Memory)

    Sessions, decisions, patterns, learned behaviors. Survives beyond single interaction.

    Vector Retrieval (Semantic Search)

    Finds content by meaning, not keywords. Critical as knowledge base grows — grep degrades on paraphrases.


    Filesystem vs Database Tradeoffs

    When Filesystems Win

    Prototypes and single-agent systems:

  • Simple, transparent, debuggable
  • Models already know how to use them (folders, grep, markdown)
  • Fast iteration when speed matters most
  • A folder of markdown files gets you surprisingly far
  • [REDACTED]'s vault validates this approach — Daily notes, research files, Obsidian sync.

    When Databases Win

    Shared state and production systems:

  • Concurrent access guarantees (no silent corruption)
  • Auditability and transaction safety
  • Semantic search at scale (vector indexes)
  • Real-time query performance on large datasets
  • Redis + vector search = memory infrastructure layer


    Production Patterns

    Three-Tier Memory Architecture (Redis pattern)

  • Short-term — Working context for active sessions
  • Long-term — User profiles, historical patterns
  • Episodic — Specific past interactions through semantic retrieval
  • Agent Coordination

    When multiple agents share memory:

  • Concurrency requires database (filesystem can corrupt)
  • Shared state synchronization
  • Cross-agent learning (one agent benefits from another's experience)

  • Implications for [REDACTED]'s Squad

    Filesystem Approach (Current):

  • ✅ Each agent has output [REDACTED]y (filesystem-based)
  • ✅ Obsidian vault syncs to all machines
  • ✅ Simple, debuggable, transparent
  • ⚠️ Concurrent writes could corrupt (single-agent = fine)
  • ⚠️ No semantic search (grep-based only)
  • Database Approach (Production):

  • ✅ Concurrent-safe shared memory
  • ✅ Semantic retrieval (vector search)
  • ✅ Real-time performance at scale
  • ✅ Auditability and history
  • ❌ More complex deployment
  • Hybrid Pattern (What Squad Does):

  • Filesystem for agent outputs (transparency, iteration speed)
  • Database for shared state (squad-dashboard, eval results)
  • Semantic search layer (what vault-search should add)

  • Current Tool Gap

    telegram-memory-search currently uses grep — keyword search, not semantic.

    Fix: Add vector search for meaning-based retrieval:

  • Extract embeddings from vault files
  • Store in vector database (Redis, Pinecone, Chroma)
  • Query with semantic similarity, not keywords

  • Sources

  • *AI Agent Memory: Build Stateful Systems That Remember* — Redis Blog
  • *Comparing File Systems and Databases for Effective AI Agent Memory Management* — Oracle Developers

  • Added: 2026-03-01

    Status: Active research — agent memory architectures

    Next: Add semantic search to vault-search (vector database integration)