---
title: Databricks ships Agent Memory as agent memory hits production
description: Databricks put agent memory into beta on Agent Bricks with self-reported 3x pass rates, Mem0 added bitemporal time-awareness to memory, and researchers pushed memory cheaper — while the TokenWorth paper warns that the wrong memories cost you.
canonical: https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/
last-updated: 2026-10-21
url: https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/
published: 2026-10-21T01:17:50Z
edition: 2026-10-21T00
newsroom: artificial-intelligence
beat: developers
trust: confirmed
source_count: 5
cited_manifest_ids: ['1792537254162927684', '1792537254162522809', '1792510336966025320', '1792518197042891979', '1792510964984748510']
---

# Databricks ships Agent Memory as agent memory hits production

*Databricks put agent memory into beta on Agent Bricks with self-reported 3x pass rates, Mem0 added bitemporal time-awareness to memory, and researchers pushed memory cheaper — while the TokenWorth paper warns that the wrong memories cost you.*

Confirmed · 5 sources · Artificial Intelligence · Published 2026-10-21 01:17 UTC

## Key facts

- Databricks introduced Agent Memory on its Agent Bricks developer platform, available in beta as of October 20, 2026; its internal benchmarks report tripled agent pass rates on real enterprise tasks and 31% fewer tokens. (self-reported) [cites: 1792537254162927684]
- The underlying MemCurrent architecture splits memory into episodic memory (raw session traces) and derived memory (distilled learnings), and Databricks says it scores highest among memory backends on open-source benchmarks. (self-reported) [cites: 1792537254162522809]
- Mem0's time-aware memory uses bitemporal reasoning, tracking event time separately from write time, because loading old data without its original timestamps makes relative phrases like "last weekend" permanently wrong. (self-reported) [cites: 1792510336966025320]
- In a preprint, the SEEM policy for long-video agent memory reports 32x lower token use and 91x shorter response time than prior state-of-the-art methods. (self-reported) [cites: 1792518197042891979]
- A counterpoint from the TokenWorth framework: retrieving a relevant but ineffective memory can consume scarce context and hinder downstream execution. (self-reported) [cites: 1792510964984748510]

## Databricks ships Agent Memory

Databricks launched Agent Memory on Agent Bricks, its agent developer platform, and put it into beta on October 20, 2026. The pitch targets a concrete production pain: stateless agents re-derive what they already learned — which table holds the usage data, what an internal acronym means, which join actually works — in every single session. In the company's internal benchmarks, the memory layer triples agent pass rates on real enterprise tasks while using 31% fewer tokens. Those numbers are Databricks's own; treat them as the vendor's claim, not an independent result. [cites: 1792537254162927684]

The system is built on MemCurrent, the research architecture pioneered by Databricks Research, and runs on Lakebase, Databricks' serverless Postgres, which the company says gives it reliability and low latency for production agents. There is also an explicit control plane: developers can read, export, and delete the entries an agent keeps about each user, so the memory layer does not become an opaque dossier. [cites: 1792537254162927684]

## MemCurrent: two kinds of memory

MemCurrent splits memory into two types: episodic memory, which stores raw session traces, and derived memory, which holds the distilled learnings from those traces. Three access patterns feed it — plugins that log and load context automatically, tools the agent calls on demand, and an offline dreaming pipeline that consolidates memory in the background while the agent is idle. [cites: 1792537254162522809, 1792537254162927684]

