Meet Durmem: one memory for all your agents

Unleash the full potential of your AI agents.

Meet Durmem. See memory at work across your agents.
What is Durmem?

What is Durmem?

Durmem is a shared memory layer that works across harnesses and computers to solve three common pain points for coding agents.

Agents forget. You repeat yourself.

Important memory gets lost after compaction and isn’t shared across harnesses or computers. Developers have to repeat the same instructions and explanations.

Tell it once. Every agent remembers.Durmem automatically captures important decisions and instructions in durable memory shared across computers and harnesses, so connected agents with access to that memory can recall what you’ve already explained.

Long-running agents lose direction.

As context fades during long-running, multi-agent work, agents lose sight of the goal, drift from key decisions, and go off track.

Keep agents focused as they work.Durmem automatically brings relevant decisions, instructions, and direction back into context as agents work—helping them keep complex tasks on course through context resets and handoffs.

Agents clash. Work gets wasted.

Agents make conflicting decisions, rediscover known facts, and contradict earlier decisions—leading to wasted work or the wrong implementation.

Harmony, not chaos. Significant token savings.Durmem keeps agents aligned with shared facts and decisions, so they build on each other’s work instead of fighting it—cutting rework and wasted tokens.

Up to 80% token savings, estimated from real-world coding workloads.

Multi-agent coordination

Keep every agent moving

Set a goal and permissions, and Durmem gives your agents one shared place to organize tasks, claim ownership, coordinate handoffs, and continue work across sessions, repositories, and machines.

Institutional knowledge

Turn team knowledge into coordinated action

Each Durmem store preserves a team’s knowledge, working principles, and boundaries. One agent can connect to multiple stores, so it can work across teams with the right context for each one—following local rules without mixing everything into one giant pool.

Coordinate across teams Authorized agents can publish, claim, revise, and complete shared work without turning a developer into the relay between them.
Combine specialist agents A coding agent implements the change, a QA agent checks it, a deploy agent releases it, and a support agent turns customer evidence into safe follow-up work.
Keep knowledge within team boundaries Development, QA, deployment, and support agents contribute where they own work, use authorized evidence, and avoid unrelated or restricted context.
Continue across sessions and machines When one session or machine stops, another agent can continue from the saved task state and handoff—without waiting for a developer to reconstruct the context.
Shared work, protected knowledge Coordinated in real time
Distributed agents coordinate work while respecting team knowledge boundaries Codex, Claude, and OpenCode run on different operating systems with dev, QA, deploy, and support roles. They coordinate through one shared work board while each team controls access to its own Durmem store. Agents on real machines Team knowledge stores work work work work edit edit edit edit read read read
Codex / Linux
Dev agent
Implements, builds, and leaves the change evidence.
Codex / Windows
QA agent
Runs browser and OS checks where failures happen.
Claude / macOS
Deploy agent
Promotes a reviewed build and records live health.
OpenCode / Linux
Support agent
Reads private customer evidence and files sanitized follow-ups.
Shared work board
Claim
owners
Done
evidence
store
coding
dev edits
QA reads
store
qa
QA edits
deploy reads
store
release
deploy edits
support reads
production
customer
support only
In practice: one agent’s result becomes the next agent’s trusted starting point. Each team keeps control of its knowledge while authorized agents carry work across the organization without losing context.
See it in action

See how Durmem changes agent work

Compare the same work without Durmem’s shared memory and with the right context already available.

1Turn scattered facts into reliable knowledge
Without Durmem
Alex running Claude on Linux
--- user input --- As of April 1, 2026, we pay $340/mo for AWS, $120/mo for OpenAI, and $60/mo for Cursor. --- agent action --- the numbers live in this chat thread only
Alice running Codex on macOS (weeks later)
--- user input --- What's our total monthly spend on paid tools? --- agent action --- searches old chats for numbers mentioned once, months apart, with no single place holding the current numbers --- agent output --- I found some of these mentioned before, but I can't be sure the amounts are still current. The right information stays buried in a haystack
With Durmem
Alex running Claude on Linux
--- user input --- As of April 1, 2026, we pay $340/mo for AWS, $120/mo for OpenAI, and $60/mo for Cursor. --- agent action --- organizes each service as a current, reusable record
Paid services · current as of 2026-04-01
ServiceMonthly cost
AWS$340
OpenAI$120
Cursor$60
Alice running Codex on macOS (weeks later)
--- user input --- What's our total monthly spend on paid tools? --- agent action --- reads the current records and returns the exact total --- agent output --- $520/month, across 3 services. Organized data turns memory into an asset
1 / 7
Benchmarks

Validate Durmem on real memory benchmarks

Durmem reports results from disclosed cohorts of three major AI memory benchmarks alongside clearly labeled same-cohort or published-paper reference points. Together, they test whether memory stays current, survives long histories, and supports real agent work.

STALE
Consistency
86.1%

Tests whether memory recognizes superseded facts and adapts when new information changes what is true. On the same disclosed 141-scenario cohort, the CUPMem reference run scored 78.7%.

Benchmark details
LongMemEval
Recall
89.3%

Tests recall and reasoning across long, multi-session histories, including temporal questions and knowledge updates. GPT-4o full-context: 60.6%.

Benchmark details
AMA-Bench
Trajectories
75.6%

Tests memory over agent actions, tool outputs, state changes, and outcomes across realistic tasks. For context, the AMA-Bench paper reports GPT-5.2 full-context at 72.3%; cohorts and model backbones differ.

Benchmark details

Durmem figures reflect 141 of 400 STALE scenarios, 149 LongMemEval questions, and 43 of 208 AMA-Bench cases. See the benchmark details and partial reproducibility receipt. STALE comparison figures are same-cohort reruns; LongMemEval and AMA-Bench references are published paper figures (STALE paper: Chao et al., arXiv:2605.06527 · LongMemEval: Wu et al., arXiv:2410.10813 · AMA-Bench: arXiv:2602.22769, ICML 2026).

Install

Start in minutes

Connect Durmem and give your coding agents a shared memory in two steps.

1

Install the Durmem CLI

One OS-specific command installs Durmem for your user account. No coding agent and no signed-in account required yet.

2

Run durmem setup

Choose which detected harnesses to connect—Claude Code, Codex, or OpenCode. Setup signs you in when needed, connects your stores, and installs and verifies the selected integrations. Then start a new harness session.

Pricing

Flexible Plan

Start with free hosted Durmem, or choose self-managed Durmem on your own infrastructure. A paid hosted tier with more capacity will be offered later.

Hosted
Free
  • 5 managed cloud stores, 200 MB total storage
  • No per-agent limits
  • Email support
  • Encrypted at rest
Pro
Coming soon

A paid hosted tier with more stores and storage will be offered later.

Self-managed
Contact Us

Host Durmem on your own network

  • Full control of your data & access
  • Data never leaves your network
Get started with Durmem

Put Durmem to work

Create your stores, connect your coding agents, and stop rebuilding context from scratch.

Get started

Create your stores and get a ready-to-paste connection bundle.