పెద్ద పనిలోని భాగాలను అనేక ఏజెంట్లకు కేటాయించి, వారి కనుగొన్న విషయాలను సేకరించి కలిపే వర్క్‌ఫ్లో ప్రోగ్రామ్‌ను Claude Managed Agents ఇప్పుడు రాయగలదు. ఈ ఫీచర్ బీటాలో ఉంది. పత్రాల ఫోల్డర్‌ను సమీక్షించి, తనిఖీ చేసిన కనుగొన్న విషయాల ఫైల్‌ను తయారు చేయాలనుకునే సాఫ్ట్‌వేర్ బిల్డర్ కోసం డాక్యుమెంట్ చేసిన సెటప్ ఇక్కడ ఉంది.

ఇది Anthropic యొక్క Claude Platform API మరియు CLIను ఉపయోగిస్తుంది. BIG CHANGE ప్రస్తుత డాక్యుమెంటేషన్‌ను సమీక్షించింది; మేము సెటప్‌ను అమలు చేయలేదు లేదా వర్క్‌ఫ్లోను పరీక్షించలేదు.

వర్క్‌ఫ్లో ఏమి చేస్తుంది

ఒక డైనమిక్ వర్క్‌ఫ్లో అనేది ఒక రన్ కోసం ఒక ప్రోగ్రామ్. ఇది పనిని దశలుగా విభజించగలదు, ఏజెంట్ థ్రెడ్‌లను సమాంతరంగా ప్రారంభించగలదు, దశల మధ్య ఫలితాలను పంపగలదు, విఫలమైన శాఖను మళ్లీ ప్రయత్నించగలదు లేదా నిర్వహించగలదు, ఫలితాలను కలపగలదు. ఉదాహరణకు, మొదటి దశ వేర్వేరు ఫైళ్లను పరిశీలిస్తే, తరువాతి దశ కనుగొన్న విషయాలను సరిపోల్చవచ్చు. ప్రధాన ఏజెంట్ రన్‌ను ప్రారంభిస్తుంది; సర్వర్ దాన్ని నేపథ్యంలో అమలు చేస్తుంది.

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

ప్రారంభించడానికి ముందు

మీకు Claude Console ఖాతా, API కీ, Claude Managed Agents యాక్సెస్ అవసరం. API ఖాతాలకు ఇది డిఫాల్ట్‌గా ప్రారంభించబడి ఉంటుందని Anthropic చెబుతోంది. ఏజెంట్ మరియు వర్క్‌ఫ్లో ఎండ్‌పాయింట్‌లకు managed-agents-2026-04-01 beta హెడర్ అవసరం. Anthropic SDK ఈ హెడర్‌ను ఆటోమేటిక్‌గా సెట్ చేస్తుంది; SDK లేకుండా APIను పిలిస్తే దాన్ని మీరే చేర్చండి.

ప్రస్తుత డాక్యుమెంటేషన్‌లో Managed Agents ఇప్పటికీ బీటాగా గుర్తించబడింది. Anthropic యొక్క విడుదల గమనికలు పబ్లిక్ బీటాకు ఏప్రిల్ 9, 2026, మల్టీ-ఏజెంట్ ఆర్కెస్ట్రేషన్‌కు మే 11, డైనమిక్ వర్క్‌ఫ్లోలకు అక్టోబర్ 9 తేదీలను సూచిస్తున్నాయి. డైనమిక్ వర్క్‌ఫ్లోలు కూడా బీటాలో ఉన్నాయి. తేదీ ముఖ్యం: “1,000 ఏజెంట్లు” అనేది ప్రస్తుతం ఒక్క వర్క్‌ఫ్లో రన్‌కు ఉన్న పరిమితి; ఏకకాలంలో 1,000 ఏజెంట్లను ప్రారంభించే కొత్త సామర్థ్యం కాదు.

