Claude Platform Docs

Sessions

Créer une session
beta.sessions.create(**kwargs) -> BetaManagedAgentsSession
POST/v1/sessions
Lister les sessions
beta.sessions.list(**kwargs) -> SyncBidirectionalPageCursor[BetaManagedAgentsSession]
GET/v1/sessions
Obtenir une session
beta.sessions.retrieve(session_id, **kwargs) -> BetaManagedAgentsSession
GET/v1/sessions/{session_id}
Mettre à jour une session
beta.sessions.update(session_id, **kwargs) -> BetaManagedAgentsSession
POST/v1/sessions/{session_id}
Supprimer une session
beta.sessions.delete(session_id, **kwargs) -> BetaManagedAgentsDeletedSession
DELETE/v1/sessions/{session_id}
Archiver une session
beta.sessions.archive(session_id, **kwargs) -> BetaManagedAgentsSession
POST/v1/sessions/{session_id}/archive
Models
class BetaManagedAgentsAdvisorParams: type: "advisor"; model

Platform advisor roster entry: a model the session's primary thread may consult mid-turn. At most one per roster; the entry occupies the roster name anthropic.advisor.

type: Literal["advisor"]
model: str

A Claude model id. The model must be permitted as an advisor for this agent's model.

minLength1
maxLength256
class BetaManagedAgentsAgentMessagePreview: type: "agent.message"; id
type: Literal["agent.message"]
id: str

The id the buffered agent.message will carry if it is emitted. Matches the event_id on this preview's event_delta events.

class BetaManagedAgentsAgentParams: type: "agent"; id; version

Specification for an Agent. Provide a specific version or use the short-form agent="agent_id" for the most recent version

type: Literal["agent"]
id: str

The agent ID.

minLength1
maxLength128
version: Optional[int]

The specific agent version to use. Omit to use the latest version. Must be at least 1 if specified.

formatint32
class BetaManagedAgentsAgentThinkingPreview: type: "agent.thinking"; id
type: Literal["agent.thinking"]
id: str

The id the buffered agent.thinking will carry if it is emitted. Start-only — no event_delta events follow.

class BetaManagedAgentsAgentWithOverridesParams: type: "agent_with_overrides"; id; mcp_servers; ... # 5 more

Reference to an agent plus optional configuration overrides. Each provided field replaces the agent's value for the caller's use; the agent resource is unchanged.

class BetaManagedAgentsBranchCheckout: type: "branch"; name
type: Literal["branch"]
name: str

Branch name to check out.

minLength1
maxLength255
class BetaManagedAgentsBudgetLimit: type: "limit"; max_list_cost

A hard spend ceiling. The session stops issuing new model requests once the tracked list cost reaches max_list_cost.

type: Literal["limit"]
max_list_cost: BetaMonetaryAmount

Maximum list cost the session may accrue. List price is used regardless of any negotiated discount, so the cap fires at or before the actual charge.

amount: str

Amount in minor units of the currency, as an integer decimal string with no leading zeros: "2500" is $25.00 and "50" is fifty cents. A string rather than a number so no float rounding is ever applied.

currency: BetaCurrency

Uppercase ISO-4217 currency code. USD is the only currency currently supported; the accepted set is closed and grows only when a new currency is priced.

class BetaManagedAgentsCacheCreationUsage: ephemeral_1h_input_tokens; ephemeral_5m_input_tokens

Prompt-cache creation token usage broken down by cache lifetime.

ephemeral_1h_input_tokens: Optional[int]

Tokens used to create 1-hour ephemeral cache entries.

formatint32
ephemeral_5m_input_tokens: Optional[int]

Tokens used to create 5-minute ephemeral cache entries.

formatint32
class BetaManagedAgentsCommitCheckout: type: "commit"; sha
type: Literal["commit"]
sha: str

Full commit SHA to check out.

minLength7
maxLength64
class BetaManagedAgentsDeletedSession: type: "session_deleted"; id

Confirmation that a session has been permanently deleted.

type: Literal["session_deleted"]
id: str
class BetaManagedAgentsDeltaContent: type: "content_delta"; content; index
type: Literal["content_delta"]
content: BetaManagedAgentsTextBlock

A partial element of the content array at index, typed like the element itself — the same shape the buffered agent.message carries in content.

type: Literal["text"]
text: str

The text content.

minLength1
index: Optional[int]

Which entry in the previewed event's content array this fragment lands in. Insert content as that entry when the index is new; append to the existing entry otherwise.

