Markdown edition

# Review a Claude Managed Agent memory store with one Dream

> Run one manual Claude Dream over authorized sessions, inspect and correct its separate memory store, then attach only reviewed memory to a later session.

By BIG CHANGE Editorial

Published: 2026-10-20T01:54:53.933Z
Updated: 2026-10-20T01:54:53.933Z
Canonical: https://bigchange.ai/blog/claude-managed-agents-reviewed-dream-memory-guide

![Conceptual charcoal illustration of one reviewer at a desktop monitor comparing two separate areas of indistinct text; one line on the right is orange.](https://bigchange.ai/api/media/file/claude-dream-reviewed-memory-hero-v1.png)
AI-generated conceptual illustration by BIG CHANGE.

A Claude Managed Agent can carry notes between sessions in a memory store, but those notes can become repetitive or outdated. Anthropic's [Dreams research preview](https://platform.claude.com/docs/en/managed-agents/dreams) can read one store and past sessions, then write a separate proposed store. This guide shows a developer with the required access how to run **one manual Dream**, check what it retained, and attach only accepted memory to a later session.

This is a documentation-based procedure, checked against Anthropic's current Managed Agents guides on 20 October 2026. BIG CHANGE did not run a Dream, inspect a real output, test account access or measure cost or improvement. The procedure ends with one reviewed store used by one later session. It does not set up a recurring run, grading or automatic memory sharing with other agents.

## The big change

- **What changed:** A Dream can synthesize an existing memory store and 1–100 selected session transcripts into a new memory store without changing the input.
- **Why it matters:** The separate output gives its owner a chance to compare new or condensed notes with the original evidence before another session reads them.
- **What to watch:** Dreams needs separate research-preview access. A completed job produces a candidate store, not an approved set of facts or preferences.

## Before you start

You need a Claude Console account and API key, an existing Managed Agent with the agent toolset, an environment, and access to the [Managed Agents beta described in the quickstart](https://platform.claude.com/docs/en/managed-agents/quickstart). You also need **separate Dreams research-preview access**. The Managed Agents beta alone does not establish that entitlement. Confirm it through the [Dreams access route](https://platform.claude.com/docs/en/managed-agents/dreams) before sending the request.

Choose one existing memory store and 1–100 real, relevant, completed sessions whose content you are authorized to process together. If you have transcripts but no store, the [memory guide](https://platform.claude.com/docs/en/managed-agents/memory#create-a-memory-store) shows how to create an empty one. Give it a scoped name and description. The agent needs its documented toolset to read or write an attached store. Attach the store when creating an input session; a running session cannot gain a store later. Use `read_write` only if the agent needs to save memory. The default is `read_write`, so specify `read_only` for material the agent should only consult. Check the returned resource's `mount_path` rather than guessing it.

Review the proposed input with the people responsible for its data. A session may contain customer material, private project details or untrusted text. Anthropic warns that an attacker-controlled prompt or tool result can contaminate a writable store and affect later sessions. Decide who can inspect the Dream output and which facts may persist. Keep a human-accessible record of the source sessions, prior memory content and decisions you make during review.

Run the command examples in a Bash-compatible shell with cURL that supports `--fail-with-body` and Python 3 for the correction and final session check. PowerShell uses different quoting and environment-variable syntax, so its commands need adaptation. Install Anthropic's Python SDK with `pip install anthropic` as the [quickstart](https://platform.claude.com/docs/en/managed-agents/quickstart#install-the-sdk) shows. Set and **export** `ANTHROPIC_API_KEY` through your normal secret-handling method so both cURL and the Python SDK can use it. Set `store_id`, `session_a`, `session_b`, `agent_id` and `environment_id` to IDs returned by your **own** workspace. The examples use two sessions; use one or more real session IDs, up to 100. Keep the key out of shared logs and drafts. The exact beta headers matter: direct **memory-store** calls use `agent-memory-2026-07-22` alone; session calls use `managed-agents-2026-04-01`; Dream calls use both `managed-agents-2026-04-01` and `dreaming-2026-04-21`. The current specific memory guide says combining the first two on a memory-store request returns HTTP 400. Anthropic's SDK sets the relevant headers automatically.

## Run and track one Dream

1. Read the input store and the selected sessions first. Record their real IDs and the memory paths and contents that matter to your task. State a narrow curation aim, such as preserving documented project conventions and dropping superseded notes. Keep the store and sessions available until the run finishes. The Dream can fail if an input store is archived or deleted, or an input session is deleted, while it runs.
2. Create the Dream with the existing store and sessions. The documented model in this example is `claude-opus-5-5`; [Anthropic lists other supported preview models](https://platform.claude.com/docs/en/managed-agents/dreams#create-a-dream). Optional `instructions` can steer broad synthesis and are capped at 4,096 characters. They are not a reliable way to edit a particular sentence in a memory.

```bash
curl -sS --fail-with-body https://api.anthropic.com/v1/dreams \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21" \
  -H "content-type: application/json" \
  --data '{
    "inputs": [
      {"type": "memory_store", "memory_store_id": "'"$store_id"'"},
      {"type": "sessions", "session_ids": ["'"$session_a"'", "'"$session_b"'"]}
    ],
    "model": "claude-opus-5-5",
    "instructions": "Preserve documented project conventions; drop superseded or one-off notes."
  }'
```

3. Save the returned `drm_...` ID as `dream_id`. A `pending` response means the job was created and queued. Poll **that same ID** until its status is `completed`, `failed` or `canceled`:

```bash
curl -sS --fail-with-body "https://api.anthropic.com/v1/dreams/$dream_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
```

Read `status`, `outputs`, `usage` and `error` in the response. `outputs` can be empty while the Dream is pending or briefly running; that alone is no reason to submit another job. Anthropic says runs can take minutes to hours and bills them at standard API token rates for the selected model. The `usage` field reports tokens, but your final charge depends on actual usage and pricing. There is no measured cost or completion time for this guide.

## Inspect and correct the separate store

4. After `status` reaches `completed`, take the `memory_store_id` from the `memory_store` entry in `outputs` and set it as `output_store_id`. List that store's memories with the **memory** beta header, then retrieve the individual memories you need to examine. Follow all pages of the listing and inspect the full content, including paths and hashes. You can also review the store in the Console.

```bash
curl -sS --fail-with-body "https://api.anthropic.com/v1/memory_stores/$output_store_id/memories?path_prefix=/" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: agent-memory-2026-07-22"

curl -sS --fail-with-body "https://api.anthropic.com/v1/memory_stores/$output_store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: agent-memory-2026-07-22"
```

5. Compare each retained or synthesized claim with its relevant source session and the old store. Check whether a statement is actually supported, whether it belongs to the right user or project, and whether a newer instruction contradicts it. Look for secrets, personal data and instructions smuggled in through untrusted material. Record a keep, correct or discard decision for each consequential memory. The Dream changes **neither** the input store nor the source sessions; only the reviewed output should move forward.

For a targeted correction, first retrieve the output memory's current `content_sha256`. Submit its actual `mem_id`, fresh hash and corrected content through the [documented memory update](https://platform.claude.com/docs/en/managed-agents/memory#update-a-memory). A hash mismatch means another write occurred: read again, resolve the difference, then retry against the new hash. The following syntax shows that precondition. Enter your reviewed correction as `corrected_content` through a JSON encoder; this example uses Python 3 to escape its content safely.

```bash
python3 -c 'import json,os; print(json.dumps({"content": os.environ["corrected_content"], "precondition": {"type": "content_sha256", "content_sha256": os.environ["mem_sha"]}}))' > correction.json

curl -sS --fail-with-body -X POST "https://api.anthropic.com/v1/memory_stores/$output_store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: agent-memory-2026-07-22" \
  -H "content-type: application/json" \
  --data-binary @correction.json
```

Set and export `corrected_content` and `mem_sha` before encoding, inspect `correction.json`, and keep it within the same private data boundary as the memory. Remove the local copy under your retention policy after the readback. Re-read every edited memory. A store holds up to 10,000 memories, each at most 100 kB. New-memory writes fail at the store limit, although existing memories remain readable and editable. Scope or safely prune a crowded store before depending on a new write.

## Attach only accepted memory to a later session

6. Once the output passes review, create a **new** session with that store. This example attaches it as `read_only`, which suits a check that should not change the reviewed record. If the agent needs to add memories later, grant `read_write` deliberately and review those later writes too.

```bash
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data '{
    "agent": "'"$agent_id"'",
    "environment_id": "'"$environment_id"'",
    "resources": [
      {"type": "memory_store", "memory_store_id": "'"$output_store_id"'", "access": "read_only"}
    ]
  }'
```

Check the new session's returned resources for the intended store ID and its actual `mount_path`. Save its returned session ID as `new_session_id` and export that shell variable so Python can read it. Write a plain-language question about one retained fact whose source you verified, then set and export it as `memory_question`. Anthropic's [quickstart message flow](https://platform.claude.com/docs/en/managed-agents/quickstart#create-your-first-session) opens an event stream, sends a `user.message`, prints `agent.message` text and stops at `session.status_idle`. Use that documented interface to send your question and read the answer:

```bash
python3 - <<'PY'
import os
from anthropic import Anthropic

client = Anthropic()
session_id = os.environ["new_session_id"]
question = os.environ["memory_question"]

with client.beta.sessions.events.stream(session_id) as stream:
    client.beta.sessions.events.send(
        session_id,
        events=[{"type": "user.message", "content": [{"type": "text", "text": question}]}],
    )
    for event in stream:
        if event.type == "agent.message":
            for block in event.content:
                if block.type == "text":
                    print(block.text, end="")
        elif event.type == "session.status_idle":
            print()
            break
PY
```

Compare the streamed answer with both the stored text and the original session. A plausible answer is not enough if it cannot be traced to that evidence. Record the Dream ID, accepted output store ID, comparison decisions, new session ID and result. Keep the input store until the replacement has passed this check.

If creation returns an access or validation error, check the research-preview entitlement, exact input IDs and session count before changing the request. If a run is still pending or running, keep polling its ID. A `failed` or `canceled` run can leave a partial output store; inspect the error and do not attach that store as approved memory. If a later session cannot use the accepted memory, check the resources and mount path on **that session**. An attached store cannot be added to a session already running.

Memory changes create versions. Anthropic says ordinary versions are retained for 30 days, with some recent versions of a live memory kept longer. Deleting a current memory does **not** remove its retained history. To restore an older retained version, read it and update the live memory or recreate a deleted one; there is no separate restore call. Export history you need before its retention period ends and use the documented redaction route for sensitive historical content. Archiving a store is one-way, makes it read-only and prevents new attachment. Deleting a store permanently removes its memories and versions. Make either retention decision under the data owner's policy, after the later session is verified.

For an earlier, distinct Managed Agents task, see [our parallel document-review guide](https://bigchange.ai/blog/claude-managed-agents-parallel-document-review-guide). Our [Hy Memory 2.0 coverage](https://bigchange.ai/blog/hy-memory-2-sdk-chat-work-coding-context) concerns a separate memory SDK and its own scoped recall workflow.

## Sources & further reading

- Anthropic's [Dreams guide](https://platform.claude.com/docs/en/managed-agents/dreams) documents research-preview access, inputs, create and poll requests, statuses, separate output, billing and failure behavior. Its broader statement about memory-store beta headers conflicts with the current specific memory guide; use the latter for direct memory-store calls.
- Anthropic's [memory guide](https://platform.claude.com/docs/en/managed-agents/memory) documents store creation, session attachment, the memory-specific header, listing, hash-protected edits, versions and retention. It warns about writable-store contamination and irreversible archive and deletion.
- Anthropic's [Managed Agents quickstart](https://platform.claude.com/docs/en/managed-agents/quickstart) explains the account, API key, agent, environment and session prerequisites. None of these pages establishes an observed run or quality gain for this guide.

## Sources

- [Anthropic Dreams](https://platform.claude.com/docs/en/managed-agents/dreams) — Research-preview access, one input store and 1–100 sessions, create/poll/status/output behavior, supported models, optional instructions, billing and errors. Its generic memory-store header statement conflicts with the current specific memory guide; follow the latter for direct memory-store requests. No run or outcome was observed.
- [Anthropic Using agent memory](https://platform.claude.com/docs/en/managed-agents/memory) — Specific direct memory-store beta header, creation and attachment, access and mount paths, list/retrieve/hash-protected edit, limits, version retention, redaction and archive/delete consequences. Warns about untrusted content contaminating writable memory; it does not validate Dream output.
- [Anthropic Managed Agents quickstart](https://platform.claude.com/docs/en/managed-agents/quickstart) — Console/API-key, agent, environment and session setup prerequisites. Managed Agents access does not itself prove Dreams research-preview entitlement.
- [BIG CHANGE: Build a Claude workflow that reviews documents in parallel](https://bigchange.ai/blog/claude-managed-agents-parallel-document-review-guide) — Contextual Managed Agents coverage of a different parallel document-review task. Related distinct, not a dated continuation or evidence for Dream results.
- [BIG CHANGE: Hy Memory 2.0 gives agents three ways to keep context](https://bigchange.ai/blog/hy-memory-2-sdk-chat-work-coding-context) — Contextual separate SDK and scoped recall coverage. It does not establish Anthropic Dream behavior and is not an In this story parent.