Claude Managed Agent మెమరీ స్టోర్‌లోని గమనికలను సెషన్‌ల మధ్య తీసుకెళ్లగలదు. అయితే అవి పునరావృతం కావచ్చు లేదా పాతబడవచ్చు. Anthropic అందించే Dreams పరిశోధన ముందస్తు రూపం ఒక స్టోర్‌ను, గత సెషన్‌లను చదివి, విడిగా ప్రతిపాదిత స్టోర్‌ను రాయగలదు. అవసరమైన ప్రవేశం ఉన్న డెవలపర్‌కు ఈ గైడ్ ఒక Dreamను చేతితో నడపడం, అది ఉంచిన విషయాలను పరిశీలించడం, ఆమోదించిన మెమరీని మాత్రమే తరువాతి సెషన్‌కు జోడించడం చూపిస్తుంది.

ఇది డాక్యుమెంటేషన్ ఆధారిత విధానం. 20 అక్టోబర్ 2026న Anthropic ప్రస్తుత Managed Agents గైడ్‌లతో తనిఖీ చేశాం. BIG CHANGE ఒక Dreamను నడపలేదు, వాస్తవ అవుట్‌పుట్‌ను చూడలేదు, ఖాతా ప్రవేశాన్ని పరీక్షించలేదు, ఖర్చు లేదా మెరుగుదలను కొలవలేదు. సమీక్షించిన ఒక స్టోర్‌ను ఒక తరువాతి సెషన్ ఉపయోగించడంతో ఈ విధానం ముగుస్తుంది. ఇది పునరావృత నిర్వహణ, మార్కులివ్వడం లేదా ఇతర ఏజెంట్‌లతో ఆటోమేటిక్ మెమరీ భాగస్వామ్యాన్ని ఏర్పాటు చేయదు.

పెద్ద మార్పు

  • ఏమి మారింది: ఇన్‌పుట్‌ను మార్చకుండా, ఉన్న మెమరీ స్టోర్‌ను, ఎంచుకున్న 1–100 సెషన్‌ల ప్రతిలిపులను Dream కొత్త మెమరీ స్టోర్‌గా సమీకరించగలదు.
  • ఇది ఎందుకు ముఖ్యం: విడిగా ఉండే అవుట్‌పుట్ వల్ల, మరో సెషన్ చదవకముందే యజమాని కొత్త లేదా సంక్షిప్త గమనికలను అసలు ఆధారాలతో పోల్చవచ్చు.
  • గమనించాల్సిన విషయం: Dreamsకు పరిశోధన ముందస్తు రూపానికి ప్రత్యేక ప్రవేశం కావాలి. పని పూర్తయితే వచ్చే స్టోర్ ఒక ప్రతిపాదన మాత్రమే; ఆమోదించిన వాస్తవాలు లేదా అభిరుచుల సమూహం కాదు.

ప్రారంభించే ముందు

Claude Console ఖాతా, API కీ, ఏజెంట్ సాధనాల సమూహం ఉన్న Managed Agent, ఒక వాతావరణం, అలాగే త్వరిత ప్రారంభ గైడ్‌లో వివరించిన Managed Agents బీటాకు ప్రవేశం కావాలి. అదనంగా Dreams పరిశోధన ముందస్తు రూపానికి ప్రత్యేక ప్రవేశం కూడా కావాలి. Managed Agents బీటా మాత్రమే ఆ అర్హతను నిరూపించదు. అభ్యర్థన పంపేముందు Dreams ప్రవేశ ప్రక్రియ ద్వారా నిర్ధారించండి.

ఒక ఉన్న మెమరీ స్టోర్‌ను, కలిపి ప్రాసెస్ చేయడానికి మీకు అనుమతి ఉన్న 1–100 వాస్తవ, సంబంధిత, పూర్తయిన సెషన్‌లను ఎంచుకోండి. ప్రతిలిపులు ఉండి స్టోర్ లేకపోతే మెమరీ గైడ్ ఖాళీ స్టోర్‌ను సృష్టించే విధానాన్ని వివరిస్తుంది. పరిమిత పరిధి తెలిసే పేరు, వివరణ ఇవ్వండి. జోడించిన స్టోర్‌ను చదవడానికి లేదా రాయడానికి ఏజెంట్‌కు డాక్యుమెంటేషన్‌లో పేర్కొన్న సాధనాలు కావాలి. ఇన్‌పుట్ సెషన్‌ను సృష్టించేటప్పుడే స్టోర్‌ను జోడించండి; నడుస్తున్న సెషన్‌కు తరువాత జోడించలేరు. read_write ను ఏజెంట్ మెమరీని సేవ్ చేయాల్సి ఉంటేనే వాడండి. డిఫాల్ట్ read_write, కాబట్టి కేవలం చదవాల్సిన సమాచారానికి read_only ను స్పష్టంగా ఇవ్వండి. ఊహించకుండా, తిరిగి ఇచ్చిన వనరులోని mount_path ను తనిఖీ చేయండి.

