A memory that reorganizes itself. And shows you the diff.

# Anthropic Managed Agents — a hosted async dream.
# Research preview, gated by dreaming-2026-04-21 alongside
# managed-agents-2026-04-01.
dream = client.beta.dreams.create(
    inputs=[
        {"type": "memory_store", "memory_store_id": store_id},
        {"type": "sessions", "session_ids": [session_a, session_b]},
    ],
    model="claude-opus-4-8",
    instructions="Focus on coding-style preferences; ignore one-off debugging notes.",
)

# typically minutes to tens of minutes, driven by input size
while dream.status in ("pending", "running"):
    time.sleep(10)
    dream = client.beta.dreams.retrieve(dream.id)

# the result is a whole second store, not a diff
store = next(o.memory_store_id for o in dream.outputs
             if o.type == "memory_store")

A single hosted job: it clones the store, runs a pipeline you don’t see, and hands back a second store id. Adopting means attaching that store to future sessions; discarding means deleting or archiving it. Nothing tells you which memories moved — that comparison is yours to make.

# blueprint: derivations/dream.yaml — not checked in yet
name: dream
sources:
  sessions:                   # the one bounded run driver
    kind: snapshot
    collections: [sessions]
    statuses: [active]
    max_records: 100          # the "sessions window" slider
    max_tokens: 24000
  store:                      # current keyed memory heads
    kind: current
    collections: [memories]
    statuses: [active]
    keys: [style, tools, domain, workflow]
    max_records: 4
    max_tokens: 6000
  policy:                     # steering, as one guarded current record
    kind: record
    collection: playbooks
    key: curation_policy
    max_tokens: 1500
model: strong
limits:                       # cost is bounded, not open-ended
  max_llm_calls: 2
  max_total_tokens: 40000
  max_wall_s: 120
tasks:
  - id: curate
    use: llm
    with:
      output_schema: { ... records[] with required citations ... }
      prompt: |
        Rebuild one clean memory store for {{entity}} from the evidence below.
        Merge duplicates, replace stale or contradicted entries with the latest
        value, and surface genuinely new insights. Cite only visible UUIDs.

        CURATION POLICY: {{policy.rendered}}
        EXISTING STORE:  {{store.rendered}}
        RECENT SESSIONS: {{sessions.rendered}}
emit:
  from: "{{curate.records}}"
  collection: memories
  type: memory
  keys: [style, tools, domain, workflow]   # the bounded target
  complete: true            # a full rebuild, every key accounted for
  review: required          # stage a draft — never auto-overwrite

This is an implementation blueprint, not a copy-paste-ready checked-in file: a real catalog must include the collection schemas, a complete output schema, the reviewed artifact, package bindings, and tests. The closest runnable pattern in this repository is the reviewed CRM profile rebuild.

# 1 · steer it: the policy is a record, so rewriting it is an ingest
await memseek.records.ingest(
    collection="playbooks", key="curation_policy", type="playbook",
    entity="user:ada",
    text="Focus on coding-style preferences; ignore one-off debugging notes.",
)

# 2 · run it — returns a job id immediately, the worker does the work
queued = await memseek.run_processor("dream", entity="user:ada")

while True:                          # queued → running → succeeded
    job = await memseek.job(queued["job_id"])
    if job.get("successful_run_id"): break
    if job["state"] == "dead": raise RuntimeError(job)
    await asyncio.sleep(0.5)

# …or don't call it at all. A cron trigger dreams nightly, and a write
# trigger dreams once enough new sessions have landed.

In this blueprint, a memory rebuild is an ordinary run. A completed catalog could fire it on demand, on a schedule, or from a write trigger when enough sessions accumulate. Nothing would become live yet: the run would stage a draft.

# 3 · read the audited run — the draft carries its own classified diff
review = await memseek.run(job["successful_run_id"])
candidate = review["run"]["content"]["candidate_set"]

candidate["covered_keys"]   # every key the rebuild accounted for
candidate["divergence"]     # per key: added · changed · removed · unchanged

# 4 · adopt it — atomic, and only if the store hasn't moved underneath
if looks_good(candidate["divergence"]):
    await memseek.promote(
        entity="user:ada",
        source_run_id=job["successful_run_id"],
        artifact="dream_candidate",   # the reviewed contract it must satisfy
    )
# Decline by simply not promoting: the draft stays in the audit trail
# forever, and live memory was never touched.

Promotion re-checks the input heads captured before the Task ran. If the store changed underneath the dream, activation is rejected as stale rather than silently clobbering newer memory — and declining costs nothing, because a draft that is never promoted simply stays a draft.