ప్లాట్‌ఫారమ్ సెషన్ సంభాషణ చరిత్ర, శాండ్‌బాక్స్ స్థితి, అవుట్‌పుట్‌లను సర్వర్ వైపు నిల్వ చేస్తుంది. Managed Agents ప్రస్తుతం Zero Data Retention లేదా HIPAA Business Associate Agreement కవరేజీకి అర్హం కాదనిAnthropic చెబుతోంది. వర్తించే డేటా నియమాలు, సెటప్‌ను మీ సంస్థ నిర్ధారించేవరకు నియంత్రిత లేదా గోప్యమైన సమాచారాన్ని సెషన్‌లో ఉంచవద్దు.

1. CLI మరియు SDKను ఇన్‌స్టాల్ చేయండి

Anthropic ant CLIను మీ ఆపరేటింగ్ సిస్టమ్‌కు తగిన పద్ధతిలో Managed Agents త్వరిత ప్రారంభ మార్గదర్శిలోని సూచనల ప్రకారం ఇన్‌స్టాల్ చేయండి. ఉదాహరణకు, డాక్యుమెంట్ చేసిన macOS కమాండ్:

Terminal
brew install anthropics/tap/ant

Python కోసం SDKను ఇన్‌స్టాల్ చేసి, API కీని సోర్స్ ఫైల్‌లో ఉంచకుండా మీ ఎన్విరాన్‌మెంట్ ద్వారా అందించండి:

Terminal
pip install anthropic
export ANTHROPIC_API_KEY="your-api-key"

పైన ఉన్న కీ placeholder మాత్రమే. నిజమైన విలువను మీ సాధారణ secret managerలో లేదా రక్షిత ఎన్విరాన్‌మెంట్ కాన్ఫిగరేషన్‌లో ఉంచండి.

2. వర్క్‌ఫ్లోలను ఉపయోగించగల ఏజెంట్‌ను నిర్వచించండి

సృష్టించండి document-reviewer.md. multiagent బ్లాక్ అక్టోబర్‌లో వచ్చిన వర్క్‌ఫ్లో రకాన్ని ప్రారంభిస్తుంది. సబ్‌ఏజెంట్లను నిలిపివేస్తే కాన్ఫిగర్ చేసిన delegation మార్గం స్పష్టమవుతుంది: ఈ ఏజెంట్ ఒక్కసారి సబ్‌ఏజెంట్‌కు అప్పగించకుండా డైనమిక్ వర్క్‌ఫ్లోలను ఉపయోగిస్తుంది.

YAML
---
name: document-reviewer
model: claude-sonnet-5-5
tools:
  - type: agent_toolset_20260401
multiagent:
  type: multiagent_20261001
  subagents:
    type: disabled
  workflows:
    type: enabled
---

You review documents for a user-defined checklist.

When a request contains more than 20 independent files, use a dynamic workflow.
Make one phase that checks the files independently and a later phase that
reconciles duplicate findings. Do not infer missing facts. Save the final
machine-readable results to report.json and a concise explanation to summary.md.
Include the source filename and a short evidence excerpt for every finding.
If a file cannot be read or a worker fails, record that file as unresolved;
do not silently omit it. The final response must report the number of files
reviewed, unresolved files, and whether every output file was written.

Threshold మరియు సమీక్ష సూచనలు మీ విధాన నిర్ణయాలు; Anthropic డిఫాల్ట్‌లు కావు. పని మరియు తప్పుల ఖర్చుకు అనుగుణంగా వాటిని మార్చండి. claude-sonnet-5-5 అనేది ఉదాహరణ model ID; మీ ఖాతాకు ప్రస్తుతం అందుబాటులో ఉండి, బడ్జెట్‌లో సరిపోయే మోడల్‌ను ఎంచుకోండి.

ఏజెంట్‌ను సృష్టించి, తిరిగి వచ్చిన IDను భద్రపరచండి:

Terminal
ant apply document-reviewer.md

CLI ఏజెంట్ IDను చూపించి claude-lock.jsonలో నమోదు చేస్తుంది. Managed Agents పునర్వినియోగించగల ఏజెంట్ నిర్వచనాన్ని (మోడల్, సూచనలు, టూల్స్) సెషన్ నడిచే ఎన్విరాన్‌మెంట్ నుండి వేరు చేస్తుంది.