ప్రతిపాదిత ఇన్‌పుట్‌ను దాని డేటాకు బాధ్యత వహించే వారితో సమీక్షించండి. సెషన్‌లో కస్టమర్ సమాచారం, ప్రైవేట్ ప్రాజెక్ట్ వివరాలు లేదా నమ్మలేని టెక్స్ట్ ఉండవచ్చు. దాడిచేసేవారి నియంత్రణలోని ప్రాంప్ట్ లేదా సాధన ఫలితం రాయగల స్టోర్‌ను కలుషితం చేసి తరువాతి సెషన్‌లపై ప్రభావం చూపవచ్చని Anthropic హెచ్చరిస్తుంది. Dream అవుట్‌పుట్‌ను ఎవరు పరిశీలించవచ్చు, ఏ వాస్తవాలను ఉంచవచ్చు అనేది నిర్ణయించండి. మూల సెషన్‌లు, పాత మెమరీ సమాచారం, సమీక్ష నిర్ణయాలను మనుషులు చూడగల రికార్డుగా ఉంచండి.

కమాండ్ ఉదాహరణలను Bashకు అనుకూలమైన షెల్‌లో నడపండి. cURLకు --fail-with-body మద్దతు ఉండాలి; సవరణకు, చివరి సెషన్ తనిఖీకి Python 3 కావాలి. PowerShellలో కోట్స్, వాతావరణ వేరియబుల్స్ సింటాక్స్ భిన్నం కాబట్టి కమాండ్‌లను మార్చాలి. Anthropic Python SDKను pip install anthropic తో ఇన్‌స్టాల్ చేయండి; విధానం త్వరిత ప్రారంభ గైడ్ లో ఉంది. సెట్ చేసి ఎగుమతి చేయండి ANTHROPIC_API_KEY ను మీ సాధారణ రహస్యాల నిర్వహణ పద్ధతితో, తద్వారా cURL, Python SDK రెండూ వాడగలవు. store_id, session_a, session_b, agent_id మరియు environment_id లకు మీ సొంత వర్క్‌స్పేస్ ఇచ్చిన IDలను సెట్ చేయండి. ఉదాహరణలు రెండు సెషన్‌లను వాడతాయి; ఒకటి నుంచి 100 వరకు వాస్తవ సెషన్ IDలు ఇవ్వండి. కీని షేర్ చేసిన లాగ్‌లు, డ్రాఫ్ట్‌లలో ఉంచవద్దు. ఖచ్చితమైన బీటా హెడర్‌లు ముఖ్యం: నేరుగా చేసే మెమరీ-స్టోర్ కాల్‌లు agent-memory-2026-07-22 మాత్రమే వాడతాయి; సెషన్ కాల్‌లు managed-agents-2026-04-01; Dream కాల్‌లు managed-agents-2026-04-01 మరియు dreaming-2026-04-21 రెండూ వాడతాయి. ప్రస్తుత ప్రత్యేక మెమరీ గైడ్ ప్రకారం, మెమరీ-స్టోర్ అభ్యర్థనలో మొదటి రెండింటిని కలిపితే HTTP 400 వస్తుంది. Anthropic SDK అవసరమైన హెడర్‌లను ఆటోమేటిక్‌గా సెట్ చేస్తుంది.