class BetaManagedAgentsDeltaEvent: type: "event_delta"; delta; event_id

An incremental update to an event that is still being streamed. Deltas are best-effort and may stop early; when the buffered event with id == event_id is produced it carries the complete content. A model request that ends early (an error or interrupt) produces no buffered event — its terminal span.model_request_end closes the preview. Only sent on stream connections that opt in via event_deltas; never appears in event history.

type: Literal["event_delta"]
delta: BetaManagedAgentsDeltaContent

One fragment of the previewed event. The delta type is named for the previewed event's field it streams into: agent.message events stream content_delta fragments, each a partial element of the content array.

type: Literal["content_delta"]
content: BetaManagedAgentsTextBlock

A partial element of the content array at index, typed like the element itself — the same shape the buffered agent.message carries in content.

type: Literal["text"]
text: str

The text content.

minLength1
index: Optional[int]

Which entry in the previewed event's content array this fragment lands in. Insert content as that entry when the index is new; append to the existing entry otherwise.

event_id: str

The id of the event being previewed. Matches event.id on the corresponding event_start and the buffered event that reconciles the preview.

type BetaManagedAgentsDeltaType = Literal["agent.message", "agent.thinking"]
One of the following:
"agent.message"
"agent.thinking"
class BetaManagedAgentsFileResourceParams: type: "file"; file_id; mount_path

Mount a file uploaded via the Files API into the session.

type: Literal["file"]
file_id: str

ID of a previously uploaded file.

minLength1
maxLength128
mount_path: Optional[str]

Mount path in the container. Defaults to /mnt/session/uploads/<file_id>.

minLength1
maxLength4096
class BetaManagedAgentsGitHubRepositoryResourceParams: type: "github_repository"; url; authorization_token; ... # 2 more

Mount a GitHub repository into the session's container.

class BetaManagedAgentsMemoryStoreResourceParam: type: "memory_store"; memory_store_id; access; instructions

Parameters for attaching a memory store to an agent session.

type: Literal["memory_store"]
memory_store_id: str

The memory store ID (memstore_...). Must belong to the caller's organization and workspace.

access: Optional[Literal["read_write", "read_only"]]

Access mode for the mounted store. Defaults to read_write. read_only mounts the store as a read-only filesystem.

One of the following:
"read_write"
"read_only"
instructions: Optional[str]

Per-attachment guidance for the agent on how to use this store. Rendered into the memory section of the system prompt. Max 4096 chars.

maxLength4096
type BetaManagedAgentsMultiagent = ...

Resolved multiagent orchestration configuration as returned in API responses.

One of the following:
class BetaManagedAgentsMultiagentCoordinator: type: "coordinator"; agents

Resolved coordinator topology with a concrete agent roster.

class BetaManagedAgentsMultiagent20261001: type: "multiagent_20261001"; advisor; subagents; workflows

Resolved multiagent configuration with three members, each enabled or disabled on its own.

type BetaManagedAgentsMultiagentParams = ...

Multiagent orchestration configuration.

One of the following:
class BetaManagedAgentsMultiagentCoordinatorParams: type: "coordinator"; agents

A coordinator topology: the session's primary thread orchestrates work by spawning session threads, each running an agent drawn from the agents roster.

class BetaManagedAgentsMultiagent20261001Params: type: "multiagent_20261001"; advisor; subagents; workflows

Multiagent configuration with three members, each enabled or disabled on its own. On an update, if the agent's stored multiagent also has type multiagent_20261001, this configuration is merged into the stored one, level by level, instead of replacing it. A key that the update omits keeps its stored value. A key sent as null takes its default, on create as well, so "workflows": null enables workflows. An object sent with a type other than the stored one replaces the stored object, and the keys that it omits take their defaults. A predefined_agents list that is sent replaces the stored list. Every object that is sent needs its type, and an enabled advisor needs its model. Other validation applies to the merged result.

type BetaManagedAgentsMultiagentRosterEntryParams = ...

An entry in a multiagent roster: an agent ID string, a versioned agent reference, or self.

One of the following:
class BetaManagedAgentsOutcomeEvaluationResource: type: "outcome_evaluation"; completed_at; description; ... # 4 more

Evaluation state for a single outcome defined via a define_outcome event.

type: Literal["outcome_evaluation"]
completed_at: Optional[datetime]

When the outcome reached a terminal result. Null while pending/running/evaluating.

formatdate-time
description: str

What the agent should produce.

explanation: Optional[str]

Grader's verdict text from the most recent evaluation. For satisfied, explains why criteria are met; for needs_revision (intermediate), what's missing; for failed, why unrecoverable.

