Skip to content

SYSTEM Cited by 1 source

MemCurrent

MemCurrent is Databricks' persistent-memory architecture for production AI agents, first disclosed 2026-10-20. It powers Agent Bricks Memory and Genie. Agents read and write memory as they work, and an offline "dreaming" pipeline consolidates memory in the background to keep it consistent and fresh. Its design thesis: more history is not better memory — supplying every past interaction is costly and injects stale/conflicting/irrelevant context, so the problem is what to retain, how to maintain it, and how to measure usefulness.

Two memory types

  • Episodic memory — raw session traces, append-only; a plugin logs each step as a session runs. Useful for recovering details that distillation drops, but the agent only searches it in ~⅓ of cases (passing ~60% of those).
  • Derived memory — distilled learnings stored as files in a structured knowledge base that simulates a hierarchical file system (a mutable table). An auto-generated memory.md index at the top describes the file layout and what each file contains; it is injected at session start so the agent "knows what it knows before it begins."

Both live in a production-grade database that scales to many users at low latency — in Agent Bricks this is a session store (episodic) + a memory store (derived), powered by Lakebase.

Three access patterns (plugin / tool / pipeline)

MemCurrent uses all three memory-access patterns, each where it fits best:

  • Plugin (automatic, online): injects the memory index at session start and logs each step to episodic memory. Immediate + predictable, but spends tokens even when memory isn't needed.
  • Tools (agent-driven, online): add_memory / update_memory / delete_memory for explicit requests ("Never write scripts in /tmp"), plus two retrieval tools spanning both memory types — search_memory (top matches for a query: a past trace step or a line in a memory file) and fetch_memory (full entry by identifier: session ID or file path).
  • Offline "dreaming" pipeline (scheduled/triggered, offline): distills implicit learnings from each new session into the right file, and does whole-store maintenance — split oversized files, merge duplicates, resolve conflicts. Lower runtime cost/latency (async, batched) at the price of a delay before updates land.

The offline-pipeline + online-tool split is an async-projected read model applied to memory: the authoritative append-only episodic log feeds a background consolidation pass that materializes the read-optimized derived store; explicit tool writes take effect immediately on top.

What makes it work (ablations)

  • Memory types: no memory 22.3% → episodic-only 35.8% → derived-only 66.1% → both 68.4% pass rate. The injected memory index is what makes derived memory strong; episodic adds a smaller boost by recovering distillation-dropped detail.
  • Extraction strategy: online tools alone 53.9% vs offline dreaming alone 63.5%; combined 66.1%. Dreaming handles background extraction + consolidation; tools make explicit requests take effect right away.

Results

  • Open-source benchmarks (LoCoMo, LongMemEval, ConvoMem): avg 88.1% ≈ full-context 87.8% at 8.4K vs 103K input tokens/question (~12× fewer); beats full context on the two longest-history benchmarks, where dumping everything into the prompt confuses the agent. On the Pareto frontier vs Mem0, PropMem, OpenClaw memory.
  • Genie Internal Memory Benchmark (114 cases, 29 users, 2,233 history sessions, built from real Genie sessions): 68.4% pass (no-memory 22.3%, gold-injection ceiling 78.6% — closes >80% of the gap), lowest latency (252s) and tokens (418K) among backends; Mem0 43.9%. Headline vs no memory: 3× pass rate, 1.35× faster, 1.44× cheaper.

Relationship to other Databricks / wiki systems

  • Lakebase — the production-grade database powering Agent Bricks Memory's session store (episodic) + memory store (derived).
  • Genie — now powered by MemCurrent; the source of the internal-benchmark sessions.
  • Agent Bricks Memory — the developer-platform product that ships MemCurrent (session store + memory store + automatic dreaming pipeline + tracing/eval + a <10-minute CLI). Sub-component of Agent Bricks; no separate page.
  • Lineage: Databricks' earlier memory work MemAlign and Memory Scaling are cited as the plugin-pattern predecessors.

Caveats

  • Tier-3 vendor post; all headline numbers are Databricks' own — the internal benchmark and backend comparison are constructed and LLM-judge-scored by Databricks, not independently reproduced.
  • Mechanism depth is partial: the dreaming pipeline's distillation/merge/ conflict-resolution logic, memory-index generation, retrieval ranking, and the Lakebase schema are described at capability level, not implementation level.
  • Model names (GPT-5.6 luna/sol, Claude Opus 4.6) are forward/placeholder- dated; the durable content is the architecture.

Seen in

Last updated · 854 distilled / 2,448 read