ఒక Dreamను నడిపి అనుసరించండి

  1. ముందుగా ఇన్‌పుట్ స్టోర్, ఎంచుకున్న సెషన్‌లను చదవండి. వాటి నిజమైన IDలు, మీ పనికి ముఖ్యమైన మెమరీ మార్గాలు, సమాచారాన్ని నమోదు చేయండి. డాక్యుమెంట్ చేసిన ప్రాజెక్ట్ పద్ధతులను ఉంచడం, పాతదై భర్తీ అయిన గమనికలను తీసేయడం వంటి పరిమిత సమీకరణ లక్ష్యాన్ని చెప్పండి. నడపడం ముగిసేవరకు స్టోర్, సెషన్‌లను అందుబాటులో ఉంచండి. నడుస్తుండగా ఇన్‌పుట్ స్టోర్‌ను ఆర్కైవ్ చేసినా, తొలగించినా, లేదా ఇన్‌పుట్ సెషన్‌ను తొలగించినా Dream విఫలం కావచ్చు.
  2. ఉన్న స్టోర్, సెషన్‌లతో Dreamను సృష్టించండి. ఈ ఉదాహరణలో డాక్యుమెంట్ చేసిన మోడల్ claude-opus-5-5; Anthropic ఇతర మద్దతున్న ముందస్తు మోడల్‌లను కూడా జాబితా చేస్తుంది. ఐచ్ఛిక instructions సాధారణ సమీకరణ దిశను నిర్దేశించవచ్చు; పరిమితి 4,096 అక్షరాలు. మెమరీలో ఒక నిర్దిష్ట వాక్యాన్ని మార్చడానికి ఇది నమ్మదగిన పద్ధతి కాదు.
Terminal
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."
  }'
  1. తిరిగి వచ్చిన drm_... IDను dream_id గా సేవ్ చేయండి. pending స్పందన అంటే పని సృష్టించి క్యూలో ఉంచారని అర్థం. అదే ID ను స్థితి completed, failed లేదా canceled అయ్యేవరకు పదేపదే చూడండి:
Terminal
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"

స్పందనలో status, outputs, usage మరియు error చదవండి. outputs Dream వేచి ఉన్నప్పుడు లేదా నడుస్తున్న కొద్దిసేపు ఖాళీగా ఉండవచ్చు; అంతమాత్రాన మరో పని పంపవద్దు. Anthropic ప్రకారం నడవడానికి నిమిషాల నుంచి గంటల వరకు పట్టవచ్చు; ఎంచుకున్న మోడల్ సాధారణ API టోకెన్ ధరలు వర్తిస్తాయి. usage ఫీల్డ్ టోకెన్‌లను చెబుతుంది, కానీ చివరి ఛార్జీ వాస్తవ వినియోగం, ధరలపై ఆధారపడుతుంది. ఈ గైడ్ కోసం ఖర్చు లేదా పూర్తి సమయం కొలవలేదు.

ప్రత్యేక స్టోర్‌ను పరిశీలించి సరిచేయండి

  1. ముందుగా status స్థితి completed అయినప్పుడు తీసుకోవాల్సినది memory_store_id ; అది memory_store ఎంట్రీలో ఉంటుంది, ఆ ఎంట్రీ outputs లో ఉంటుంది. దానిని output_store_id గా సెట్ చేయండి. ఆ స్టోర్ మెమరీలను జాబితా చేయడానికి మెమరీ బీటా హెడర్ వాడి, తరువాత పరిశీలించాల్సిన విడివిడి మెమరీలను పొందండి. జాబితాలోని అన్ని పేజీలు చూసి, మార్గాలు, హ్యాష్‌లతో సహా పూర్తి సమాచారాన్ని పరిశీలించండి. Consoleలో కూడా స్టోర్‌ను సమీక్షించవచ్చు.
Terminal
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"
  1. ఉంచిన లేదా సమీకరించిన ప్రతి దావాను సంబంధిత మూల సెషన్, పాత స్టోర్‌తో పోల్చండి. నిజంగా ఆధారం ఉందా, సరైన వినియోగదారు లేదా ప్రాజెక్ట్‌కు చెందినదా, కొత్త సూచన దానిని విరుద్ధం చేస్తుందా చూడండి. రహస్యాలు, వ్యక్తిగత డేటా, నమ్మలేని సమాచారంలో దాచిన సూచనలు వెతకండి. ముఖ్యమైన ప్రతి మెమరీని ఉంచాలా, సరిచేయాలా, తీసేయాలా నమోదు చేయండి. Dream రెండింటిలో దేనినీ మార్చదు : ఇన్‌పుట్ స్టోర్, మూల సెషన్‌లు అలాగే ఉంటాయి; సమీక్షించిన అవుట్‌పుట్ మాత్రమే ముందుకు వెళ్లాలి.

