One read of Claude Developer Platform

 
    To increase tool usage, raise the effort setting. `high` or `xhigh` effort settings show substantially more tool usage in agentic search and coding. You can also adjust your prompt to explicitly instruct the model about when and how to properly use its tools.
 
-8. **Real-time cybersecurity safeguards:** Newly added in Claude Opus 4.7, requests that involve prohibited or high-risk topics may lead to refusals. For legitimate security work such as penetration testing, vulnerability research, or red-teaming, apply to the [Cyber Verification Program](https://claude.com/form/cyber-use-case) to request reduced restrictions. See [Safeguards, warnings, and appeals](https://support.claude.com/en/articles/8241253-safeguards-warnings-and-appeals) for background.
+8. **Real-time cybersecurity safeguards:** Newly added in Claude Opus 4.7, requests that involve prohibited or high-risk topics may lead to refusals. For legitimate security work such as penetration testing, vulnerability research, or red-teaming, apply to the [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) to request reduced restrictions. The application route depends on how you access Claude.
 
 9. **High-resolution image support:** Claude Opus 4.7 is the first Claude model with high-resolution image support. Maximum image resolution is 2,576 pixels on the long edge, up from 1,568 pixels on prior models. This unlocks gains on vision-heavy workloads and is particularly valuable for computer use, screenshot understanding, and document analysis.
 

 * If you use [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool), plan an alternative: it is not available on Claude Opus 5.
 * If your organization has a [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) commitment, note that Priority Tier is not supported on Claude Opus 5.
 * Remove verification and self-check instructions carried over from prompts tuned for earlier models; they cause over-verification on Claude Opus 5.
-* If your product does legitimate security work, apply to the [Cyber Verification Program](https://claude.com/form/cyber-use-case) for access to lower restrictions on cyber content.
+* If your product does legitimate security work, apply to the [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) for access to lower restrictions on cyber content.
 
 #### Migrating from Claude Opus 4.5 or earlier
 

 
 5. **Sampling parameters removed:** Sampling parameters (`temperature`, `top_p`, `top_k`) set to a non-default value are not accepted and return a 400 error.
 
-6. **Cybersecurity safeguards:** Claude Sonnet 5 is the first Sonnet-tier model with real-time cybersecurity safeguards. Requests that involve prohibited or high-risk cybersecurity topics may be refused. Refusals return as a successful HTTP 200 response with `stop_reason: "refusal"`, not an error. See [Safeguards, warnings, and appeals](https://support.claude.com/en/articles/8241253-safeguards-warnings-and-appeals) for background.
+6. **Cybersecurity safeguards:** Claude Sonnet 5 is the first Sonnet-tier model with real-time cybersecurity safeguards. Requests that involve prohibited or high-risk cybersecurity topics may be refused. Refusals return as a successful HTTP 200 response with `stop_reason: "refusal"`, not an error. See [Real-time cyber safeguards on Claude Opus and Sonnet](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) for what the safeguards block and how legitimate security work can apply to the Cyber Verification Program.
 
 #### Migration checklist
 

 
 5. **Pricing:** Claude Haiku 4.5 is priced at $1/$5 per million input/output tokens. Claude Sonnet 5 is priced at $2/$10 per million input/output tokens. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing).
 
-6. **Cybersecurity safeguards:** Claude Sonnet 5 has real-time cybersecurity safeguards. Requests that involve prohibited or high-risk cybersecurity topics may be refused, returned as a successful HTTP 200 response with `stop_reason: "refusal"`. See [Safeguards, warnings, and appeals](https://support.claude.com/en/articles/8241253-safeguards-warnings-and-appeals) for background.
+6. **Cybersecurity safeguards:** Claude Sonnet 5 has real-time cybersecurity safeguards. Requests that involve prohibited or high-risk cybersecurity topics may be refused, returned as a successful HTTP 200 response with `stop_reason: "refusal"`. See [Real-time cyber safeguards on Claude Opus and Sonnet](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) for what the safeguards block and how legitimate security work can apply to the Cyber Verification Program.
 
 #### Migration checklist
 

     <Tabs>
       <Tab title="Gradle">
         ```kotlin
-        implementation("com.anthropic:anthropic-java-mcp:2.53.0")
+        implementation("com.anthropic:anthropic-java-mcp:2.57.0")
         ```
       </Tab>
 

         <dependency>
             <groupId>com.anthropic</groupId>
             <artifactId>anthropic-java-mcp</artifactId>
-            <version>2.53.0</version>
+            <version>2.57.0</version>
         </dependency>
         ```
       </Tab>

   file_resource = await mcp_client.read_resource(
       uri="file:///path/to/data.json",
   )
-  uploaded = await client.beta.files.upload(
+  uploaded = await client.files.upload(
       file=mcp_resource_to_file(file_resource),
   )
   print(uploaded.id)

 
   // As a file upload
   const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
-  const uploaded = await anthropic.beta.files.upload({ file: mcpResourceToFile(fileResource) });
+  const uploaded = await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });
   console.log(uploaded.id);
   ```
 

       file.ContentType = new(mediaType);
   }
 
-  var uploaded = await anthropic.Beta.Files.Upload(new FileUploadParams { File = file });
+  var uploaded = await anthropic.Files.Upload(new FileUploadParams { File = file });
   Console.WriteLine(uploaded.ID);
   ```
 

   if err != nil {
   	log.Fatal(err)
   }
-  uploaded, err := client.Beta.Files.Upload(ctx, anthropic.BetaFileUploadParams{File: fileReader})
+  uploaded, err := client.Files.Upload(ctx, anthropic.FileUploadParams{File: fileReader})
   if err != nil {
   	log.Fatal(err)
   }

       fileField.contentType(resourceFile.mimeType());
   }
 
-  var uploaded = anthropic.beta().files().upload(FileUploadParams.builder()
+  var uploaded = anthropic.files().upload(FileUploadParams.builder()
           .file(fileField.build())
           .build());
 

   # As a file upload
   file_resource = mcp_client.read_resource(uri: "file:///path/to/data.json")
   file = Anthropic::Mcp.resource_to_files(file_resource).first
-  uploaded_file = anthropic.beta.files.upload(file: file)
+  uploaded_file = anthropic.files.upload(file: file)
   puts uploaded_file.id
   ```
 </CodeGroup>

 To analyze your own data files (such as CSV, Excel, or images), upload them through the Files API and reference them in your request:
 
 <Note>
-  This workflow doesn't require a beta header: uploading and downloading files through the Files API and referencing them in `container_upload` blocks are all generally available. The examples on this page send `anthropic-beta: files-api-2025-04-14`, which the API accepts but doesn't require.
+  This workflow doesn't require a beta header: uploading and downloading files through the Files API and referencing them in `container_upload` blocks are all generally available.
 </Note>
 
 The Python environment can process various file types uploaded through the Files API, including:

   FILE_ID=$(curl --fail-with-body -sS https://api.anthropic.com/v1/files \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: files-api-2025-04-14" \
     -F "[email protected]" | jq -r '.id')
 
   # Then use the file_id with code execution

   curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: files-api-2025-04-14" \
     -H "content-type: application/json" \
     -d '{
       "model": "claude-opus-5",

 
   ```bash CLI
   # First, upload a file and capture the file ID
-  FILE_ID=$(ant beta:files upload \
+  FILE_ID=$(ant files upload \
     --file ./data.csv \
     --transform id --raw-output)
 
   # Then use the file_id with code execution
-  ant beta:messages create \
-    --beta files-api-2025-04-14 <<YAML
+  ant messages create <<YAML
   model: claude-opus-5
   max_tokens: 4096
   messages:

   client = anthropic.Anthropic()
 
   # Upload a file
-  file_object = client.beta.files.upload(file=Path("data.csv"))
+  file_object = client.files.upload(file=Path("data.csv"))
 
   # Use the file_id with code execution
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
-      betas=["files-api-2025-04-14"],
       max_tokens=4096,
       messages=[
           {

   const client = new Anthropic();
 
   // Upload a file
-  const fileObject = await client.beta.files.upload({
+  const fileObject = await client.files.upload({
     file: createReadStream("data.csv")
   });
 
   // Use the file_id with code execution
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
-    betas: ["files-api-2025-04-14"],
     max_tokens: 4096,
     messages: [
       {

   AnthropicClient client = new();
 
   // Upload a file
-  var fileObject = await client.Beta.Files.Upload(new FileUploadParams
+  var fileObject = await client.Files.Upload(new FileUploadParams
   {
       File = File.OpenRead("data.csv")
   });

   {
       Model = Model.ClaudeOpus5,
       MaxTokens = 4096,
-      Betas = [AnthropicBeta.FilesApi2025_04_14],
       Messages = [
           new()
           {
               Role = Role.User,
               Content = new([
-                  new BetaTextBlockParam { Text = "Analyze this CSV data" },
-                  new BetaContainerUploadBlockParam { FileID = fileObject.ID }
+                  new TextBlockParam { Text = "Analyze this CSV data" },
+                  new ContainerUploadBlockParam { FileID = fileObject.ID }
               ])
           }
       ],
-      Tools = [new BetaCodeExecutionTool20250825()]
+      Tools = [new CodeExecutionTool20250825()]
   };
 
-  var response = await client.Beta.Messages.Create(parameters);
+  var response = await client.Messages.Create(parameters);
   Console.WriteLine(response);
   ```
 

   }
   defer file.Close()
 
-  fileObject, err := client.Beta.Files.Upload(ctx, anthropic.BetaFileUploadParams{
+  fileObject, err := client.Files.Upload(ctx, anthropic.FileUploadParams{
   	File: file,
   })
   if err != nil {

   }
 
   // Use the file_id with code execution
-  response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 4096,
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(
-  			anthropic.NewBetaTextBlock("Analyze this CSV data"),
-  			anthropic.NewBetaContainerUploadBlock(fileObject.ID),
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(
+  			anthropic.NewTextBlock("Analyze this CSV data"),
+  			anthropic.NewContainerUploadBlock(fileObject.ID),
   		),
   	},
-  	Tools: []anthropic.BetaToolUnionParam{
-  		{OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
+  	Tools: []anthropic.ToolUnionParam{
+  		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
   	},
-  	Betas: []anthropic.AnthropicBeta{
-  		anthropic.AnthropicBetaFilesAPI2025_04_14,
-  	},
   })
   if err != nil {
   	log.Fatal(err)

   AnthropicClient client = AnthropicOkHttpClient.fromEnv();
 
   // Upload a file
-  FileMetadata fileObject = client.beta().files().upload(
+  FileMetadata fileObject = client.files().upload(
       FileUploadParams.builder()
           .file(Path.of("data.csv"))
           .build()

   );
 
   // Use the file_id with code execution
-  BetaMessage response = client.beta().messages().create(
+  Message response = client.messages().create(
       MessageCreateParams.builder()
           .model(Model.CLAUDE_OPUS_5)
-          .addBeta(AnthropicBeta.FILES_API_2025_04_14)
           .maxTokens(4096L)
-          .addUserMessageOfBetaContentBlockParams(List.of(
-              BetaContentBlockParam.ofText(BetaTextBlockParam.builder()
+          .addUserMessageOfBlockParams(List.of(
+              ContentBlockParam.ofText(TextBlockParam.builder()
                   .text("Analyze this CSV data")
                   .build()),
-              BetaContentBlockParam.ofContainerUpload(BetaContainerUploadBlockParam.builder()
+              ContentBlockParam.ofContainerUpload(ContainerUploadBlockParam.builder()
                   .fileId(fileObject.id())
                   .build())
           ))
-          .addTool(BetaCodeExecutionTool20250825.builder().build())
+          .addTool(CodeExecutionTool20250825.builder().build())
           .build()
   );
 

   client = Anthropic::Client.new
 
   # Upload a file
-  file_object = client.beta.files.upload(
+  file_object = client.files.upload(
     file: Pathname("data.csv")
   )
 
   # Use the file_id with code execution
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: Anthropic::Model::CLAUDE_OPUS_5,
-    betas: [Anthropic::AnthropicBeta::FILES_API_2025_04_14],
     max_tokens: 4096,
     messages: [
       {

       }
     ],
     tools: [
-      Anthropic::Beta::BetaCodeExecutionTool20250825.new
+      Anthropic::CodeExecutionTool20250825.new
     ]
   )
 

   client = Anthropic()
 
   # Request code execution that creates files
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
-      betas=["files-api-2025-04-14"],
       max_tokens=4096,
       messages=[
           {

 
 
   # Extract file IDs from the response
-  def extract_file_ids(response: BetaMessage) -> list[str]:
+  def extract_file_ids(response: Message) -> list[str]:
       file_ids: list[str] = []
       for item in response.content:
           if item.type == "bash_code_execution_tool_result":

 
   # Download the created files
   for file_id in extract_file_ids(response):
-      file_metadata = client.beta.files.retrieve_metadata(file_id)
-      file_content = client.beta.files.download(file_id)
+      file_metadata = client.files.retrieve_metadata(file_id)
+      file_content = client.files.download(file_id)
       file_content.write_to_file(file_metadata.filename)
       print(f"Downloaded: {file_metadata.filename}")
   ```

   const client = new Anthropic();
 
   // Request code execution that creates files
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
-    betas: ["files-api-2025-04-14"],
     max_tokens: 4096,
     messages: [
       {

       if (result.type === "bash_code_execution_result") {
         for (const outputBlock of result.content) {
           const [fileMetadata, fileResponse] = await Promise.all([
-            client.beta.files.retrieveMetadata(outputBlock.file_id),
-            client.beta.files.download(outputBlock.file_id)
+            client.files.retrieveMetadata(outputBlock.file_id),
+            client.files.download(outputBlock.file_id)
           ]);
           await writeFile(fileMetadata.filename, await fileResponse.bytes());
           console.log(`Downloaded: ${fileMetadata.filename}`);

   {
       Model = Model.ClaudeOpus5,
       MaxTokens = 4096,
-      Betas = [AnthropicBeta.FilesApi2025_04_14],
       Messages = [new() { Role = Role.User, Content = "Create a matplotlib visualization and save it as output.png" }],
-      Tools = [new BetaCodeExecutionTool20250825()]
+      Tools = [new CodeExecutionTool20250825()]
   };
 
-  var response = await client.Beta.Messages.Create(parameters);
+  var response = await client.Messages.Create(parameters);
 
   // Collect the file IDs from the tool results
   List<string> fileIds = [];

   {
       if (!block.TryPickBashCodeExecutionToolResult(out var toolResult))
           continue;
-      if (!toolResult.Content.TryPickBetaBashCodeExecutionResultBlock(out var result))
+      if (!toolResult.Content.TryPickBashCodeExecutionResultBlock(out var result))
           continue;
       foreach (var output in result.Content)
       {

   // Download each created file
   foreach (var fileId in fileIds)
   {
-      var fileMetadata = await client.Beta.Files.RetrieveMetadata(fileId);
-      using var download = await client.Beta.Files.Download(fileId);
+      var fileMetadata = await client.Files.RetrieveMetadata(fileId);
+      using var download = await client.Files.Download(fileId);
       var downloadStream = await download.ReadAsStream();
       await using var target = File.Create(fileMetadata.Filename);
       await downloadStream.CopyToAsync(target);

   	client := anthropic.NewClient()
   	ctx := context.Background()
 
-  	response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
+  	response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
   		Model:     anthropic.ModelClaudeOpus5,
   		MaxTokens: 4096,
-  		Messages: []anthropic.BetaMessageParam{
-  			anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a matplotlib visualization and save it as output.png")),
+  		Messages: []anthropic.MessageParam{
+  			anthropic.NewUserMessage(anthropic.NewTextBlock("Create a matplotlib visualization and save it as output.png")),
   		},
-  		Tools: []anthropic.BetaToolUnionParam{
-  			{OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
+  		Tools: []anthropic.ToolUnionParam{
+  			{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
   		},
-  		Betas: []anthropic.AnthropicBeta{
-  			anthropic.AnthropicBetaFilesAPI2025_04_14,
-  		},
   	})
   	if err != nil {
   		log.Fatal(err)

   	fileIDs := extractFileIDs(response)
 
   	for _, fileID := range fileIDs {
-  		fileMetadata, err := client.Beta.Files.GetMetadata(ctx, fileID, anthropic.BetaFileGetMetadataParams{})
+  		fileMetadata, err := client.Files.GetMetadata(ctx, fileID)
   		if err != nil {
   			log.Fatal(err)
   		}
 
-  		fileContent, err := client.Beta.Files.Download(ctx, fileID, anthropic.BetaFileDownloadParams{})
+  		fileContent, err := client.Files.Download(ctx, fileID)
   		if err != nil {
   			log.Fatal(err)
   		}

   	}
   // ...
 
-  func extractFileIDs(response *anthropic.BetaMessage) []string {
+  func extractFileIDs(response *anthropic.Message) []string {
   	var fileIDs []string
   	for _, item := range response.Content {
   		switch variant := item.AsAny().(type) {
-  		case anthropic.BetaBashCodeExecutionToolResultBlock:
+  		case anthropic.BashCodeExecutionToolResultBlock:
   			// Collect the file IDs from the tool result
   			for _, file := range variant.Content.Content {
   				if file.FileID != "" {

 
       MessageCreateParams params = MessageCreateParams.builder()
           .model(Model.CLAUDE_OPUS_5)
-          .addBeta(AnthropicBeta.FILES_API_2025_04_14)
           .maxTokens(4096L)
           .addUserMessage("Create a matplotlib visualization and save it as output.png")
-          .addTool(BetaCodeExecutionTool20250825.builder().build())
+          .addTool(CodeExecutionTool20250825.builder().build())
           .build();
 
-      BetaMessage response = client.beta().messages().create(params);
+      Message response = client.messages().create(params);
 
       List<String> fileIds = extractFileIds(response);
 
       for (String fileId : fileIds) {
-          FileMetadata fileMetadata = client.beta().files().retrieveMetadata(fileId);
-          try (HttpResponse fileContent = client.beta().files().download(fileId)) {
+          FileMetadata fileMetadata = client.files().retrieveMetadata(fileId);
+          try (HttpResponse fileContent = client.files().download(fileId)) {
               Files.copy(
                   fileContent.body(),
                   Path.of(fileMetadata.filename()),

       }
   }
 
-  List<String> extractFileIds(BetaMessage response) {
+  List<String> extractFileIds(Message response) {
       List<String> fileIds = new ArrayList<>();
       // Collect the file IDs from the tool results
-      for (BetaContentBlock item : response.content()) {
+      for (ContentBlock item : response.content()) {
           item.bashCodeExecutionToolResult().ifPresent(toolResult -> {
-              if (toolResult.content().isBetaBashCodeExecutionResultBlock()) {
-                  BetaBashCodeExecutionResultBlock result =
-                      toolResult.content().asBetaBashCodeExecutionResultBlock();
-                  for (BetaBashCodeExecutionOutputBlock output : result.content()) {
+              if (toolResult.content().isBashCodeExecutionResultBlock()) {
+                  BashCodeExecutionResultBlock result =
+                      toolResult.content().asBashCodeExecutionResultBlock();
+                  for (BashCodeExecutionOutputBlock output : result.content()) {
                       fileIds.add(output.fileId());
                   }
               }

   ```ruby Ruby
   client = Anthropic::Client.new
 
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: Anthropic::Model::CLAUDE_OPUS_5,
-    betas: ["files-api-2025-04-14"],
     max_tokens: 4096,
     messages: [
       {

   end
 
   extract_file_ids(response).each do |file_id|
-    file_metadata = client.beta.files.retrieve_metadata(file_id)
-    file_content = client.beta.files.download(file_id)
+    file_metadata = client.files.retrieve_metadata(file_id)
+    file_content = client.files.download(file_id)
 
     File.open(file_metadata.filename, "wb") do |f|
       f.write(file_content.read)

 
   // Reuse the container from the first request so the file is still there.
   response2, err := client.Messages.New(ctx, anthropic.MessageNewParams{
-  	Container: anthropic.String(response1.Container.ID),
+  	Container: anthropic.MessageCreateParamsContainerUnion{
+  		OfString: anthropic.String(response1.Container.ID),
+  	},
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 4096,
   	Messages: []anthropic.MessageParam{

 
 ## Data retention
 
-Code execution runs in server-side sandbox containers. Container data, including execution artifacts, uploaded files, and outputs, is retained for up to 30 days. This retention applies to all data processed within the container environment. Files that code execution creates in the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) (retrievable with `client.beta.files.download()`) persist until explicitly deleted.
+Code execution runs in server-side sandbox containers. Container data, including execution artifacts, uploaded files, and outputs, is retained for up to 30 days. This retention applies to all data processed within the container environment. Files that code execution creates in the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) (retrievable with `client.files.download()`) persist until explicitly deleted.
 
 For ZDR eligibility across all features, see [API and data retention](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention).
 

 description: Connect Claude to external tools and APIs. See where tools execute, when Claude calls them, and which tool fits your task.
 ---
 
-Tool use lets Claude call functions that you define or that Anthropic provides. Claude determines when to call a tool based on the user's request and the tool's description. It then returns a structured call that your application executes (client tools) or that Anthropic executes (server tools).
+Tool use (also called function calling) lets Claude call functions that you define or that Anthropic provides. Claude determines when to call a tool based on the user's request and the tool's description. It then returns a structured call that your application executes (client tools) or that Anthropic executes (server tools).
 
 Here's a minimal example using a server tool, the [Web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool), which Anthropic executes for you:
 

   echo "Claude called $(echo "$TOOL_USE" | jq -r '.name') with $(echo "$TOOL_USE" | jq -c '.input')"
 
   # Run the tool, then send the result back in a tool_result block.
+  # Claude uses the result to answer the original question.
   WEATHER="15 degrees Celsius, partly cloudy"
-  FOLLOWUP=$(curl -s https://api.anthropic.com/v1/messages \
+  curl -s https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
     -H "content-type: application/json" \

             {type: "tool_result", tool_use_id: $tool_use_id, content: $weather}
           ]}
         ]
-      }')")
-
-  # Claude uses the result to answer the original question.
-  echo "$FOLLOWUP" | jq -r '.content[] | select(.type == "text") | .text'
+      }')"
   ```
 
   ```bash CLI

         {type: "tool_result", tool_use_id: $tool_use_id, content: $weather}
       ]}
     ]' <<<"$MESSAGES")
-  FOLLOWUP=$(call_api)
 
   # Claude uses the result to answer the original question.
-  jq -r '.content[] | select(.type == "text") | .text' <<<"$FOLLOWUP"
+  call_api
   ```
 
   ```python Python

   # List Anthropic-managed Skills
   curl --fail-with-body -sS "https://api.anthropic.com/v1/skills?source=anthropic" \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
-    -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: skills-2025-10-02" |
-    jq -r '.data[] | "\(.id): \(.display_title)"'
+    -H "anthropic-version: 2023-06-01"
   ```
 
   ```bash CLI
   # List Anthropic-managed Skills
-  ant beta:skills list --source anthropic
+  ant skills list --source anthropic
   ```
 
   ```python Python
   # List Anthropic-managed Skills
-  skills = client.beta.skills.list(source="anthropic")
+  skills = client.skills.list(source="anthropic")
 
   for skill in skills.data:
-      print(f"{skill.id}: {skill.display_title}")
+      print(f"{skill.id}: {skill.display_name}")
   ```
 
   ```typescript TypeScript
   // List Anthropic-managed Skills
-  const skills = await client.beta.skills.list({ source: "anthropic" });
+  const skills = await client.skills.list({ source: "anthropic" });
 
   for (const skill of skills.data) {
-    console.log(`${skill.id}: ${skill.display_title}`);
+    console.log(`${skill.id}: ${skill.display_name}`);
   }
   ```
 
   ```csharp C#
   // List Anthropic-managed Skills
-  var skills = await client.Beta.Skills.List(new SkillListParams { Source = "anthropic" });
+  var skills = await client.Skills.List(new SkillListParams { Source = "anthropic" });
 
   foreach (var skill in skills.Items)
   {
-      Console.WriteLine($"{skill.ID}: {skill.DisplayTitle}");
+      Console.WriteLine($"{skill.ID}: {skill.DisplayName}");
   }
   ```
 
   ```go Go
   // List Anthropic-managed Skills
-  skills, err := client.Beta.Skills.List(ctx, anthropic.BetaSkillListParams{
+  skills, err := client.Skills.List(ctx, anthropic.SkillListParams{
   	Source: anthropic.String("anthropic"),
   })
   if err != nil {

   }
 
   for _, skill := range skills.Data {
-  	fmt.Printf("%s: %s\n", skill.ID, skill.DisplayTitle)
+  	fmt.Printf("%s: %s\n", skill.ID, skill.DisplayName)
   }
   ```
 
   ```java Java
   // List Anthropic-managed Skills
-  SkillListPage skills = client.beta().skills().list(
+  SkillListPage skills = client.skills().list(
       SkillListParams.builder().source("anthropic").build()
   );
 
-  for (SkillListResponse skill : skills.data()) {
-      IO.println(skill.id() + ": " + skill.displayTitle().orElse(""));
+  for (Skill skill : skills.data()) {
+      IO.println(skill.id() + ": " + skill.displayName());
   }
   ```
 

 
   ```ruby Ruby
   # List Anthropic-managed Skills
-  skills = client.beta.skills.list(source: "anthropic")
+  skills = client.skills.list(source: "anthropic")
 
   skills.data.each do |skill|
-    puts "#{skill.id}: #{skill.display_title}"
+    puts "#{skill.id}: #{skill.display_name}"
   end
   ```
 </CodeGroup>

       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
-      -H "anthropic-beta: skills-2025-10-02" \
       -d @- <<'EOF'
   {
     "model": "claude-opus-5",

   }
   EOF
   )
-  jq -r '"stop_reason=\(.stop_reason), blocks=\(.content | length)"' <<<"$response"
   ```
 
   ```bash CLI
   # Create a message with the PowerPoint Skill
-  response=$(ant beta:messages create --format json \
-    --beta skills-2025-10-02 <<'YAML'
+  response=$(ant messages create --format json <<'YAML'
   model: claude-opus-5
   max_tokens: 16000
   container:

       name: code_execution
   YAML
   )
-
-  jq -r '"stop_reason=\(.stop_reason), blocks=\(.content | length)"' <<<"$response"
   ```
 
   ```python Python
   # Create a message with the PowerPoint Skill
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
       max_tokens=16000,
-      betas=["skills-2025-10-02"],
       container={
           "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
       },

 
   ```typescript TypeScript
   // Create a message with the PowerPoint Skill
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
     max_tokens: 16000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{ type: "anthropic", skill_id: "pptx", version: "latest" }],
     },

 
   ```csharp C#
   // Create a message with the PowerPoint Skill
-  var response = await client.Beta.Messages.Create(new MessageCreateParams
+  var response = await client.Messages.Create(new MessageCreateParams
   {
       Model = Model.ClaudeOpus5,
       MaxTokens = 16000,
-      Betas = ["skills-2025-10-02"],
-      Container = new BetaContainerParams
+      Container = new ContainerParams
       {
           Skills =
           [
-              new BetaSkillParams
+              new SkillParams
               {
-                  Type = BetaSkillParamsType.Anthropic,
+                  Type = SkillParamsType.Anthropic,
                   SkillID = "pptx",
                   Version = "latest",
               },

       },
       Messages =
       [
-          new BetaMessageParam
+          new MessageParam
           {
               Role = Role.User,
               Content = "Create a presentation about renewable energy with 5 slides",
           },
       ],
-      Tools = [new BetaCodeExecutionTool20260521()],
+      Tools = [new CodeExecutionTool20260521()],
   });
 
   Console.WriteLine($"stop_reason={response.StopReason?.Raw()}, blocks={response.Content.Count}");

 
   ```go Go
   // Create a message with the PowerPoint Skill
-  response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 16000,
-  	Betas: []anthropic.AnthropicBeta{
-  		anthropic.AnthropicBetaSkills2025_10_02,
-  	},
-  	Container: anthropic.BetaMessageNewParamsContainerUnion{
-  		OfContainers: &anthropic.BetaContainerParams{
-  			Skills: []anthropic.BetaSkillParams{
+  	Container: anthropic.MessageCreateParamsContainerUnion{
+  		OfContainers: &anthropic.ContainerParams{
+  			Skills: []anthropic.SkillParams{
   				{
-  					Type:    anthropic.BetaSkillParamsTypeAnthropic,
+  					Type:    anthropic.SkillParamsTypeAnthropic,
   					SkillID: "pptx",
   					Version: anthropic.String("latest"),
   				},

   			},
   		},
   	},
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(
-  			anthropic.NewBetaTextBlock("Create a presentation about renewable energy with 5 slides"),
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(
+  			anthropic.NewTextBlock("Create a presentation about renewable energy with 5 slides"),
   		),
   	},
-  	Tools: []anthropic.BetaToolUnionParam{
-  		{OfCodeExecutionTool20260521: &anthropic.BetaCodeExecutionTool20260521Param{}},
+  	Tools: []anthropic.ToolUnionParam{
+  		{OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{}},
   	},
   })
   if err != nil {

 
   ```java Java
   // Create a message with the PowerPoint Skill
-  BetaMessage response = client.beta().messages().create(
+  Message response = client.messages().create(
       MessageCreateParams.builder()
           .model(Model.CLAUDE_OPUS_5)
           .maxTokens(16000)
-          .addBeta(AnthropicBeta.SKILLS_2025_10_02)
           .container(
-              BetaContainerParams.builder()
+              ContainerParams.builder()
                   .addSkill(
-                      BetaSkillParams.builder()
-                          .type(BetaSkillParams.Type.ANTHROPIC)
+                      SkillParams.builder()
+                          .type(SkillParams.Type.ANTHROPIC)
                           .skillId("pptx")
                           .version("latest")
                           .build()

                   .build()
           )
           .addUserMessage("Create a presentation about renewable energy with 5 slides")
-          .addTool(BetaCodeExecutionTool20260521.builder().build())
+          .addTool(CodeExecutionTool20260521.builder().build())
           .build()
   );
 

 
   ```ruby Ruby
   # Create a message with the PowerPoint Skill
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: "claude-opus-5",
     max_tokens: 16_000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{type: "anthropic", skill_id: "pptx", version: "latest"}]
     },

 * **`tools`:** Enables code execution (required for Skills)
 
 <Note>
-  Skills are generally available on the Claude API and don't require a beta header. The examples on this page still send the `skills-2025-10-02` beta header and use the SDKs' `beta` namespace. Both remain valid, so you can run the examples as written and omit the header in your own requests.
+  Skills are generally available on the Claude API and don't require a beta header. This covers the Skills API, the `container.skills` parameter, and the Files API. Requests that still send the `skills-2025-10-02` or `files-api-2025-04-14` header keep working, and the Skills API and Files API return the earlier response format for them. The PHP tabs in this quickstart still call the SDK's `beta` namespace and send those headers, so their printed output shows the earlier response fields.
 
   The examples use the `code_execution_20260521` tool version, and the Step 3 code parses the result types that current tool versions return. Skills also work with older [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) versions such as `code_execution_20250825`: any current code execution tool version satisfies the Skills requirement without a beta header. If you use a different version, use the tool `type` listed on the code execution tool page.
 </Note>

     curl --fail-with-body -sS "https://api.anthropic.com/v1/files/$file_id/content" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
-      -H "anthropic-beta: files-api-2025-04-14" \
       -o "$output_path"
     echo "Presentation saved to $output_path"
   fi

   if [[ -n "$file_id" ]]; then
     # Download the file and save it
     output_path="${TMPDIR:-/tmp}/renewable_energy.pptx"
-    ant beta:files download --file-id "$file_id" --output "$output_path"
+    ant files download --file-id "$file_id" --output "$output_path"
     echo "Presentation saved to $output_path"
   fi
   ```

   if file_id:
       # Download the file and save it
       output_path = Path(tempfile.gettempdir()) / "renewable_energy.pptx"
-      file_content = client.beta.files.download(file_id=file_id)
+      file_content = client.files.download(file_id=file_id)
       file_content.write_to_file(output_path)
       print(f"Presentation saved to {output_path}")
   ```

   if (fileId) {
     // Download the file and save it
     const outputPath = path.join(os.tmpdir(), "renewable_energy.pptx");
-    const fileContent = await client.beta.files.download(fileId);
+    const fileContent = await client.files.download(fileId);
     await fs.writeFile(outputPath, Buffer.from(await fileContent.arrayBuffer()));
     console.log(`Presentation saved to ${outputPath}`);
   }

   foreach (var block in response.Content)
   {
       if (block.TryPickBashCodeExecutionToolResult(out var bashResult)
-          && bashResult.Content.TryPickBetaBashCodeExecutionResultBlock(out var bashResultBlock))
+          && bashResult.Content.TryPickBashCodeExecutionResultBlock(out var bashResultBlock))
       {
           foreach (var output in bashResultBlock.Content)
           {

   {
       // Download the file and save it
       var outputPath = Path.Combine(Path.GetTempPath(), "renewable_energy.pptx");
-      using var download = await client.Beta.Files.Download(fileId);
+      using var download = await client.Files.Download(fileId);
       await using var source = await download.ReadAsStream();
       await using var destination = File.Create(outputPath);
       await source.CopyToAsync(destination);

   var fileID string
   for _, block := range response.Content {
   	switch result := block.AsAny().(type) {
-  	case anthropic.BetaBashCodeExecutionToolResultBlock:
+  	case anthropic.BashCodeExecutionToolResultBlock:
   		if result.Content.Type == "bash_code_execution_result" {
   			for _, output := range result.Content.Content {
   				fileID = output.FileID

   if fileID != "" {
   	// Download the file and save it
   	outputPath := filepath.Join(os.TempDir(), "renewable_energy.pptx")
-  	fileContent, err := client.Beta.Files.Download(ctx, fileID, anthropic.BetaFileDownloadParams{})
+  	fileContent, err := client.Files.Download(ctx, fileID)
   	if err != nil {
   		panic(err)
   	}

   // its Bash sub-tool, and generated files appear as bash_code_execution_output
   // items inside the bash_code_execution_tool_result block.
   String fileId = null;
-  for (BetaContentBlock block : response.content()) {
+  for (ContentBlock block : response.content()) {
       if (block.isBashCodeExecutionToolResult()) {
           var content = block.asBashCodeExecutionToolResult().content();
-          if (content.isBetaBashCodeExecutionResultBlock()) {
-              for (var output : content.asBetaBashCodeExecutionResultBlock().content()) {
+          if (content.isBashCodeExecutionResultBlock()) {
+              for (var output : content.asBashCodeExecutionResultBlock().content()) {
                   fileId = output.fileId();
               }
           }

   if (fileId != null) {
       // Download the file and save it
       Path outputPath = Files.createTempFile("renewable_energy", ".pptx");
-      try (HttpResponse fileContent = client.beta().files().download(fileId)) {
+      try (HttpResponse fileContent = client.files().download(fileId)) {
           Files.copy(fileContent.body(), outputPath, StandardCopyOption.REPLACE_EXISTING);
       }
       IO.println("Presentation saved to " + outputPath);

   if file_id
     # Download the file and save it
     output_path = File.join(Dir.tmpdir, "renewable_energy.pptx")
-    file_content = client.beta.files.download(file_id)
+    file_content = client.files.download(file_id)
     File.binwrite(output_path, file_content.read)
     puts "Presentation saved to #{output_path}"
   end

     -H "content-type: application/json" \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: skills-2025-10-02" \
     -d '{
       "model": "claude-opus-5",
       "max_tokens": 16000,

         {"role": "user", "content": "Create a quarterly sales tracking spreadsheet with sample data"}
       ],
       "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
-    }' | jq -r '"stop_reason=\(.stop_reason)"'
+    }'
   ```
 
   ```bash CLI
-  ant beta:messages create --format json \
-    --beta skills-2025-10-02 <<'YAML' | jq -r '"stop_reason=\(.stop_reason)"'
+  ant messages create <<'YAML'
   model: claude-opus-5
   max_tokens: 16000
   container:

   ```
 
   ```python Python
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
       max_tokens=16000,
-      betas=["skills-2025-10-02"],
       container={
           "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
       },

   ```
 
   ```typescript TypeScript
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
     max_tokens: 16000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
     },

   ```
 
   ```csharp C#
-  var response = await client.Beta.Messages.Create(
+  var response = await client.Messages.Create(
       new MessageCreateParams
       {
           Model = Model.ClaudeOpus5,
           MaxTokens = 16000,
-          Betas = ["skills-2025-10-02"],
-          Container = new BetaContainerParams
+          Container = new ContainerParams
           {
               Skills =
               [
-                  new BetaSkillParams
+                  new SkillParams
                   {
-                      Type = BetaSkillParamsType.Anthropic,
+                      Type = SkillParamsType.Anthropic,
                       SkillID = "xlsx",
                       Version = "latest",
                   },

           },
           Messages =
           [
-              new BetaMessageParam
+              new MessageParam
               {
                   Role = Role.User,
                   Content = "Create a quarterly sales tracking spreadsheet with sample data",
               },
           ],
-          Tools = [new BetaCodeExecutionTool20260521()],
+          Tools = [new CodeExecutionTool20260521()],
       }
   );
   ```
 
   ```go Go
-  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 16000,
-  	Betas: []anthropic.AnthropicBeta{
-  		anthropic.AnthropicBetaSkills2025_10_02,
-  	},
-  	Container: anthropic.BetaMessageNewParamsContainerUnion{
-  		OfContainers: &anthropic.BetaContainerParams{
-  			Skills: []anthropic.BetaSkillParams{
+  	Container: anthropic.MessageCreateParamsContainerUnion{
+  		OfContainers: &anthropic.ContainerParams{
+  			Skills: []anthropic.SkillParams{
   				{
-  					Type:    anthropic.BetaSkillParamsTypeAnthropic,
+  					Type:    anthropic.SkillParamsTypeAnthropic,
   					SkillID: "xlsx",
   					Version: anthropic.String("latest"),
   				},

   			},
   		},
   	},
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a quarterly sales tracking spreadsheet with sample data")),
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a quarterly sales tracking spreadsheet with sample data")),
   	},
-  	Tools: []anthropic.BetaToolUnionParam{
+  	Tools: []anthropic.ToolUnionParam{
   		{
-  			OfCodeExecutionTool20260521: &anthropic.BetaCodeExecutionTool20260521Param{},
+  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
   		},
   	},
   })

   ```
 
   ```java Java
-  BetaMessage response = client.beta().messages().create(
+  Message response = client.messages().create(
       MessageCreateParams.builder()
           .model(CLAUDE_OPUS_5)
           .maxTokens(16000)
-          .addBeta(AnthropicBeta.SKILLS_2025_10_02)
           .container(
-              BetaContainerParams.builder()
+              ContainerParams.builder()
                   .addSkill(
-                      BetaSkillParams.builder()
+                      SkillParams.builder()
                           .type(ANTHROPIC)
                           .skillId("xlsx")
                           .version("latest")

                   .build()
           )
           .addUserMessage("Create a quarterly sales tracking spreadsheet with sample data")
-          .addTool(BetaCodeExecutionTool20260521.builder().build())
+          .addTool(CodeExecutionTool20260521.builder().build())
           .build()
   );
 

   ```
 
   ```ruby Ruby
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: "claude-opus-5",
     max_tokens: 16_000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{type: "anthropic", skill_id: "xlsx", version: "latest"}]
     },

     -H "content-type: application/json" \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: skills-2025-10-02" \
     -d '{
       "model": "claude-opus-5",
       "max_tokens": 16000,

         {"role": "user", "content": "Write a 2-page report on the benefits of renewable energy"}
       ],
       "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
-    }' | jq -r '"stop_reason=\(.stop_reason)"'
+    }'
   ```
 
   ```bash CLI
-  ant beta:messages create --format json \
-    --beta skills-2025-10-02 <<'YAML' | jq -r '"stop_reason=\(.stop_reason)"'
+  ant messages create <<'YAML'
   model: claude-opus-5
   max_tokens: 16000
   container:

   ```
 
   ```python Python
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
       max_tokens=16000,
-      betas=["skills-2025-10-02"],
       container={
           "skills": [{"type": "anthropic", "skill_id": "docx", "version": "latest"}]
       },

   ```
 
   ```typescript TypeScript
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
     max_tokens: 16000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{ type: "anthropic", skill_id: "docx", version: "latest" }]
     },

   ```
 
   ```csharp C#
-  var response = await client.Beta.Messages.Create(
+  var response = await client.Messages.Create(
       new MessageCreateParams
       {
           Model = Model.ClaudeOpus5,
           MaxTokens = 16000,
-          Betas = ["skills-2025-10-02"],
-          Container = new BetaContainerParams
+          Container = new ContainerParams
           {
               Skills =
               [
-                  new BetaSkillParams
+                  new SkillParams
                   {
-                      Type = BetaSkillParamsType.Anthropic,
+                      Type = SkillParamsType.Anthropic,
                       SkillID = "docx",
                       Version = "latest",
                   },

           },
           Messages =
           [
-              new BetaMessageParam
+              new MessageParam
               {
                   Role = Role.User,
                   Content = "Write a 2-page report on the benefits of renewable energy",
               },
           ],
-          Tools = [new BetaCodeExecutionTool20260521()],
+          Tools = [new CodeExecutionTool20260521()],
       }
   );
   ```
 
   ```go Go
-  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 16000,
-  	Betas: []anthropic.AnthropicBeta{
-  		anthropic.AnthropicBetaSkills2025_10_02,
-  	},
-  	Container: anthropic.BetaMessageNewParamsContainerUnion{
-  		OfContainers: &anthropic.BetaContainerParams{
-  			Skills: []anthropic.BetaSkillParams{
+  	Container: anthropic.MessageCreateParamsContainerUnion{
+  		OfContainers: &anthropic.ContainerParams{
+  			Skills: []anthropic.SkillParams{
   				{
-  					Type:    anthropic.BetaSkillParamsTypeAnthropic,
+  					Type:    anthropic.SkillParamsTypeAnthropic,
   					SkillID: "docx",
   					Version: anthropic.String("latest"),
   				},

   			},
   		},
   	},
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Write a 2-page report on the benefits of renewable energy")),
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Write a 2-page report on the benefits of renewable energy")),
   	},
-  	Tools: []anthropic.BetaToolUnionParam{
+  	Tools: []anthropic.ToolUnionParam{
   		{
-  			OfCodeExecutionTool20260521: &anthropic.BetaCodeExecutionTool20260521Param{},
+  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
   		},
   	},
   })

   ```
 
   ```java Java
-  BetaMessage response = client.beta().messages().create(
+  Message response = client.messages().create(
       MessageCreateParams.builder()
           .model(CLAUDE_OPUS_5)
           .maxTokens(16000)
-          .addBeta(AnthropicBeta.SKILLS_2025_10_02)
           .container(
-              BetaContainerParams.builder()
+              ContainerParams.builder()
                   .addSkill(
-                      BetaSkillParams.builder()
+                      SkillParams.builder()
                           .type(ANTHROPIC)
                           .skillId("docx")
                           .version("latest")

                   .build()
           )
           .addUserMessage("Write a 2-page report on the benefits of renewable energy")
-          .addTool(BetaCodeExecutionTool20260521.builder().build())
+          .addTool(CodeExecutionTool20260521.builder().build())
           .build()
   );
 

   ```
 
   ```ruby Ruby
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: "claude-opus-5",
     max_tokens: 16_000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{type: "anthropic", skill_id: "docx", version: "latest"}]
     },

     -H "content-type: application/json" \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: skills-2025-10-02" \
     -d '{
       "model": "claude-opus-5",
       "max_tokens": 16000,

         {"role": "user", "content": "Generate a PDF invoice template"}
       ],
       "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
-    }' | jq -r '"stop_reason=\(.stop_reason)"'
+    }'
   ```
 
   ```bash CLI
-  ant beta:messages create --format json \
-    --beta skills-2025-10-02 <<'YAML' | jq -r '"stop_reason=\(.stop_reason)"'
+  ant messages create <<'YAML'
   model: claude-opus-5
   max_tokens: 16000
   container:

   ```
 
   ```python Python
-  response = client.beta.messages.create(
+  response = client.messages.create(
       model="claude-opus-5",
       max_tokens=16000,
-      betas=["skills-2025-10-02"],
       container={
           "skills": [{"type": "anthropic", "skill_id": "pdf", "version": "latest"}]
       },

   ```
 
   ```typescript TypeScript
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
     max_tokens: 16000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{ type: "anthropic", skill_id: "pdf", version: "latest" }]
     },

   ```
 
   ```csharp C#
-  var response = await client.Beta.Messages.Create(
+  var response = await client.Messages.Create(
       new MessageCreateParams
       {
           Model = Model.ClaudeOpus5,
           MaxTokens = 16000,
-          Betas = ["skills-2025-10-02"],
-          Container = new BetaContainerParams
+          Container = new ContainerParams
           {
               Skills =
               [
-                  new BetaSkillParams
+                  new SkillParams
                   {
-                      Type = BetaSkillParamsType.Anthropic,
+                      Type = SkillParamsType.Anthropic,
                       SkillID = "pdf",
                       Version = "latest",
                   },

           },
           Messages =
           [
-              new BetaMessageParam
+              new MessageParam
               {
                   Role = Role.User,
                   Content = "Generate a PDF invoice template",
               },
           ],
-          Tools = [new BetaCodeExecutionTool20260521()],
+          Tools = [new CodeExecutionTool20260521()],
       }
   );
   ```
 
   ```go Go
-  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 16000,
-  	Betas: []anthropic.AnthropicBeta{
-  		anthropic.AnthropicBetaSkills2025_10_02,
-  	},
-  	Container: anthropic.BetaMessageNewParamsContainerUnion{
-  		OfContainers: &anthropic.BetaContainerParams{
-  			Skills: []anthropic.BetaSkillParams{
+  	Container: anthropic.MessageCreateParamsContainerUnion{
+  		OfContainers: &anthropic.ContainerParams{
+  			Skills: []anthropic.SkillParams{
   				{
-  					Type:    anthropic.BetaSkillParamsTypeAnthropic,
+  					Type:    anthropic.SkillParamsTypeAnthropic,
   					SkillID: "pdf",
   					Version: anthropic.String("latest"),
   				},

   			},
   		},
   	},
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Generate a PDF invoice template")),
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Generate a PDF invoice template")),
   	},
-  	Tools: []anthropic.BetaToolUnionParam{
+  	Tools: []anthropic.ToolUnionParam{
   		{
-  			OfCodeExecutionTool20260521: &anthropic.BetaCodeExecutionTool20260521Param{},
+  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
   		},
   	},
   })

   ```
 
   ```java Java
-  BetaMessage response = client.beta().messages().create(
+  Message response = client.messages().create(
       MessageCreateParams.builder()
           .model(CLAUDE_OPUS_5)
           .maxTokens(16000)
-          .addBeta(AnthropicBeta.SKILLS_2025_10_02)
           .container(
-              BetaContainerParams.builder()
+              ContainerParams.builder()
                   .addSkill(
-                      BetaSkillParams.builder()
+                      SkillParams.builder()
                           .type(ANTHROPIC)
                           .skillId("pdf")
                           .version("latest")

                   .build()
           )
           .addUserMessage("Generate a PDF invoice template")
-          .addTool(BetaCodeExecutionTool20260521.builder().build())
+          .addTool(CodeExecutionTool20260521.builder().build())
           .build()
   );
 

   ```
 
   ```ruby Ruby
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: "claude-opus-5",
     max_tokens: 16_000,
-    betas: ["skills-2025-10-02"],
     container: {
       skills: [{type: "anthropic", skill_id: "pdf", version: "latest"}]
     },

     Learn how to use Agent Skills to extend Claude's capabilities through the API.
   </Card>
 
-  <Card title="Create custom Skills" icon="code" href="https://platform.claude.com/docs/en/api/skills/create-skill">
+  <Card title="Create custom Skills" icon="code" href="https://platform.claude.com/docs/en/api/skills/create">
     Upload your own Skills for specialized tasks.
   </Card>
 

 
 ```text wrap
 $ claude
-> add prompt caching to this integration
+> /claude-api add prompt caching to this integration
 
 Done. Prompt caching is now wired into the harness. Two changes:
 

 Three controls do three different jobs. A task budget saves money, because the model sees it. `max_tokens` is a safety cap that saves nothing. On Claude Managed Agents, a session budget is the hard dollar stop behind both. Set all three: a task budget, a high `max_tokens`, and a session cap for the run you never want on a bill, with a [workspace spend limit](https://platform.claude.com/docs/en/api/rate-limits#setting-lower-limits-for-workspaces) as the final backstop.
 
 * **Task budgets** are in beta (beta header `task-budgets-2026-03-13`) on Claude Opus 5, Claude Fable 5, Claude Opus 4.8, and Claude Opus 4.7, but not Claude Sonnet 5; check the [support table](https://platform.claude.com/docs/en/build-with-claude/task-budgets#feature-support) first. Start near your loop's 90th-percentile token usage, then tighten ([Choosing a budget](https://platform.claude.com/docs/en/build-with-claude/task-budgets#choosing-a-budget) shows how to collect that distribution). Budgets below the current 20,000-token floor are rejected, and very tight budgets can produce refusal-like behavior. Set the budget once, on the first request, because a mid-task change [invalidates the cache](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context). The budget is advisory, steering the model rather than stopping it, so verify adherence on your workload.
-* **`max_tokens`** caps a single response, invisibly to the model, so lowering it does not make the model economize. The turns that needed the room are discarded and still billed. On an internal repository-task benchmark[12](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs), a 16,384-token cap ended 15% of Claude Opus 5's attempts and a third of Claude Fable 5's, none of them solved. Capped runs spent less per attempt but bought proportionally fewer solves, so cost per solved task was the same as at 64,000. At that setting nothing was cut off, and Fable solved 54.6% of tasks instead of 33.3% (on a separate cut of the SWE-bench Pro[3](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) subset, described in reference 12, 92% instead of 90%). Retrying capped attempts only adds cost: at the same cap they never succeeded, and at a higher one you also pay for the wasted attempt. Set `max_tokens` to 64,000 for agentic work (128,000, the maximum, at `xhigh` or `max` effort), [stream responses](https://platform.claude.com/docs/en/build-with-claude/streaming) that large, treat [`stop_reason: max_tokens`](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons#max-tokens) as a failure, and save money with effort and task budgets, which the model can see.
+* **`max_tokens`** caps a single response, invisibly to the model, so lowering it does not make the model economize. The turns that needed the room are discarded and still billed. On an internal repository-task benchmark[12](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs), a 16,384-token cap ended 15% of Claude Opus 5's attempts and a third of Claude Fable 5's, none of them solved. Capped runs spent less per attempt but bought proportionally fewer solves, so cost per solved task was the same as at 64,000. At that setting nothing was cut off, and Fable solved 54.6% of tasks instead of 36.6% on the problems both runs scored (on a separate cut of the SWE-bench Pro[3](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) subset, described in reference 12, 92% instead of 90%). Retrying capped attempts only adds cost: at the same cap they never succeeded, and at a higher one you also pay for the wasted attempt. Set `max_tokens` to 64,000 for agentic work (128,000, the maximum, at `xhigh` or `max` effort), [stream responses](https://platform.claude.com/docs/en/build-with-claude/streaming) that large, treat [`stop_reason: max_tokens`](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons#max-tokens) as a failure, and save money with effort and task budgets, which the model can see.
 * **Session budgets on Claude Managed Agents** are the hard stop. A [session budget](https://platform.claude.com/docs/en/managed-agents/budgets) is a dollar cap on one session at list rates for tokens, searches, and session time. At the cap, the session pauses with `stop_reason: budget_reached`; raising the budget resumes it. It is platform-enforced, works on any model with a list price (including Claude Sonnet 5), and combines with the advisory task budget. Deployments apply the same field to every run.
 
 The first of two `max_tokens` charts plots cost per attempt and per solved task at each cap:

 
 ![Diagram of the orchestrator strategy: a Claude Fable 5 orchestrator fans subtasks out to three Claude Sonnet 5 workers](https://platform.claude.com/docs/images/model-routing-orchestrator-strategy.png)
 
-This pattern saves wall-clock time when workers can run in parallel: on the corpus benchmark[8](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) later in this section, an episode took 1.9 hours with the coordinator compared with 11.4 hours solo. It saved money in only two measured situations. On work a single model could handle alone, the same model at lower effort was cheaper every time.
+This pattern saves wall-clock time when workers can run in parallel: on the corpus benchmark[8](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs), an episode took a little over 2 hours with the coordinator running the platform's documented limit of 25 concurrent workers, compared with 11.4 hours solo. It saved money in only two measured situations. On work a single model could handle alone, the same model at lower effort was cheaper every time.
 
 **Case 1: insurance against the cost tail on routine work.** A frontier model running alone occasionally spirals on a routine problem it would normally solve. Because you cannot tell in advance which those will be, a few such runs dominate the bill. A coordinator that hands routine work to a lower-cost worker caps that tail, because any spiraling now happens at worker rates.
 

 
 **Case 2: work larger than one context window.** A solo model must work through an input that large serially, one context window at a time, paying to re-read its own state on every pass. Workers each read their own partition, in parallel and at worker rates. Reading-heavy work that still fits in one context window is a model-choice problem, not a delegation problem: on reading cost alone, the orchestrator comes out ahead only when no single context can hold the work.
 
-Anthropic built a benchmark for this case[8](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs): a 21.6-million-token corpus of 14 public Python packages with 130 planted defects, too large for any context window. Lowering effort cannot help, because the bill is the corpus read itself: Claude Fable 5 solo cost $720 to $764 per episode at every effort setting, and only its accuracy moved. The coordinator configuration cost 55% less than any of those settings and scored 3 to 7 points below Fable at `medium` or the default, while beating a Claude Sonnet 5 solo baseline outright:
+Anthropic built a benchmark for this case[8](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs): a 21.6-million-token corpus of 14 public Python packages with 130 planted defects, too large for any context window. Lowering effort cannot help, because the bill is the corpus read itself: Claude Fable 5 solo cost $720 to $764 per episode at every effort setting, and only its accuracy moved. The coordinator configuration cost more than 60% less than any of those settings and scored 2 to 6 points below Fable at `medium` or the default, while beating a Claude Sonnet 5 solo baseline outright:
 
-![Chart, corpus benchmark: the coordinator costs 55% less than Fable solo at every effort setting, 3 to 7 points below its best](https://platform.claude.com/docs/images/cost-intel-corpus-pareto.png)
+![Chart, corpus benchmark: the coordinator costs over 60% less than Fable solo at every effort setting, 2 to 6 points below its best](https://platform.claude.com/docs/images/cost-intel-corpus-pareto.png)
 
-The token accounting shows why. The coordinator configuration read more than the solo model (32 million input tokens compared with 14.5 million) and still cost less, because partitioned reading at worker rates is cheaper than repeated re-reading at frontier rates. Fable 5 at default effort still holds peak accuracy, at 2.3 times the coordinator configuration's cost, so delegation here buys most of the accuracy, not all of it.
+The token accounting shows why. Both bills are mostly corpus reading served from the cache: the coordinator configuration read about 570 million cached tokens per episode, nearly three times the solo model's roughly 200 million, and still cost less than half as much, because its reads were billed at Claude Sonnet 5's cache-read rate rather than Claude Fable 5's. Fable 5 at default effort still holds peak accuracy, at 2.8 times the coordinator configuration's cost, so delegation here buys most of the accuracy, not all of it.
 
 **When delegation doesn't pay.** An orchestrator buys something only when there is bulk to hand off: many independent pieces, ideally too many for one context window. When the work is one dependent chain, or fits in a single context, the orchestrator pays for a plan, a handoff, and a merge that a single model gets for free. In every such case measured, the coordinator's model alone at lower effort came out ahead.
 

 | Lower effort                           | Knowledge work: `medium` 15% to 30%, `low` a third to a half; long coding: `medium` about half, `low` about three quarters                                | 1 to 3 points on knowledge work, 2 to 8 on long coding | Faster                          | [Tune effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)                                                         |
 | Re-run failures                        | About half, at the same pass rate                                                                                                                         | None                                                   | Two runs on the tasks that fail | [Re-run failures at higher effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort)               |
 | Task budget                            | 18% to 47%                                                                                                                                                | 3 to 4 points                                          | Faster                          | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                         |
-| Raising `max_tokens`                   | None per solved task, but more tasks solved                                                                                                               | Gains of 2 to 21 points                                | Neutral                         | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                         |
+| Raising `max_tokens`                   | None per solved task, but more tasks solved                                                                                                               | Gains of 2 to 18 points                                | Neutral                         | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                         |
 | Advisor                                | Depends on the capability gap and the consult rate; the chart-reading pairing scored above both models' effort curves, the coding pairing only marginally | Small gains                                            | About two extra calls per task  | [Advisor strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions)                       |
-| Orchestrator                           | 55% below the frontier model beyond one context window; about half on routine tails                                                                       | 3 to 7 points below the frontier model                 | Much faster on large inputs     | [Orchestrator strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work)                  |
+| Orchestrator                           | More than 60% below the frontier model beyond one context window; about half on routine tails                                                             | 2 to 6 points below the frontier model                 | Much faster on large inputs     | [Orchestrator strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work)                  |
 
 ## Benchmarks referenced
 

 5. **Agent-architecture scaling:** Kim et al., "Towards a Science of Scaling Agent Systems," arXiv.08296, 2025. Independent external study, cited only for the direction of the finding on when delegation does not pay, not for any figure.
 6. **DeepWideSearch:** "DeepWideSearch: Benchmarking Depth and Width in Agentic Information Seeking," arXiv.20168, 2025. The 220 questions span 15 domains, each combining many-row collection with multi-hop retrieval; measured on the benchmark's standing row set, 3 runs per configuration.
 7. **DeepResearch Bench II:** Li et al., "DeepResearch Bench II: Diagnosing Deep Research Agents via Rubrics from Expert Report," arXiv.08536, 2026. Its 132 research tasks across 22 domains are graded against expert-derived binary rubrics; measured on a 50-task subset stratified across all themes, one attempt per task, 3 runs, scored on tasks no configuration refused. Claude Opus 4.6 judges under the benchmark's rubric protocol; the original uses a different judge, and an Anthropic judge may favor the house style. The runs predate Claude Opus 5, hence its absence from the [Compare models](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) chart. The Sonnet 5 cost differs slightly between the caching chart (inference cost, with and without caching) and that chart (all-in cost, caching on); both come from the same runs.
-8. **Corpus defect sweep:** Anthropic-internal, for work larger than one context window: a 21.6-million-token corpus from 14 public Python package sources with 130 planted defects and deterministic grading; protocol fixed before the runs and internally reviewed; three runs per configuration. The charted team configuration ran its workers on Claude Managed Agents: each of six waves was one session in which the Claude Fable 5 lead ran 40 Claude Sonnet 5 worker threads, the platform's limit at the time (the current default is lower), with a small external driver sequencing the waves and carrying the findings between them. Absolute F1 is specific to this corpus build, not comparable across benchmarks; configuration comparisons are like for like.
+8. **Corpus defect sweep:** Anthropic-internal, for work larger than one context window: a 21.6-million-token corpus from 14 public Python package sources with 130 planted defects and deterministic grading; protocol fixed before the runs and internally reviewed; three runs per configuration. Every configuration ran on Claude Managed Agents. The charted team configuration is an August 2026 run in which the Claude Fable 5 coordinator ran the whole sweep inside the platform at its documented limit of 25 concurrent Claude Sonnet 5 workers; its three episodes scored F1 0.842, 0.805, and 0.810 for $263, $299, and $261. The solo configurations are July 2026 runs on the same corpus build. Absolute F1 is specific to this corpus build, not comparable across benchmarks; configuration comparisons are like for like.
 9. **GPQA Diamond:** Rein et al., "GPQA: A Graduate-Level Google-Proof Q\&A Benchmark," 2023. The 198-question Diamond subset, measured August 2026, two runs per configuration, model-graded against reference answers, advisor tokens metered per request. A platform safety check refused two biology questions on the Sonnet and Opus executors; excluding them changes no comparison by more than one point.
 10. **DeepSWE:** Datacurve, "DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks," arXiv.07946, 2026. Measured August 2026: 113 original tasks across five languages with program-based verifiers. Pairings are two runs each with advisor tokens metered per request, and used a client-side advisor loop rather than the advisor tool, with identical accounting. Single-model effort sweeps are single runs priced from token counts, a cache-aware approximation. Costs per task are run totals divided by 113.
 11. **Internal agentic-coding benchmark:** Anthropic-internal: 370 repository tasks graded by the repositories' own tests. The API figures (Opus 5 alone, Fable 5 alone, and the pairing) were measured August 2026 at the default effort with a 128,000-token output cap, one run per configuration: five attempts per task at the default settings and for the pairing, one at `low` and `medium`; the pairing averaged about two advisor consultations per attempt; costs are per attempt. The Claude Code figures are July 2026 runs of the same tasks, one run per configuration, costs approximate.