iteration: int

0-indexed revision cycle the outcome is currently on.

formatint32
outcome_id: str

Server-generated outc_ ID for this outcome.

result: str

Current evaluation state. pending before the agent begins work; running while producing or revising; evaluating while the grader scores; satisfied/max_iterations_reached/failed/interrupted are terminal.

class BetaManagedAgentsServerToolUsage: web_fetch_requests; web_search_requests

Cumulative count of server-executed tool invocations, broken down by tool.

web_fetch_requests: Optional[int]

Number of server-executed web fetch requests.

formatint32
web_search_requests: Optional[int]

Number of server-executed web search requests.

formatint32
class BetaManagedAgentsSession: type: "session"; id; agent; ... # 14 more

A Managed Agents session.

class BetaManagedAgentsSessionAgent: type: "agent"; id; description; ... # 8 more

Resolved agent definition for a session. Snapshot of the agent at session creation time.

class BetaManagedAgentsSessionAgentUpdate: mcp_servers; tools

Mid-session agent configuration update. Only tools and mcp_servers are updatable. Full replacement: the provided array becomes the new value. To preserve existing entries, GET the session, modify the array, and POST it back.

type BetaManagedAgentsSessionMultiagent = ...

Resolved multiagent orchestration configuration as returned on a session.

One of the following:
class BetaManagedAgentsSessionMultiagentCoordinator: type: "coordinator"; agents

Resolved coordinator topology with full agent definitions for each roster member.

type: Literal["coordinator"]
agents: List[Agent]

Full agent definitions the coordinator may spawn as session threads.

One of the following:
class BetaManagedAgentsSessionThreadAgent: type: "agent"; id; description; ... # 7 more

Resolved agent definition for a single session_thread. Snapshot of the agent at thread creation time. The multiagent roster is not repeated here; read it from Session.agent.

class BetaManagedAgentsAdvisor: type: "advisor"; model

Platform advisor roster entry: a model the session's primary thread may consult mid-turn.

type: Literal["advisor"]
model: str

The advisor model id.

type BetaManagedAgentsSessionMultiagentSubagents = ...

Whether the agent can spawn session threads.

One of the following:
class BetaManagedAgentsSessionMultiagentSubagentsEnabled: type: "enabled"; inline_agents; predefined_agents

The agent can spawn session threads.

class BetaManagedAgentsMultiagentSubagentsDisabled: type: "disabled"

The agent cannot spawn session threads.

type: Literal["disabled"]
class BetaManagedAgentsSessionMultiagentSubagentsEnabled: type: "enabled"; inline_agents; predefined_agents

The agent can spawn session threads.

type BetaManagedAgentsSessionMultiagentWorkflows = ...

Whether the agent can start workflow runs.

One of the following:
class BetaManagedAgentsSessionMultiagentWorkflowsEnabled: type: "enabled"; inline_agents; predefined_agents

The agent can start workflow runs.

class BetaManagedAgentsMultiagentWorkflowsDisabled: type: "disabled"

The agent cannot start workflow runs.

type: Literal["disabled"]
class BetaManagedAgentsSessionMultiagentWorkflowsEnabled: type: "enabled"; inline_agents; predefined_agents

The agent can start workflow runs.

class BetaManagedAgentsSessionMultiagent20261001: type: "multiagent_20261001"; advisor; subagents; workflows

Resolved multiagent configuration with three members, as copied to the session at creation.

class BetaManagedAgentsSessionStats: active_seconds; duration_seconds

Timing statistics for a session.

active_seconds: Optional[float]

Cumulative time in seconds the session spent in running status. Excludes idle time.

formatdouble
duration_seconds: Optional[float]

Elapsed time since session creation in seconds. For terminated sessions, frozen at the final update.

formatdouble
class BetaManagedAgentsSessionUpdatedEvent: type: "session.updated"; id; processed_at; ... # 4 more

Emitted when an UpdateSession request changed at least one field. Carries only the fields that changed; absent fields were not part of the update. The new configuration applies from the next turn.

class BetaManagedAgentsSessionUsage: active_seconds; cache_creation; cache_read_input_tokens; ... # 4 more

Cumulative token usage for a session across all turns.

class BetaManagedAgentsSessionUsageEvent: type: "session.usage"; id; processed_at; ... # 2 more

Periodic snapshot of the session's cumulative usage and tracked list cost.

class BetaManagedAgentsStartEvent: type: "event_start"; event