ఒక నిర్దిష్ట సవరణకు ముందుగా అవుట్‌పుట్ మెమరీ ప్రస్తుత content_sha256 పొందండి. దాని నిజమైన mem_id, తాజా హ్యాష్, సరిచేసిన సమాచారాన్ని డాక్యుమెంట్ చేసిన మెమరీ నవీకరణ ద్వారా పంపండి. హ్యాష్ సరిపోకపోతే వేరే రాత జరిగిందని అర్థం: మళ్లీ చదివి, తేడా పరిష్కరించి కొత్త హ్యాష్‌తో ప్రయత్నించండి. కింది సింటాక్స్ ఆ ముందస్తు షరతును చూపిస్తుంది. సమీక్షించిన సవరణను corrected_content గా JSON ఎన్‌కోడర్‌కు ఇవ్వండి; ఈ ఉదాహరణ Python 3తో సమాచారంలోని ప్రత్యేక అక్షరాలను సురక్షితంగా ఎస్కేప్ చేస్తుంది.

Terminal
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

ఎన్‌కోడ్ చేయడానికి ముందు సెట్ చేసి ఎగుమతి చేయండి corrected_content మరియు mem_sha ను, పరిశీలించండి correction.json, దానిని మెమరీ ఉన్న ప్రైవేట్ డేటా హద్దుల్లోనే ఉంచండి. తిరిగి చదివి నిర్ధారించాక మీ నిల్వ విధానం ప్రకారం స్థానిక ప్రతిని తీసేయండి. మార్చిన ప్రతి మెమరీని మళ్లీ చదవండి. స్టోర్‌లో గరిష్ఠంగా 10,000 మెమరీలు, ఒక్కొక్కటి 100 kB వరకు ఉంటాయి. స్టోర్ పరిమితి వద్ద కొత్త మెమరీ రాయడం విఫలమవుతుంది, కానీ ఉన్నవాటిని చదవవచ్చు, మార్చవచ్చు. కొత్త రాతపై ఆధారపడే ముందు పరిధి తగ్గించండి లేదా నిండిన స్టోర్‌ను సురక్షితంగా తగ్గించండి.

ఆమోదించిన మెమరీని మాత్రమే తరువాతి సెషన్‌కు జోడించండి

  1. అవుట్‌పుట్ సమీక్షలో ఉత్తీర్ణమైన తర్వాత ఆ స్టోర్‌తో కొత్త సెషన్‌ను సృష్టించండి. ఈ ఉదాహరణ దాన్ని read_only గా జోడిస్తుంది; సమీక్షించిన రికార్డును మార్చకూడని పరీక్షకు ఇది సరిపోతుంది. ఏజెంట్ తరువాత మెమరీలు జోడించాల్సి ఉంటే ఉద్దేశపూర్వకంగా read_write ఇవ్వండి; తరువాతి రాతలనూ సమీక్షించండి.
Terminal
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"}
    ]
  }'

కొత్త సెషన్ ఇచ్చే వనరుల్లో కావలసిన స్టోర్ ID, వాస్తవ mount_path చూడండి. తిరిగి వచ్చిన సెషన్ IDను new_session_id గా సేవ్ చేసి, Python చదవడానికి ఆ షెల్ వేరియబుల్‌ను ఎగుమతి చేయండి. మూలాన్ని ధృవీకరించిన ఒక ఉంచిన వాస్తవంపై సాధారణ భాషలో ప్రశ్న రాసి, దానిని memory_question గా సెట్ చేసి ఎగుమతి చేయండి. Anthropic త్వరిత ప్రారంభ సందేశ ప్రవాహం ఈవెంట్ స్ట్రీమ్ తెరిచి, user.message పంపి, agent.message టెక్స్ట్‌ను ముద్రించి, session.status_idle వద్ద ఆగుతుంది. ఈ డాక్యుమెంట్ చేసిన ఇంటర్‌ఫేస్‌తో ప్రశ్న పంపి సమాధానం చదవండి:

Terminal
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

స్ట్రీమ్ సమాధానాన్ని నిల్వ చేసిన టెక్స్ట్, మూల సెషన్ రెండింటితో పోల్చండి. ఆ ఆధారంతో ముడిపెట్టలేకపోతే నమ్మదగినట్లు కనిపించే సమాధానం సరిపోదు. Dream ID, ఆమోదించిన అవుట్‌పుట్ స్టోర్ ID, పోలిక నిర్ణయాలు, కొత్త సెషన్ ID, ఫలితం నమోదు చేయండి. ప్రత్యామ్నాయం ఈ పరీక్షలో ఉత్తీర్ణమయ్యేవరకు ఇన్‌పుట్ స్టోర్‌ను ఉంచండి.