3. శాండ్‌బాక్స్‌ను కాన్ఫిగర్ చేయండి

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

YAML
# environment.yaml
name: document-review
config:
  type: cloud
  networking:
    type: limited
    allow_package_managers: true

దీన్ని ant apply environment.yamlతో అమలు చేయండి; దాని ID కూడా claude-lock.json. ఏజెంట్‌కు నెట్‌వర్క్ యాక్సెస్ అవసరమైతే, అవసరమైన హోస్ట్‌లను మాత్రమే allowed_hostsలో జాబితా చేయండి. పరిమిత నెట్‌వర్కింగ్‌లో ఈ హోస్ట్ జాబితా Managed Agents వెబ్ శోధన మరియు fetch టూల్స్‌ను కూడా పరిమితం చేస్తుంది. ప్యాకేజ్ మేనేజర్‌లను అనుమతించే సెట్టింగ్ వెబ్‌సైట్‌లను allowlistకు జోడించదు.

మొదటి రన్ కోసం చిన్న, సున్నితమైన సమాచారం లేని ఫోల్డర్‌ను, అవసరమైన టూల్స్‌ను మాత్రమే ఉపయోగించండి. అంతర్నిర్మిత ఏజెంట్ టూల్‌సెట్‌లో shell మరియు ఫైల్ ఆపరేషన్లు ఉన్నాయి; టూల్స్ జోడిస్తే ఏజెంట్ చేయగల పనులు పెరగవచ్చు. బాహ్య సిస్టమ్‌లు లేదా credentialsకు యాక్సెస్ ఇచ్చే ముందు డాక్యుమెంట్ చేసిన permission policy మరియు sandbox controlsను తనిఖీ చేయండి.

4. సెషన్ ప్రారంభించి పరిమితమైన పనిని పంపండి

Python SDKతో ఏజెంట్ మరియు ఎన్విరాన్‌మెంట్ IDలను ఉపయోగించి సెషన్ సృష్టించండి:

Python
import anthropic

client = anthropic.Anthropic()
session = client.beta.sessions.create(
    agent="AGENT_ID_FROM_CLAUDE_LOCK",
    environment_id="ENVIRONMENT_ID_FROM_CLAUDE_LOCK",
    title="Small document review",
)
print(session.id)

రెండు ID placeholderలను claude-lock.jsonలోని విలువలతో భర్తీ చేయండి. తరువాత session event stream ద్వారా స్పష్టమైన పనిని పంపండి. ఈవెంట్ పంపే ముందు స్ట్రీమ్‌ను ప్రారంభించండి; అప్పుడు రన్, దాని పురోగతిని జరుగుతున్నప్పుడే చూడవచ్చు:

Python
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": (
                    "Review each Markdown file in /review-set for a missing "
                    "owner, deadline, or acceptance criterion. Quote evidence; "
                    "do not infer missing details. Reconcile duplicate findings "
                    "and write /mnt/session/outputs/report.json plus "
                    "/mnt/session/outputs/summary.md. In report.json, use "
                    "a files array with one record per input: path, status "
                    "(reviewed or unresolved), and findings; each finding has "
                    "a check, evidence excerpt, and source location. Include "
                    "input, reviewed, and unresolved counts."
                ),
            }],
        }],
    )
    open_runs = {}
    run_results = {}
    for event in stream:
        if event.type == "workflow_run.created":
            open_runs[event.workflow_run_id] = event.name
            print(f"Run started: {event.name}")
        elif event.type == "workflow_run.status_ended":
            run_results[event.workflow_run_id] = event.result.type
            open_runs.pop(event.workflow_run_id, None)
            print(f"Run ended: {event.result.type}")
        elif event.type == "workflow_run.error":
            print(f"Run error: {event.error}")
        elif event.type == "agent.message":
            for block in event.content:
                if block.type == "text":
                    print(block.text)
        elif event.type == "session.status_idle":
            if event.stop_reason.type == "end_turn" and not open_runs:
                break

    # Inspect the child threads associated with completed workflow runs.
    for thread in client.beta.sessions.threads.list(session.id):
        if thread.workflow_run_id in run_results:
            print(f"Thread {thread.id}: {thread.status}")
            for thread_event in client.beta.sessions.threads.events.list(
                thread.id, session_id=session.id
            ):
                if thread_event.type == "session.error":
                    print(f"Thread error: {thread_event}")

