> ## Content Index
> Fetch the complete content index at: https://zipmex.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Databricks MemCurrent: agent pass rate rises to 68.4% from 22.3% in its own test
- URL: https://zipmex.com/blog/databricks-says-its-memcurrent-memory-lifts-agent-pass-rate-to-68-4-from-22-3-in-its-own-test/
- Published: 2026-10-20T23:13:08.000Z
- Updated: 2026-10-24T23:52:41.000Z
- Description: Databricks says MemCurrent memory raised AI agent pass rate from 22.3% to 68.4% on its internal benchmark. What was tested, what drove it, and the caveats.
- Author: ZIPMEX
- Tags: AI, #zipmex-newsroom

On Oct. 20, 2026, Databricks published MemCurrent, a persistent memory design for AI agents. It says the design lifted an agent's pass rate on its internal enterprise benchmark from 22.3% with no memory to 68.4%. Over the same comparison, Databricks reports 31% fewer tokens and lower latency. Every figure in this article comes from Databricks, which built the benchmark, ran the tests and published the results. The same day, Databricks released Agent Memory in Beta and called it "a production implementation of MemCurrent."

![Three facts from Databricks' MemCurrent post: the benchmark has 114 test cases, 29 users and 2,233 history sessions; it used Claude Opus 4.6 as the agent model and GPT 5.6 sol as the memory model; another setup used GPT 5.6 luna as both agent and memory model.](https://storage.ghost.io/c/d4/f3/d4f34881-0300-4bbe-b8df-78a26d28be4d/content/images/2026/10/zipmex-ca3595f541d455cf.png)

Original ZIPMEX key-facts diagram on how Databricks tested its MemCurrent memory for AI agents: benchmark size and the models used. Built from the quoted Databricks source, data: databricks.com, 2026-10-20\. · ZIPMEX diagram; data: databricks.com

How Databricks tested MemCurrent/ KEY FACTSHow Databricks tested MemCurrentBENCHMARK SIZEDatabricks says its benchmark has 114 test cases, 29 usersand 2,233 history sessions.MODELS USEDDatabricks says it used Claude Opus 4.6 as the agent modeland GPT 5.6 sol as the memory model.OTHER MODEL SETUPDatabricks says it used GPT 5.6 luna as both the agent andthe memory model.Source: MemCurrent: Designing Persistent Memory for Production Agents (databricks.com), accessed Oct 20, 2026

![Three facts from Databricks' MemCurrent post: the benchmark has 114 test cases, 29 users and 2,233 history sessions; it used Claude Opus 4.6 as the agent model and GPT 5.6 sol as the memory model; another setup used GPT 5.6 luna as both agent and memory model.](https://storage.ghost.io/c/d4/f3/d4f34881-0300-4bbe-b8df-78a26d28be4d/content/images/2026/10/zipmex-ca3595f541d455cf.png)

Original ZIPMEX key-facts diagram on how Databricks tested its MemCurrent memory for AI agents: benchmark size and the models used. Built from the quoted Databricks source, data: databricks.com, 2026-10-20\. · ZIPMEX diagram; data: databricks.com

## What Databricks announced on Oct. 20

Two posts appeared on the Databricks blog on Oct. 20, 2026:

- **The research post**, "MemCurrent: Designing Persistent Memory for Production Agents," credited to the Databricks AI Research Team. It describes the architecture and the benchmarks.
- **The product post**, "Introducing Agent Memory on Databricks," by Sirui Sun and Nihit Desai. It says Agent Memory is "available in Beta today" and runs on Lakebase, which Databricks calls its serverless Postgres.

The research post also says MemCurrent already runs behind the scenes in Genie, Databricks' conversational data interface.

## How MemCurrent works

MemCurrent stores memory in two layers:

- **Episodic memory**: raw session traces. A plugin logs them step by step, and they are append-only.
- **Derived memory**: learnings distilled from those sessions. They are stored as files in a structured knowledge base, which a mutable table arranges like a hierarchical file system. An auto-generated `memory.md` index at the top describes how the files are organised.

Memory gets written in two ways:

- **Online tools**: `add_memory`, `update_memory` and `delete_memory`, which the agent calls when a user explicitly asks it to remember, change or forget something.
- **Offline "dreaming"**: a background pipeline that runs on a schedule or a trigger. It pulls implicit learnings out of new sessions, splits oversized files, merges duplicates and resolves conflicts.

For reads, a plugin injects the index when a session starts. The agent can then call `search_memory` and `fetch_memory` across both layers.

The Databricks documentation uses product terms for the same design. The **session store** holds the transcript of one interaction, which is episodic memory. The **memory store** holds durable facts, preferences and decisions the agent recalls in later conversations, which is derived memory. A **memory pipeline** is the dreaming process that turns the first into the second. Both stores are backed by Lakebase.

## The internal benchmark

Databricks built the benchmark from real Genie conversations. It started with more than 12,000 sessions and mined about 3,000 candidates that showed signs of being worth remembering. An adversarial judge checked each case against seven criteria, and then the cases were reviewed by hand. The final set has:

- 114 test cases
- 29 users
- 2,233 history sessions
- 5 memory types crossed with 11 scenarios

The agent model was Claude Opus 4.6 and the memory model was GPT 5.6 sol. Results are averaged over three repeats.

### Results

| Setup                        | Pass rate |
| ---------------------------- | --------- |
| No memory (baseline)         | 22.3%     |
| Mem0                         | 43.9%     |
| MemCurrent                   | 68.4%     |
| Gold injection (upper bound) | 78.6%     |

"Gold injection" hands the agent the correct memory directly, so it works as a ceiling. Databricks says MemCurrent closes more than 80% of the gap between no memory and that ceiling. Among the memory backends tested, it reports the lowest mean latency for MemCurrent (252 seconds per task) and the lowest mean token use (418K tokens per task). Compared with no memory, Databricks says MemCurrent runs 1.35x faster and costs 1.44x less. Those ratios match the "26% faster" and "31% fewer tokens" in its summary.

## Pass rates in Databricks' internal test

Sort by pass rate to compare the four setups.

| Setup          | Pass rate (%) | Mean token use per task | Mean latency per task (s) | Source                                                                                                                                                                                                                   |
| -------------- | ------------- | ----------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| No memory      | 22.3%         | not stated              | not stated                | Source: [MemCurrent: Designing Persistent Memory for Production Agents (databricks.com), accessed Oct 20, 2026](https://www.databricks.com/blog/memcurrent-designing-persistent-memory-production-agents?ref=zipmex.com) |
| Mem0           | 43.9%         | not stated              | not stated                | Source: [MemCurrent: Designing Persistent Memory for Production Agents (databricks.com), accessed Oct 20, 2026](https://www.databricks.com/blog/memcurrent-designing-persistent-memory-production-agents?ref=zipmex.com) |
| MemCurrent     | 68.4%         | 418K                    | 252                       | Source: [MemCurrent: Designing Persistent Memory for Production Agents (databricks.com), accessed Oct 20, 2026](https://www.databricks.com/blog/memcurrent-designing-persistent-memory-production-agents?ref=zipmex.com) |
| Gold injection | 78.6%         | not stated              | not stated                | Source: [MemCurrent: Designing Persistent Memory for Production Agents (databricks.com), accessed Oct 20, 2026](https://www.databricks.com/blog/memcurrent-designing-persistent-memory-production-agents?ref=zipmex.com) |

The figures are Databricks' own, and token and latency values appear only for MemCurrent.

31%On Databricks' internal benchmark, MemCurrent triples the agent's pass rate over having no memory, while using 31% fewer tokens and running 26% faster.

Source: databricks.com, Oct 20, 2026 · [Read the source](https://www.databricks.com/blog/memcurrent-designing-persistent-memory-production-agents?ref=zipmex.com)

## What drove the gain

Databricks ran two ablations on the same internal benchmark.

### Memory type

- Episodic memory alone: 35.8%
- Derived memory alone: 66.1%
- Both: 68.4%

Most of the gain comes from derived memory. Databricks says the agent searched episodic memory in about one-third of cases and passed 60% of those. It calls the extra gain from episodic memory small.

### How memory is extracted

- Online tools alone: 53.9%
- Offline dreaming alone: 63.5%
- Both: 66.1%

Background consolidation beat writing memory only on request by nearly 10 points. Databricks reports 66.1% for both "derived memory alone" and "online tools plus dreaming." It does not say whether they are the same run.

## Open-source benchmarks

Databricks also tested on three public benchmarks: LoCoMo, LongMemEval and a 500-sample stratified subset of ConvoMem. Here GPT 5.6 luna served as both agent and memory model, run through LangGraph and the OpenAI Agents SDK with three repeats.

- Average accuracy: MemCurrent 88.1%, full context 87.8%
- Input tokens per question: MemCurrent 8.4K, full context 103K, about 12x fewer
- Latency: similar across backends, 4 to 7 seconds per question

Databricks says MemCurrent beat full context on the two benchmarks with the longest histories. It also says Mem0 did well on these public benchmarks even though it trailed on the internal one.

## What builders can take from it

Databricks reports these findings. It has not shown that they generalise:

- **Distil sessions, don't just store them.** In these tests, raw history alone added about 13 points. Distilled memory added about 44.
- **Run consolidation in the background.** A scheduled pipeline that merges, splits and reconciles memory files did better than relying on the agent to write memory during a task.
- **Give the agent an index.** Each session opens with a short map of what memory holds, and the agent searches from there.
- **Measure against a ceiling.** A gold-injection run shows how much of the possible gain a memory system actually captures, which tells you more than a single pass rate.

## What the numbers do not show

- The internal benchmark, its test cases and the scoring all come from Databricks. The post does not mention a code or dataset release.
- The internal and open-source results used different models (Claude Opus 4.6 with GPT 5.6 sol, against GPT 5.6 luna), so the two sets of scores do not compare directly.
- The public Genie One documentation describes memories that users explicitly ask for or confirm, and says they are private to each user. It does not mention MemCurrent, so the claim that Genie uses MemCurrent rests on Databricks' statement.
- Agent Memory is in Beta, and the Agent memory documentation does not state a release status.

Promotion · ZIPMEX

### Trade perpetual futures on ZIPMEX

135 marketsCrypto · stocks · gold · oil · FXPTS on every tradePTS → ZIPMEX tokens

[See all markets](https://trade.zipmex.com/perps/markets?utm%5Fsource=zipmex-news&utm%5Fcampaign=perps&utm%5Fmedium=article&utm%5Fcontent=story-192620)

135 markets on trade.zipmex.com

Perpetual futures are leveraged derivatives. Prices can move fast and you can lose all of your margin. Not available in every jurisdiction. Not investment advice.