# Using Memory Stores for Cross-Session Persistence in Claude Agents

> Learn how to use memory stores for cross-session persistence in Claude agents. Mount a CMA Memory Store as a virtual file system for shared, persistent data across chat sessions.

- Repository: [Anthropic/cwc-workshops](https://github.com/anthropics/cwc-workshops)
- Tags: deep-dive
- Published: 2026-07-20

---

**Claude Managed Agents (CMA) achieve cross-session persistence by mounting a CMA Memory Store as a virtual file system, allowing agents to read from and write to a shared, persistent repository across independent chat sessions.**

The `anthropics/cwc-workshops` repository demonstrates this architecture through the *Agents that Remember* workshop, showing how persistent memory transforms stateless agents into context-aware collaborators. By attaching the same memory store to multiple sessions via resource flags, developers enable agents to recall past interactions, track preferences, and build cumulative knowledge over time.

## How Memory Stores Enable Cross-Session Persistence

Memory stores function as durable key-value repositories that behave like virtual file systems attached to Claude Managed Agents. Unlike ephemeral session contexts, these stores survive individual session termination, acting as a shared brain between otherwise isolated conversations.

### The Role of Memory Stores

According to the source code in [`agents-that-remember/README.md`](https://github.com/anthropics/cwc-workshops/blob/main/agents-that-remember/README.md), a **memory store** provides persistent storage that agents can interact with at runtime through standard read/write operations. When mounted on multiple sessions, the store creates a bidirectional data flow: Session A writes information that Session B can later retrieve, effectively eliminating the "goldfish memory" limitation of standard chat interfaces.

### Session Resources and Access Control

Sessions connect to memory stores through a **resource descriptor** injected at creation time. As implemented in the `anthropics/cwc-workshops` codebase, this resource is a JSON object specifying the store ID, access level, and system prompt guidance.

The resource descriptor supports two access modes:
- **`read_write`**: Full bidirectional access for active learning and note-taking
- **`read_only`**: Restricted access for consuming distilled knowledge without modification

When a session starts, the system prompt defined in the resource's `prompt` field automatically instructs the agent on when and how to interact with the store, eliminating the need for hard-coded I/O logic in the agent's core implementation.

## Creating and Attaching Memory Stores

The following CLI workflows, derived from [`agents-that-remember/scripts/bootstrap.sh`](https://github.com/anthropics/cwc-workshops/blob/main/agents-that-remember/scripts/bootstrap.sh), demonstrate the complete lifecycle of memory store provisioning.

### Create a Memory Store

First, provision the persistent storage entity using the `ant` CLI:

```bash
MEM=$(ant beta:memory-stores create \
      --name "cwc-memory" \
      --description "Cross-session knowledge for my CwC agent" \
      --format json | jq -r .id)
echo "Memory store ID: $MEM"

```

### Mount the Store on a Session

Attach the store to a new session using the `--resource` flag with a properly formatted JSON descriptor:

```bash
MEM_RESOURCE='{
  "type":"memory_store",
  "memory_store_id":"'"$MEM"'",
  "prompt":"Track which CwC sessions I have attended and any follow-up links.",
  "access":"read_write"
}'

SES=$(ant beta:sessions create \
      --agent "$AGENT" \
      --environment-id "$ENV" \
      --title "First session with memory" \
      --resource "$MEM_RESOURCE" \
      --format json | jq -r .id)

```

### Persist and Retrieve Data

Once mounted, the agent automatically writes data based on the system prompt instructions. You can also manually inspect stored memories:

```bash

# Store data through natural conversation

ant beta:sessions:events send \
    --session-id "$SES" \
    --event '{"type":"user.message","content":[{"type":"text","text":"I attended the CMA talk yesterday – notes at https://example.com/notes/cma"}]}'

# Retrieve all stored memories

ant beta:memory-stores:memories list --memory-store-id "$MEM"

```

## The Dreaming Service for Knowledge Distillation

The **Dreaming Service** provides automated batch processing that compresses raw session transcripts into distilled, curated knowledge stores. As documented in [`agents-that-remember/README.md`](https://github.com/anthropics/cwc-workshops/blob/main/agents-that-remember/README.md), this service runs a Claude model (`claude-opus-4-7`) over historical data to generate refined memory stores without manual curation.

### Running a Dream Job

Create a dream that consumes both a memory store and specific session IDs, outputting a new, optimized store:

```bash
DREAM=$(ant beta:dreams create \
        --model claude-opus-4-7 \
        --input '{"type":"memory_store","memory_store_id":"'"$MEM"'"}' \
        --input '{"type":"sessions","session_ids":["'"$HIST1"','"$HIST2"','"$HIST3"','"$SES"']}' \
        --instructions "Summarize all session content into a concise knowledge base." \
        --format json | jq -r .id)

# Wait for completion, then capture the output store ID

MEM_OUT=$(ant beta:dreams retrieve --dream-id "$DREAM" --format json \
         | jq -r '.outputs[] | select(.type=="memory_store") | .memory_store_id')

```

The distilled store (`$MEM_OUT`) can then be mounted on fresh sessions, providing agents with compact, relevant context rather than raw chat logs.

### Using Distilled Memory in New Sessions

Attach the refined knowledge base to subsequent sessions for improved recall:

```bash
ant beta:sessions create \
    --agent "$AGENT" \
    --environment-id "$ENV" \
    --title "Recall after dreaming" \
    --resource '{"type":"memory_store","memory_store_id":"'"$MEM_OUT"'"}' \
    --format json

```

## Bootstrap Automation

For rapid prototyping, the repository provides [`agents-that-remember/scripts/bootstrap.sh`](https://github.com/anthropics/cwc-workshops/blob/main/agents-that-remember/scripts/bootstrap.sh), which automates the complete setup workflow. This script provisions the Claude Managed Agent, initializes the execution environment, seeds historical sessions, and creates initial memory stores, allowing immediate experimentation with cross-session persistence features.

The bootstrap script also references `agents-that-remember/.env.example` for required API key configuration (`ANTHROPIC_API_KEY`).

## Summary

- **Memory stores** provide virtual file system persistence that survives individual session termination, enabling state sharing across independent Claude agent conversations.
- **Resource descriptors** mount stores onto sessions via the `--resource` flag, specifying `memory_store_id`, `access` level (`read_write` or `read_only`), and contextual `prompt` instructions.
- **Dreaming** automates knowledge compression by running batch jobs over session transcripts to create distilled, refined memory stores optimized for future retrieval.
- The **bootstrap.sh** script in the `anthropics/cwc-workshops` repository automates end-to-end provisioning of agents, environments, and memory stores for immediate development.

## Frequently Asked Questions

### What is a CMA Memory Store?

A CMA Memory Store is a persistent key-value repository exposed as a virtual file system to Claude Managed Agents. According to the `anthropics/cwc-workshops` source code, it allows agents to write data during one session and read it during another, functioning like a hard drive for the agent that survives chat session boundaries.

### How does the dreaming service improve agent memory?

The dreaming service consumes raw session transcripts and existing memory stores as inputs, then uses the `claude-opus-4-7` model to generate a new, distilled memory store. This process compresses verbose conversation history into concise knowledge bases, reducing token consumption while improving retrieval accuracy for future sessions.

### What access levels are available for memory stores?

Memory stores support two access levels defined in the resource JSON: **`read_write`** allows the agent to both store new information and retrieve existing data, while **`read_only`** restricts the agent to consumption only. The access level is set when attaching the store via the `--resource` flag during session creation.

### How do I automate memory store setup?

Use the [`agents-that-remember/scripts/bootstrap.sh`](https://github.com/anthropics/cwc-workshops/blob/main/agents-that-remember/scripts/bootstrap.sh) script from the `anthropics/cwc-workshops` repository. This shell script automates the creation of the agent, environment, memory stores, and seed sessions, requiring only the `ANTHROPIC_API_KEY` environment variable defined in `.env.example` to be configured.