మీరు కాన్ఫిగర్ చేసిన session input విధానం ఫైళ్లను /review-setవద్ద అందుబాటులో ఉంచుతుందని ఈ ఉదాహరణ భావిస్తుంది. ఏజెంట్‌ను సమీక్షించమని అడిగే ముందు డాక్యుమెంట్ చేసిన input విధానంతో ఫైళ్లను సెషన్ sandboxలో ఉంచండి. అవుట్‌పుట్‌లను /mnt/session/outputs/కింద రాయమని ఏజెంట్‌కు చెప్పండి; Managed Agents ఫైల్ డాక్యుమెంటేషన్ సెషన్ పరిధిలోని ఫైళ్లను జాబితా చేయడం, డౌన్‌లోడ్ చేయడం ఎలాగో వివరిస్తుంది. Python SDKలో డాక్యుమెంట్ చేసిన readback ఆకారం:

Python
files = client.beta.files.list(
    scope_id=session.id,
    betas=["managed-agents-2026-04-01"],
)
for report in files:
    if report.filename == "report.json":
        content = client.files.download(report.id)
        content.write_to_file("report.json")
        break

సెషన్ idle అయిన తర్వాత ఫైల్ కనిపించడానికి కొన్ని సెకన్లు పట్టవచ్చు; కనిపించకపోతే కొద్దిసేపటి తర్వాత మళ్లీ జాబితా చేయండి. సురక్షితమైన మొదటి పరీక్ష కోసం, ఆశించిన ఫలితాలను మీరు చేతితో పరిశీలించగల కొన్ని పత్రాలతో test folder తయారు చేయండి. నమూనా prompt సమీక్ష పనిని నిర్వచిస్తుంది; ప్రతి సమస్యను ఏజెంట్ కనుగొంటుందని హామీ ఇవ్వదు.

ఆడిట్ చేయగలిగేంత కఠినంగా output contract ఉండాలి. ఉదాహరణకు:

JSON
{
  "files": [
    {
      "path": "requirements.md",
      "status": "reviewed",
      "findings": [
        {
          "check": "deadline",
          "evidence_excerpt": "...",
          "source_location": "requirements.md, section 2"
        }
      ]
    }
  ],
  "input_count": 1,
  "reviewed_count": 1,
  "unresolved_count": 0
}

ఇది మీ workflow కోసం సూచించిన schema; Anthropic అందించిన schema కాదు. పరిష్కారం కాని లేదా చదవలేని ఫైళ్లను రికార్డులుగా ఉంచండి, ఫలితం లేకపోవడాన్ని సజావైన సమీక్షగా ఎవరూ భావించకూడదు.

5. రన్ మరియు దాని అవుట్‌పుట్‌ను తనిఖీ చేయండి

Workflow ప్రారంభమైనప్పుడు event stream workflow_run.createdఅని నివేదిస్తుంది; ఇందులో run ID, workflow ప్రకటించిన దశలు ఉంటాయి. సరిపోలే workflow_run.status_endedవచ్చే వరకు ప్రతి run IDను తెరిచి ఉంచేలా నమూనా రూపొందించబడింది; ప్రాథమిక సెషన్ idle కావడం ఒక్కటే నేపథ్య workflow ముగిసిందని నిర్ధారించదు. ప్రాథమిక stream child-thread స్థితిని సంక్షిప్తం చేస్తుంది; ప్రతి thread యొక్క సొంత event జాబితాలో దాని సందేశాలు, లోపాలు ఉంటాయి. నమూనా threadలను workflow_run_id ఆధారంగా జాబితా చేసి session.error eventsను చూపిస్తుంది. అయిపోయిన retryలు ( retry_status.type == "exhausted"తో సహా) లేదా ఇతర child errors కోసం ఆ eventsను పరిశీలించి, ప్రభావిత ఫైళ్లను unresolvedగా గుర్తించండి.