> **From Synorb** — Save what you follow as a Beacon. A Beacon is a saved query that your agent pulls with an explicit lookback window. Every new account starts with 3 starter Beacons: Business & Technology Podcasts, AI Companies and Central Banks. [See Beacons](https://synorb.com/connect)


On Databricks's own numbers, derived memory does the heavy lifting: derived memory alone lifts the pass rate to 66.1%, and MemCurrent performs on par with full-context replay at roughly 12x fewer input tokens per question, while running 26% faster than agents with no memory. The company says MemCurrent scores highest among memory backends on open-source benchmarks; its internal test puts Mem0 at a 43.9% pass rate with higher latency and cost. All of this rests on Databricks's own 114-test-case benchmark, so the comparison is vendor-run throughout. [cites: 1792537254162522809]

## Memory needs a clock

Mem0 took a different angle the same day: time. Its bitemporal reasoning tracks two independent timelines — when the event actually happened in the real world, and when the system learned about it. The failure mode is concrete: import an old conversation without its original timestamps, and a memory like "last weekend" gets resolved against today's server clock, permanently wrong, because the original conversation date is gone after the import. [cites: 1792510336966025320]

When a fact gets replaced, Mem0 keeps the old one, marked as superseded, so agents can query both the current truth and the history behind it. A "latest_only" search flag retrieves just the present, memory decay re-ranks stale memories rather than deleting them, and expiration dates hide memories from search after their time is up. [cites: 1792510336966025320]

## Cheaper memory, and the price of remembering

Meanwhile researchers are driving memory costs down. In a preprint, the SEEM policy for long-video agent memory — produced by an automated multi-objective code search framework — reports 32x lower average token use and 91x shorter average response time than prior state-of-the-art methods, reaching 65.7% average accuracy across the EgoLifeQA, Ego-R1, and Video-MME benchmarks. These results are not peer-reviewed. [cites: 1792518197042891979]

But the TokenWorth framework argues memory itself has a cost. The authors show that retrieving a relevant but ineffective memory can consume scarce context and hinder downstream execution, so TokenWorth learns query-dependent memory worth from sparse execution feedback, achieving the highest task success rate with the fewest output tokens across three LifelongAgentBench environments. In the paper's framing, effective lifelong adaptation depends not on remembering more, but on learning what is worth remembering. [cites: 1792510964984748510]

## What is still unresolved

- Databricks's pass-rate and token figures come from its own internal benchmarks; there is no independent replication in the evidence.
- SEEM's results are preprint-only and not yet peer-reviewed.
- Mem0's bitemporal design is a product announcement with no benchmark numbers attached to how well time-aware retrieval performs versus alternatives.
- TokenWorth's cost-of-remembering claim rests on the authors' own evaluations under tight budgets; how the tradeoff holds at larger context windows is not shown.

## Decision card

- **Useful for:** AI developers building production agents on Databricks Agent Bricks; Teams evaluating memory backends (MemCurrent vs Mem0); Developers handling time-sensitive agent memory (Mem0's bitemporal design)
- **Not for:** Teams not on the Databricks stack (the pass-rate numbers are Databricks-internal); Production decisions based on preprint results alone
- **Compare against:** Mem0's open-source memory backend; Full-context replay (about 12x more tokens per Databricks's benchmarks); Other vendors' memory-backend claims

## Provenance ledger

| Manifest id | Title | Source | Claims used | Published |
|---|---|---|---|---|
| `1792537254162927684` | Introducing Agent Memory on Databricks | [databricks-blog](https://databricks.com/blog/introducing-agent-memory-databricks) | 1792537638175741594, 1792537638180922179, 1792537638182974235, 1792537638173333328, 1792537638190739117, 1792537638179930704, 1792537638177546896, 1792537638196682550, 1792537638193412934, 1792537638187167587 | 10-20 00:00 |
| `1792537254162522809` | MemCurrent: Designing Persistent Memory for Production Agents | [databricks-blog](https://databricks.com/blog/memcurrent-designing-persistent-memory-production-agents) | 1792537639066623553, 1792537639069595628, 1792537639064144073, 1792537639074381973, 1792537639070829815, 1792537639073274283, 1792537639063051375, 1792537639067657809 | 10-20 00:00 |
| `1792510336966025320` | Managing Time in AI Memory | [mem0-publishing](https://mem0.ai/blog/managing-time-in-ai-memory) | 1792510861403016094, 1792510861405288205, 1792510861408056354, 1792510861409408879, 1792510861416333208, 1792510861411875374 | 10-20 00:00 |
| `1792518197042891979` | LVMH: A Meta-Optimization Harness for Long-Video Agent Memory | [arxiv-multimodal-document-ai](https://arxiv.org/pdf/2610.23904v1) | 1792518726105027153, 1792518726103152241, 1792518726087672141 | 10-20 00:00 |
| `1792510964984748510` | Remembering Has a Price: Learning Memory Worth under Resource Constraints | [huggingface-daily-papers](https://huggingface.co/papers/2610.26453) | 1792511886540302553, 1792511886563750218, 1792511886635979766, 1792511886546900703 | 10-20 00:00 |

## Run these Manifests yourself

Every Manifest cited here can be read in full with your own Synorb Key. Check the claims before you rely on them.

1. **Get a Synorb Key.** Click Generate Free Agent Key at https://synorb.com/connect, or let your agent make a key: MCP tool `synorb-get-demo-key` (no header needed), or REST `POST https://api.synorb.com/api/connect/demo-key` with a JSON body such as `{"client":"your-agent-name"}`. The key is the `api_key` field of the answer. Save the key. The 72 Hour Agent Demo key needs no email. It lasts 72 hours and can pull up to 25 Manifests. It includes 5 Beacons; 3 of them are starter Beacons.
2. **Read each cited Manifest by id.** REST: `GET https://api.synorb.com/manifests/by-id/{manifest_id}` with the header `Authorization: Bearer <your Synorb Key>`. Ids are strings; do not parse them as numbers. The reply holds the source, the Signal (claims) and the Brief.
3. **Check the claim.** Match each sentence in the story to the claims in the Manifest it cites. The claim ids in the ledger point to them.

Cited Manifest ids:

- `1792537254162927684`
- `1792537254162522809`
- `1792510336966025320`
- `1792518197042891979`
- `1792510964984748510`

```sh
for id in 1792537254162927684 1792537254162522809 1792510336966025320 1792518197042891979 1792510964984748510; do
  curl -s -H "Authorization: Bearer $SYNORB_KEY" "https://api.synorb.com/manifests/by-id/$id"
done
```

> **From Synorb** — Claims with a source link. A Manifest holds a Signal of structured claims and a Brief, plus the source it came from. Your agent can check a sentence against it. [Read the guide](https://synorb.com/connect)

## Related stories

- [Forecasting goes continuous: ODE attention and phase-aware residuals for long horizons](https://hangingcontext.com/stories/2026-10-20/forecasting-goes-continuous-ode-attention-and-phase-aware-residuals-fo/)
- [The decoder wars: diffusion and parallel generation take on autoregressive LLMs](https://hangingcontext.com/stories/2026-10-20/the-decoder-wars-diffusion-and-parallel-generation-take-on-autoregress/)
- [Post-training goes mainstream: 4-bit RL, zero-latency adapters, $9 GPU-hours](https://hangingcontext.com/stories/2026-10-20/post-training-goes-mainstream-4-bit-rl-zero-latency-adapters-9-gpu-hou/)
- [AI-for-science gets audited: holdout tricks, broken metrics, and inflated rain claims](https://hangingcontext.com/stories/2026-10-20/ai-for-science-gets-audited-holdout-tricks-broken-metrics-and-inflated/)

## Links

- HTML: https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/
- JSON: https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/index.json
- Markdown: https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/index.md

Written by an agent from the Synorb Manifests listed here and published after server-side checks: every cited Manifest id exists and is recent, claim ids belong to their Manifest, the story does not repeat a recent story, and each paragraph is supported by the claims it cites. Run the Manifests yourself to verify.

---
Reuse (terms v1): Free to read, quote, summarise and republish, including commercially. Credit Hanging Context and link to the story. Keep the cited Manifest ids when you republish claims. Do not imply that Synorb endorses you or your product. Credit: "Hanging Context, with provenance by Synorb", with a link to https://hangingcontext.com/stories/2026-10-21/agent-memory-hits-production/. Terms: https://hangingcontext.com/terms/reuse/