Opens a preview of a buffered event. Carries the previewed event's type and id only. Followed by zero or more event_delta events with the same event id, normally concluded by the buffered event carrying that id. If the producing model request ends without that event (an error or interrupt mid-stream), its terminal span.model_request_end closes the preview. Only sent on stream connections that opt in via event_deltas; never appears in event history.

type BetaManagedAgentsStartEventPreview = ...
One of the following:
class BetaManagedAgentsAgentMessagePreview: type: "agent.message"; id
type: Literal["agent.message"]
id: str

The id the buffered agent.message will carry if it is emitted. Matches the event_id on this preview's event_delta events.

class BetaManagedAgentsAgentThinkingPreview: type: "agent.thinking"; id
type: Literal["agent.thinking"]
id: str

The id the buffered agent.thinking will carry if it is emitted. Start-only — no event_delta events follow.

class BetaManagedAgentsSystemContentBlock: type: "text"; text

Content block in a mid-conversation system message. Text-only.

type: Literal["text"]
text: str

The text content.

minLength1
class BetaManagedAgentsSystemMessageEvent: type: "system.message"; id; content; processed_at

A mid-conversation system message event. Carries system-role content that is appended to the session as a role: "system" turn.

type: Literal["system.message"]
id: str

Unique identifier for this event.

content: List[BetaManagedAgentsSystemContentBlock]

System content blocks. Text-only.

type: Literal["text"]
text: str

The text content.

minLength1
processed_at: Optional[datetime]

Timestamp when this system message was processed.

formatdate-time
class BetaManagedAgentsUserToolResultEvent: type: "user.tool_result"; id; tool_use_id; ... # 4 more

Event sent by the client providing the result of an agent-toolset tool execution. Only valid on self_hosted environments, where sandbox-routed tools are executed by the client rather than the server.

SessionsÉvénements

Lister les événements
beta.sessions.events.list(session_id, **kwargs) -> SyncPageCursor[BetaManagedAgentsSessionEvent]
GET/v1/sessions/{session_id}/events
Envoyer des événements
beta.sessions.events.send(session_id, **kwargs) -> BetaManagedAgentsSendSessionEvents
POST/v1/sessions/{session_id}/events
Diffuser les événements en streaming
beta.sessions.events.stream(session_id, **kwargs) -> BetaManagedAgentsStreamSessionEvents
GET/v1/sessions/{session_id}/events/stream

SessionsRessources

Ajouter une ressource de session
beta.sessions.resources.add(session_id, **kwargs) -> BetaManagedAgentsFileResource
POST/v1/sessions/{session_id}/resources
Lister les ressources de session
beta.sessions.resources.list(session_id, **kwargs) -> SyncPageCursor[BetaManagedAgentsSessionResource]
GET/v1/sessions/{session_id}/resources
Obtenir une ressource de session
beta.sessions.resources.retrieve(resource_id, **kwargs) -> ResourceRetrieveResponse
GET/v1/sessions/{session_id}/resources/{resource_id}
Mettre à jour une ressource de session
beta.sessions.resources.update(resource_id, **kwargs) -> ResourceUpdateResponse
POST/v1/sessions/{session_id}/resources/{resource_id}
Supprimer une ressource de session
beta.sessions.resources.delete(resource_id, **kwargs) -> BetaManagedAgentsDeleteSessionResource
DELETE/v1/sessions/{session_id}/resources/{resource_id}

SessionsFils

Lister les fils de session
beta.sessions.threads.list(session_id, **kwargs) -> SyncPageCursor[BetaManagedAgentsSessionThread]
GET/v1/sessions/{session_id}/threads
Obtenir un fil de session
beta.sessions.threads.retrieve(thread_id, **kwargs) -> BetaManagedAgentsSessionThread
GET/v1/sessions/{session_id}/threads/{thread_id}
Archiver un fil de session
beta.sessions.threads.archive(thread_id, **kwargs) -> BetaManagedAgentsSessionThread
POST/v1/sessions/{session_id}/threads/{thread_id}/archive

SessionsFilsÉvénements

Lister les événements d'un fil de session
beta.sessions.threads.events.list(thread_id, **kwargs) -> SyncPageCursor[BetaManagedAgentsSessionEvent]
GET/v1/sessions/{session_id}/threads/{thread_id}/events
Diffuser en streaming les événements d'un fil de session
beta.sessions.threads.events.stream(thread_id, **kwargs) -> BetaManagedAgentsStreamSessionThreadEvents
GET/v1/sessions/{session_id}/threads/{thread_id}/stream