“completed” అనే పదాన్ని కాకుండా output fileనే deliverableగా పరిగణించండి. Thread పని విఫలమైనా లేదా thread సృష్టించలేకపోయినా run completed తో ముగియవచ్చని Anthropic స్పష్టంగా హెచ్చరిస్తుంది. report.json తెరిచి ప్రతి input fileకు findings లేదా స్పష్టమైన unresolved status ఉందా, evidence excerpts సరైన source fileను చూపుతున్నాయా, మీరు ఇచ్చిన ఫైళ్ల సంఖ్యలతో గణనలు సరిపోతున్నాయా చూడండి. పెద్ద corpusలో workflow వాడే ముందు చిన్న test folderను మీ అంచనా ఫలితాలతో పోల్చండి.

మీ client disconnect అయితే, కొత్త event stream తెరిచిన తర్వాత వెలువడిన eventsనే పంపుతుంది. డాక్యుమెంట్ చేసిన event-type filters, paginationతో పాత session eventsను జాబితా చేసి run స్థితిని మళ్లీ నిర్మించండి. Child threadలు ఇంకా పని చేస్తుండవచ్చు; ప్రాథమిక agent idle అయిందని run ముగిసిందని అనుకోకండి. గమనించిన అన్ని runలు ముగిసిన తర్వాత session పరిధిలోని ఫైళ్లను జాబితా చేసి, డాక్యుమెంట్ చేసిన Files APIతో /mnt/session/outputs/report.json మరియు summary.md డౌన్‌లోడ్ చేయండి. అందించిన ప్రతి ఫైల్‌కు reviewed లేదా unresolved రికార్డు ఉందా, లెక్కలు సరిపోతున్నాయా తనిఖీ చేయండి. నమూనా event loop నివేదికను తానే డౌన్‌లోడ్ చేయదు లేదా validate చేయదు.

రూపకల్పనను మార్చే పరిమితులు

Anthropic యొక్క workflow-run పరిమితులు ప్రస్తుతం ఒక రన్‌లో ఒకేసారి పనిచేసే గరిష్ఠంగా 64 workflow threadలను పేర్కొంటున్నాయి; అయితే API ఆ concurrencyకి హామీ ఇవ్వదు, విలువ మారవచ్చు. 1,000-agent పరిమితి మొత్తం రన్ జీవితకాలంలో ప్రారంభించిన ఏజెంట్లను లెక్కిస్తుంది; ఒకేసారి ఉన్న threadల సంఖ్య కాదు. ఆ మొత్తం పరిమితి చేరిన తర్వాత మరొక ఏజెంట్‌ను ప్రారంభించమని workflow కోరితే, రన్ thread_limit_errorతో ముగుస్తుంది; విఫల ఏజెంట్ల retryలు అదనపు threadలను సృష్టించవచ్చు.

ఒక రన్ డిఫాల్ట్‌గా 24 గంటలు ఉంటుంది; దాని ఏజెంట్ తక్కువ వ్యవధిని నిర్దేశిస్తే అంతకంటే తక్కువ. మీ client కోసం వేచి ఉన్న సమయం కూడా లెక్కలోకి వస్తుంది; pause చేసిన రన్‌కూ timeout కావచ్చు. ఒక సెషన్‌లో idle runలతో సహా డిఫాల్ట్‌గా 10 open runలు ఉంటాయి. సెషన్ usage budget అన్ని workflow ఏజెంట్లకు వర్తిస్తుంది; దాన్ని చేరితే budget పెంచే వరకు లేదా తొలగించే వరకు open runలు pause అవుతాయి. చిన్న పని యూనిట్లను ప్రణాళిక చేయండి, checkpointsను ఫైళ్లలో భద్రపరచండి, సమీక్షించామని నటించకుండా పూర్తికాని అంశాలను reconciliation దశ నివేదించేలా చేయండి.