సృష్టించేటప్పుడు ప్రవేశం లేదా ధృవీకరణ లోపం వస్తే అభ్యర్థన మార్చేముందు పరిశోధన ముందస్తు అర్హత, ఖచ్చితమైన ఇన్‌పుట్ IDలు, సెషన్ సంఖ్య చూడండి. నడపడం ఇంకా వేచి ఉంటే లేదా కొనసాగుతుంటే అదే IDను పరిశీలిస్తూ ఉండండి. failed లేదా canceled నడపడం పాక్షిక అవుట్‌పుట్ స్టోర్‌ను వదిలేయవచ్చు; లోపాన్ని పరిశీలించి, దాన్ని ఆమోదిత మెమరీగా జోడించవద్దు. తరువాతి సెషన్ ఆమోదించిన మెమరీ వాడలేకపోతే వనరులు, మౌంట్ మార్గం చూడాల్సింది ఆ సెషన్‌లోనే. ఇప్పటికే నడుస్తున్న సెషన్‌కు స్టోర్‌ను జోడించలేరు.

మెమరీ మార్పులు వెర్షన్‌లను సృష్టిస్తాయి. Anthropic ప్రకారం సాధారణ వెర్షన్‌లు 30 రోజులు ఉంటాయి; ప్రస్తుతం ఉన్న మెమరీలో కొన్ని ఇటీవలి వెర్షన్‌లు ఇంకా ఎక్కువ కాలం ఉంటాయి. ప్రస్తుత మెమరీ తొలగించినా నిల్వ చేసిన చరిత్ర తొలగదు . పాత నిల్వ వెర్షన్‌ను పునరుద్ధరించడానికి దానిని చదివి ప్రస్తుత మెమరీని నవీకరించండి లేదా తొలగించినదాన్ని మళ్లీ సృష్టించండి; విడిగా పునరుద్ధరణ కాల్ లేదు. అవసరమైన చరిత్రను నిల్వ కాలం ముగిసేముందే ఎగుమతి చేసి, సున్నితమైన పాత సమాచారానికి డాక్యుమెంట్ చేసిన తొలగింపు విధానాన్ని వాడండి. స్టోర్‌ను ఆర్కైవ్ చేయడం తిరగరానిది; చదవడానికి మాత్రమే ఉంచి కొత్త జోడింపులను ఆపుతుంది. స్టోర్‌ను తొలగిస్తే మెమరీలు, వెర్షన్‌లు శాశ్వతంగా పోతాయి. తరువాతి సెషన్‌ను ధృవీకరించిన తరువాత, డేటా యజమాని విధానం ప్రకారం ఏ నిల్వ నిర్ణయమైనా తీసుకోండి.

మునుపటి వేరే Managed Agents పనికి చూడండి మా సమాంతర డాక్యుమెంట్ సమీక్ష గైడ్. మా Hy Memory 2.0 కథనం వేరే మెమరీ SDK, దాని సొంత పరిమిత పరిధి జ్ఞాపక పునఃపొందే విధానం గురించి.

మూలాలు మరియు మరింత చదవడానికి

  • Anthropic Dreams గైడ్ పరిశోధన ముందస్తు ప్రవేశం, ఇన్‌పుట్‌లు, సృష్టించడం, స్థితి అడగడం, స్థితులు, వేరు అవుట్‌పుట్, బిల్లింగ్, వైఫల్య ప్రవర్తనను వివరిస్తుంది. మెమరీ-స్టోర్ బీటా హెడర్‌లపై సాధారణ వాక్యం ప్రస్తుత ప్రత్యేక మెమరీ గైడ్‌కు విరుద్ధంగా ఉంది; నేరుగా చేసే కాల్‌లకు రెండోదాన్ని అనుసరించండి.
  • Anthropic మెమరీ గైడ్ స్టోర్ సృష్టి, సెషన్ జోడింపు, ప్రత్యేక మెమరీ హెడర్, జాబితా, హ్యాష్ రక్షిత మార్పులు, వెర్షన్‌లు, నిల్వను వివరిస్తుంది. రాయగల స్టోర్ కలుషితం కావడం, తిరగరాని ఆర్కైవ్, తొలగింపుపై హెచ్చరిస్తుంది.
  • Anthropic Managed Agents త్వరిత ప్రారంభ గైడ్ ఖాతా, API కీ, ఏజెంట్, వాతావరణం, సెషన్ అవసరాలను వివరిస్తుంది. ఈ పేజీల్లో ఏదీ ఈ గైడ్ కోసం గమనించిన నడపడం లేదా నాణ్యత పెరుగుదలను నిరూపించదు.