విఫలమైతే workflow_run.error మరియు ప్రభావిత threadను పరిశీలించండి. program_error అంటే workflow code లేదా child విఫలమై ఉండవచ్చు; thread_limit_error 1,000-agent పరిమితిని సూచిస్తుంది; timeout_error రన్ వ్యవధి పరిమితిని సూచిస్తుంది. రన్ session budget చేరితే కొనసాగించడానికి budgetను పెంచండి లేదా తొలగించండి. Workflow ఆపాలంటే దాని runలను ఆపమని ప్రాథమిక ఏజెంట్‌ను అడగండి; session turnను interrupt చేయడం ఒక్కటే run-cancellation ఆదేశం కాదు.

ఖర్చు

Anthropic ధరల డాక్యుమెంటేషన్ ఎంచుకున్న మోడల్ token రేట్లతో పాటు session runtime కోసం Managed Agentsకు ఛార్జీ చేస్తుంది: నడుస్తున్న session గంటకు $0.08. Session status runningగా ఉన్నప్పుడు runtime పేరుకుపోతుంది; idle, rescheduling, terminated సమయం లెక్కలోకి రాదు. Workflow runకు ప్రత్యేక రుసుము లేదు; కానీ threadల token వినియోగం sessionలో భాగంగా బిల్లు అవుతుంది. Session లోపల ప్రారంభించిన వెబ్ శోధనకు 1,000 శోధనలకు $10గా పేర్కొంటారు. ఖచ్చితమైన మొత్తం model, input/output tokens, tools, session వ్యవధిపై ఆధారపడుతుంది; 1,000-agent పరిమితి నుంచి అంచనా వేయకుండా Consoleలో usage చూడండి.

ఆచరణలో, కొన్ని ఫైళ్లతో ప్రారంభించి, workflow output ప్రతి ఫైల్‌ను లెక్కలోకి తీసుకుంటోందో నిర్ధారించి, విఫల threadలను పరిశీలించి, సమీక్ష విధానం మరియు ఖర్చు ఆమోదయోగ్యంగా ఉన్నప్పుడే inputను విస్తరించండి. Managed workflows asynchronous parallel పనిని సమన్వయం చేస్తాయి; అవి findingsను ధృవీకరించవు.

పెద్ద మార్పు

అక్టోబర్ 9 నుంచి Managed Agents ఏజెంట్, server అనేక agent threadలు మరియు దశల్లో అమలు చేసే workflow programను రాయగలదు. ప్రధాన సెషన్ పురోగతిని అనుసరిస్తుండగా, బిల్డర్లు పరిమితమైన, audit చేయగల fan-out కోసం ఈ మార్గాన్ని వాడవచ్చు. ఫీచర్ ఇంకా బీటాలోనే ఉంది; ప్రచురించిన పరిమితులు ప్రతి రన్ గరిష్ఠ concurrency చేరుతుందని లేదా సరైన findings ఇస్తుందని హామీ ఇవ్వవు.

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

  • Claude Managed Agents అవలోకనం — బీటా స్థితి, API header, యాక్సెస్, stateful సెషన్‌లు, టూల్స్, డేటా నిల్వ పరిమితులు.
  • Claude Managed Agents ప్రారంభ మార్గదర్శి — CLI, SDK, agent/environment సెటప్, సెషన్ సృష్టి, event-stream ఉదాహరణ.
  • Multiagent orchestration — dynamic workflowsను ప్రారంభించడం; workflows, subagents మధ్య ఎంపిక.
  • Workflow runs — రన్ ఈవెంట్‌లు, ఫలితాల అర్థం, రికవరీ, budgets, డాక్యుమెంట్ చేసిన పరిమితులు.
  • Session threads — రన్‌కు సంబంధించిన child threadలను జాబితా చేయడం, వాటి event history చదవడం.
  • Session files — మౌంట్ చేసిన inputలు, output paths, session పరిధి ఫైల్ జాబితా, downloads.
  • Claude Platform విడుదల గమనికలు — అక్టోబర్ 9, 2026 dynamic-workflows నవీకరణ మరియు బీటా కాన్ఫిగరేషన్.
  • Claude Platform ధరలు — token billing మరియు session-runtime రేట్లు.