开始使用 Claude Managed Agents

创建您的第一个自主智能体。

本指南将引导您完成创建智能体、设置环境、启动会话以及流式传输智能体响应的过程。

让 Claude Code 为您设置智能体

示例代码
/claude-api managed-agents-onboard

核心概念

概念描述
Agent(智能体)模型、系统提示、工具、MCP 服务器和技能
Environment(环境)会话运行位置的配置:Anthropic 托管的云沙箱,或在您自己的基础设施上自托管的沙箱
Session(会话)在环境中运行的智能体实例,执行特定任务并生成输出
Events(事件)您的应用程序与智能体之间交换的消息(用户轮次、工具结果、状态更新)

开始之前

创建 Claude Console 账户

注册 Claude Console 账户,或登录您已有的账户。

选择身份验证方式

对于本地开发,建议使用 CLI 登录。

Follow the steps for one of the following options.

CLI

安装 CLI

Homebrew (macOS)

示例代码
brew install anthropics/tap/ant

curl (Linux/WSL)

对于 Linux 环境,请直接下载发布版二进制文件。

示例代码
VERSION=2.9.0
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
case $(uname -m) in
  x86_64) ARCH=amd64 ;;
  aarch64) ARCH=arm64 ;;
esac
curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
  | sudo tar -xz -C /usr/local/bin ant

您可以在 GitHub 发布页面上找到所有发布版本。

go install

您也可以使用 go install 从源代码安装 CLI,这需要 Go 1.26.10 或更高版本。

示例代码
go install github.com/anthropics/anthropic-cli/v2/cmd/ant@latest

go install 会将二进制文件放置在 $(go env GOPATH)/bin 中。如果该目录尚未添加到您的 PATH 中,请将其添加进去:

示例代码
export PATH="$PATH:$(go env GOPATH)/bin"

登录

示例代码
ant auth login

登录完成后,SDK 和 CLI 将自动获取您的凭据。

API 密钥

创建 API 密钥

在 Claude Console 中创建 API 密钥。

设置环境变量

SDK 和 CLI 从 ANTHROPIC_API_KEY 读取您的密钥:

示例代码
export ANTHROPIC_API_KEY="your-api-key-here"

API 密钥

要运行 CLI 示例,请安装 CLI:

Homebrew (macOS)

示例代码
brew install anthropics/tap/ant

curl (Linux/WSL)

对于 Linux 环境,请直接下载发布版二进制文件。

示例代码
VERSION=2.9.0
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
case $(uname -m) in
  x86_64) ARCH=amd64 ;;
  aarch64) ARCH=arm64 ;;
esac
curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
  | sudo tar -xz -C /usr/local/bin ant

您可以在 GitHub 发布页面上找到所有发布版本。

go install

您也可以使用 go install 从源代码安装 CLI,这需要 Go 1.26.10 或更高版本。

示例代码
go install github.com/anthropics/anthropic-cli/v2/cmd/ant@latest

go install 会将二进制文件放置在 $(go env GOPATH)/bin 中。如果该目录尚未添加到您的 PATH 中,请将其添加进去:

示例代码
export PATH="$PATH:$(go env GOPATH)/bin"

安装 SDK

Python

示例代码
pip install anthropic

TypeScript

示例代码
npm install @anthropic-ai/sdk

Java

Gradle

示例代码
implementation("com.anthropic:anthropic-java:3.8.0")

Maven

示例代码
<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>anthropic-java</artifactId>
    <version>3.8.0</version>
</dependency>

Go

示例代码
go get github.com/anthropics/anthropic-sdk-go/v2

C#

示例代码
dotnet add package Anthropic

Ruby

示例代码
bundle add anthropic

PHP

示例代码
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"

创建您的第一个会话

创建智能体

创建一个智能体,用于定义模型、系统提示和可用工具。

CLI 登录

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
  -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "Coding Assistant",
    "model": "claude-opus-5-5",
    "system": "You are a helpful coding assistant. Write clean, well-documented code.",
    "tools": [
      {
        "type": "agent_toolset_20260401",
        "configs": [
          {"name": "web_search", "enabled": false},
          {"name": "web_fetch", "enabled": false}
        ]
      }
    ]
  }'

保存返回的 agent.id。您创建的每个会话都会引用它。

API 密钥

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "Coding Assistant",
    "model": "claude-opus-5-5",
    "system": "You are a helpful coding assistant. Write clean, well-documented code.",
    "tools": [
      {
        "type": "agent_toolset_20260401",
        "configs": [
          {"name": "web_search", "enabled": false},
          {"name": "web_fetch", "enabled": false}
        ]
      }
    ]
  }'

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
ant apply coding-assistant.md
示例代码
---
name: Coding Assistant
model: claude-opus-5-5
tools:
  - type: agent_toolset_20260401
    configs:
      - name: web_search
        enabled: false
      - name: web_fetch
        enabled: false
---

You are a helpful coding assistant. Write clean, well-documented code.

ant apply 会打印智能体的 ID 并将其记录在 claude-lock.json 中。您创建的每个会话都会引用它。

示例代码
from anthropic import Anthropic

client = Anthropic()

agent = client.beta.agents.create(
    name="Coding Assistant",
    model="claude-opus-5-5",
    system="You are a helpful coding assistant. Write clean, well-documented code.",
    tools=[
        {
            "type": "agent_toolset_20260401",
            "configs": [
                {"name": "web_search", "enabled": False},
                {"name": "web_fetch", "enabled": False},
            ],
        },
    ],
)

print(f"Agent ID: {agent.id}, version: {agent.version}")

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const agent = await client.beta.agents.create({
  name: "Coding Assistant",
  model: "claude-opus-5-5",
  system: "You are a helpful coding assistant. Write clean, well-documented code.",
  tools: [
    {
      type: "agent_toolset_20260401",
      configs: [
        { name: "web_search", enabled: false },
        { name: "web_fetch", enabled: false }
      ]
    }
  ]
});

console.log(`Agent ID: ${agent.id}, version: ${agent.version}`);

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
using Anthropic;
using Anthropic.Models.Beta.Agents;
using Anthropic.Models.Beta.Environments;
using Anthropic.Models.Beta.Sessions;
using Anthropic.Models.Beta.Sessions.Events;

var client = new AnthropicClient();

var agent = await client.Beta.Agents.Create(new()
{
    Name = "Coding Assistant",
    Model = BetaManagedAgentsModel.ClaudeOpus5_5,
    System = "You are a helpful coding assistant. Write clean, well-documented code.",
    Tools =
    [
        new BetaManagedAgentsAgentToolset20260401Params
        {
            Configs =
            [
                new BetaManagedAgentsWebSearchToolConfigParams { Enabled = false },
                new BetaManagedAgentsWebFetchToolConfigParams { Enabled = false },
            ],
        },
    ],
});

Console.WriteLine($"Agent ID: {agent.ID}, version: {agent.Version}");

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go/v2"
)

func main() {
	client := anthropic.NewClient()
	ctx := context.Background()

	agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
		Name: "Coding Assistant",
		Model: anthropic.BetaManagedAgentsModelConfigParams{
			ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
		},
		System: anthropic.String("You are a helpful coding assistant. Write clean, well-documented code."),
		Tools: []anthropic.BetaAgentNewParamsToolUnion{{
			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
				Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
					{OfWebSearch: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
						Enabled: anthropic.Bool(false),
					}},
					{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
						Enabled: anthropic.Bool(false),
					}},
				},
			},
		}},
	})
	if err != nil {
		panic(err)
	}

	fmt.Printf("Agent ID: %s, version: %d\n", agent.ID, agent.Version)

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.beta.agents.AgentCreateParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
import com.anthropic.models.beta.agents.BetaManagedAgentsWebFetchToolConfigParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsWebSearchToolConfigParams;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserMessageEventParams;
import com.anthropic.models.beta.sessions.events.EventSendParams;

void main() {
    var client = AnthropicOkHttpClient.fromEnv();

    var agent = client.beta().agents().create(AgentCreateParams.builder()
        .name("Coding Assistant")
        .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
        .system("You are a helpful coding assistant. Write clean, well-documented code.")
        .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
            .addConfig(BetaManagedAgentsWebSearchToolConfigParams.builder()
                .enabled(false)
                .build())
            .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
                .enabled(false)
                .build())
            .build())
        .build());

    IO.println("Agent ID: " + agent.id() + ", version: " + agent.version());

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsModel;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebSearchToolConfigParams;
use Anthropic\Client;

$client = new Client();

$agent = $client->beta->agents->create(
    name: 'Coding Assistant',
    model: BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
    system: 'You are a helpful coding assistant. Write clean, well-documented code.',
    tools: [
        BetaManagedAgentsAgentToolset20260401Params::with(
            configs: [
                BetaManagedAgentsWebSearchToolConfigParams::with(enabled: false),
                BetaManagedAgentsWebFetchToolConfigParams::with(enabled: false),
            ],
        ),
    ],
);

echo "Agent ID: {$agent->id}, version: {$agent->version}\n";

保存返回的 agent.id。您创建的每个会话都会引用它。

示例代码
require "anthropic"

client = Anthropic::Client.new

agent = client.beta.agents.create(
  name: "Coding Assistant",
  model: Anthropic::Beta::BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
  system_: "You are a helpful coding assistant. Write clean, well-documented code.",
  tools: [
    {
      type: "agent_toolset_20260401",
      configs: [
        {name: "web_search", enabled: false},
        {name: "web_fetch", enabled: false}
      ]
    }
  ]
)

puts "Agent ID: #{agent.id}, version: #{agent.version}"

保存返回的 agent.id。您创建的每个会话都会引用它。

agent_toolset_20260401 工具类型会启用预构建的智能体工具(bash、文件操作、网络搜索等)。此示例禁用了网络搜索和网页获取,因为本指南中的任务(编写一个简短的 Python 脚本)不会用到网页。请只为智能体提供它所需的工具。有关完整列表和各工具的配置选项,请参阅工具。

创建环境

环境定义了智能体运行所在的沙箱。此环境使用 limited 网络并允许包管理器,因此在沙箱中运行的代码可以访问公共包注册表和代码托管平台。在 limited 网络下,allowed_hosts (java, php: allowedHosts; csharp, go: AllowedHosts) 列表同样适用于网络搜索和网页获取,尽管它们在沙箱外运行。如果未列出任何主机(此环境正是如此),这些工具不会返回任何页面或搜索结果。如果您自己的智能体使用这些工具,请将它所需的主机添加到该列表中。

CLI 登录

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
  -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "quickstart-env",
    "config": {
      "type": "cloud",
      "networking": {"type": "limited", "allow_package_managers": true}
    }
  }'

同样保存返回的 environment.id。

API 密钥

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "quickstart-env",
    "config": {
      "type": "cloud",
      "networking": {"type": "limited", "allow_package_managers": true}
    }
  }'

同样保存返回的 environment.id。

示例代码
ant apply environment.yaml
示例代码
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: quickstart-env
config:
  type: cloud
  networking:
    type: limited
    allow_package_managers: true

ant apply 同样会将环境的 ID 记录在 claude-lock.json 中。要用一条命令同时创建智能体和环境,请传入两个文件:ant apply coding-assistant.md environment.yaml。

示例代码
environment = client.beta.environments.create(
    name="quickstart-env",
    config={
        "type": "cloud",
        "networking": {"type": "limited", "allow_package_managers": True},
    },
)

print(f"Environment ID: {environment.id}")

同样保存返回的 environment.id。

示例代码
const environment = await client.beta.environments.create({
  name: "quickstart-env",
  config: {
    type: "cloud",
    networking: { type: "limited", allow_package_managers: true }
  }
});

console.log(`Environment ID: ${environment.id}`);

同样保存返回的 environment.id。

示例代码
var environment = await client.Beta.Environments.Create(new()
{
    Name = "quickstart-env",
    Config = new BetaCloudConfigParams
    {
        Networking = new BetaLimitedNetworkParams { AllowPackageManagers = true },
    },
});

Console.WriteLine($"Environment ID: {environment.ID}");

同样保存返回的 environment.id。

示例代码
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
	Name: "quickstart-env",
	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
		OfCloud: &anthropic.BetaCloudConfigParams{
			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
				OfLimited: &anthropic.BetaLimitedNetworkParams{
					AllowPackageManagers: anthropic.Bool(true),
				},
			},
		},
	},
})
if err != nil {
	panic(err)
}

fmt.Printf("Environment ID: %s\n", environment.ID)

同样保存返回的 environment.id。

示例代码
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
    .name("quickstart-env")
    .config(BetaCloudConfigParams.builder()
        .networking(BetaLimitedNetworkParams.builder()
            .allowPackageManagers(true)
            .build())
        .build())
    .build());

IO.println("Environment ID: " + environment.id());

同样保存返回的 environment.id。

示例代码
$environment = $client->beta->environments->create(
    name: 'quickstart-env',
    config: [
        'type' => 'cloud',
        'networking' => ['type' => 'limited', 'allow_package_managers' => true],
    ],
);

echo "Environment ID: {$environment->id}\n";

同样保存返回的 environment.id。

示例代码
environment = client.beta.environments.create(
  name: "quickstart-env",
  config: {type: "cloud", networking: {type: "limited", allow_package_managers: true}}
)

puts "Environment ID: #{environment.id}"

同样保存返回的 environment.id。

启动会话

创建一个引用您的智能体和环境的会话。

CLI 登录

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
  -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "agent": "'"$AGENT_ID"'",
    "environment_id": "'"$ENVIRONMENT_ID"'",
    "title": "Quickstart session"
  }'

API 密钥

示例代码
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "agent": "'"$AGENT_ID"'",
    "environment_id": "'"$ENVIRONMENT_ID"'",
    "title": "Quickstart session"
  }'
示例代码
ant beta:sessions create \
  --agent "$AGENT_ID" \
  --environment-id "$ENVIRONMENT_ID" \
  --title "Quickstart session"
示例代码
session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    title="Quickstart session",
)

print(f"Session ID: {session.id}")
示例代码
const session = await client.beta.sessions.create({
  agent: agent.id,
  environment_id: environment.id,
  title: "Quickstart session"
});

console.log(`Session ID: ${session.id}`);
示例代码
var session = await client.Beta.Sessions.Create(new()
{
    Agent = agent.ID,
    EnvironmentID = environment.ID,
    Title = "Quickstart session",
});

Console.WriteLine($"Session ID: {session.ID}");
示例代码
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
	EnvironmentID: environment.ID,
	Title:         anthropic.String("Quickstart session"),
})
if err != nil {
	panic(err)
}

fmt.Printf("Session ID: %s\n", session.ID)
示例代码
var session = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(agent.id())
    .environmentId(environment.id())
    .title("Quickstart session")
    .build());

IO.println("Session ID: " + session.id());
示例代码
$session = $client->beta->sessions->create(
    agent: $agent->id,
    environmentID: $environment->id,
    title: 'Quickstart session',
);

echo "Session ID: {$session->id}\n";
示例代码
session = client.beta.sessions.create(
  agent: agent.id,
  environment_id: environment.id,
  title: "Quickstart session"
)

puts "Session ID: #{session.id}"

发送消息并流式传输响应

打开一个流,发送用户事件,然后在事件到达时进行处理:

此工作流需要的逻辑超出了单条 shell 命令所能实现的范围。请使用 Anthropic SDK 来运行它。

此工作流需要的逻辑超出了单条 shell 命令所能实现的范围。请使用 Anthropic SDK 来运行它。

示例代码
with client.beta.sessions.events.stream(session.id) as stream:
    # 在流打开后发送用户消息
    client.beta.sessions.events.send(
        session.id,
        events=[
            {
                "type": "user.message",
                "content": [
                    {
                        "type": "text",
                        "text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                    },
                ],
            },
        ],
    )

    # 处理流式传输事件
    for event in stream:
        match event.type:
            case "agent.message":
                for block in event.content:
                    if block.type == "text":
                        print(block.text, end="")
            case "agent.tool_use":
                print(f"\n[Using tool: {event.name}]")
            case "session.status_idle":
                print("\n\nAgent finished.")
                break
示例代码
const stream = await client.beta.sessions.events.stream(session.id);

// 在流打开后发送用户消息
await client.beta.sessions.events.send(session.id, {
  events: [
    {
      type: "user.message",
      content: [
        {
          type: "text",
          text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"
        }
      ]
    }
  ]
});

// 处理流式传输事件
loop: for await (const event of stream) {
  switch (event.type) {
    case "agent.message":
      for (const block of event.content) {
        if (block.type === "text") {
          process.stdout.write(block.text);
        }
      }
      break;
    case "agent.tool_use":
      console.log(`\n[Using tool: ${event.name}]`);
      break;
    case "session.status_idle":
      console.log("\n\nAgent finished.");
      break loop;
  }
}
示例代码
var stream = client.Beta.Sessions.Events.StreamStreaming(session.ID);

// 在流打开后发送用户消息
await client.Beta.Sessions.Events.Send(session.ID, new()
{
    Events =
    [
        new BetaManagedAgentsUserMessageEventParams
        {
            Content =
            [
                new BetaManagedAgentsTextBlock
                {
                    Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                },
            ],
        },
    ],
});

// 处理流式传输事件
await foreach (var streamEvent in stream)
{
    if (streamEvent.Value is BetaManagedAgentsAgentMessageEvent message)
    {
        foreach (var block in message.Content)
        {
            if (block.Value is BetaManagedAgentsTextBlock textBlock)
            {
                Console.Write(textBlock.Text);
            }
        }
    }
    else if (streamEvent.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
    {
        Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
    }
    else if (streamEvent.Value is BetaManagedAgentsSessionStatusIdleEvent)
    {
        Console.WriteLine("\n\nAgent finished.");
        break;
    }
}
示例代码
	stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
	defer stream.Close()

	// 在流打开后发送用户消息
	_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
		Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
			OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
				Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
					OfText: &anthropic.BetaManagedAgentsTextBlockParam{
						Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
					},
				}},
			},
		}},
	})
	if err != nil {
		panic(err)
	}

	// 处理流式传输事件
loop:
	for stream.Next() {
		switch event := stream.Current().AsAny().(type) {
		case anthropic.BetaManagedAgentsAgentMessageEvent:
			for _, block := range event.Content {
				if block.Type == "text" {
					fmt.Print(block.Text)
				}
			}
		case anthropic.BetaManagedAgentsAgentToolUseEvent:
			fmt.Printf("\n[Using tool: %s]\n", event.Name)
		case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
			fmt.Print("\n\nAgent finished.\n")
			break loop
		}
	}
	if err := stream.Err(); err != nil {
		panic(err)
	}
示例代码
try (var stream = client.beta().sessions().events().streamStreaming(session.id())) {
    // 在流打开后发送用户消息
    client.beta().sessions().events().send(session.id(), EventSendParams.builder()
        .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
            .addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
            .build())
        .build());

    // 处理流式传输事件
    loop:
    for (var event : stream) {
        switch (event.type().value()) {
            case AGENT_MESSAGE -> event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
            case AGENT_TOOL_USE -> IO.println("\n[Using tool: " + event.asAgentToolUse().name() + "]");
            case SESSION_STATUS_IDLE -> {
                IO.println("\n\nAgent finished.");
                break loop;
            }
        }
    }
}
示例代码
$stream = $client->beta->sessions->events->streamStream($session->id);

// 在流打开后发送用户消息
$client->beta->sessions->events->send(
    $session->id,
    events: [
        [
            'type' => 'user.message',
            'content' => [
                ['type' => 'text', 'text' => 'Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt'],
            ],
        ],
    ],
);

// 处理流式传输事件
foreach ($stream as $event) {
    match (true) {
        $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
            $event->content,
            static fn ($block) => $block instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
        ),
        $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentToolUseEvent => print("\n[Using tool: {$event->name}]\n"),
        $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent => print("\n\nAgent finished.\n"),
        default => null,
    };
    if ($event->type === 'session.status_idle') {
        break;
    }
}
示例代码
stream = client.beta.sessions.events.stream_events(session.id)

# 在流打开后发送用户消息
client.beta.sessions.events.send_(
  session.id,
  events: [{
    type: "user.message",
    content: [{type: "text", text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"}]
  }]
)

# 处理流式传输事件
stream.each do |event|
  case event
  when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
    event.content.each { print it.text if it.is_a?(Anthropic::Beta::Sessions::BetaManagedAgentsTextBlock) }
  when Anthropic::Beta::Sessions::BetaManagedAgentsAgentToolUseEvent
    puts "\n[Using tool: #{event.name}]"
  when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
    puts "\n\nAgent finished."
    break
  else
    # 忽略其他事件类型
  end
end

智能体会编写一个 Python 脚本,在沙箱中运行它,并验证输出文件已创建。您的输出类似如下:

示例代码
I'll create a Python script that generates the first 20 Fibonacci numbers and saves them to a file.
[Using tool: write]
[Using tool: bash]
The script ran successfully. Let me verify the output file.
[Using tool: bash]
fibonacci.txt contains the first 20 Fibonacci numbers (0 through 4181).

Agent finished.

运行过程

当您发送用户事件时,Claude Managed Agents 会:

  1. 配置沙箱:您的环境配置决定沙箱的构建方式。
  2. 运行智能体循环:Claude 根据您的消息决定使用哪些工具。
  3. 运行工具:文件写入、bash 命令和其他工具调用都在沙箱内运行。
  4. 流式传输事件:在智能体工作时,您会收到实时更新。
  5. 进入空闲状态:当智能体没有更多工作要做时,会发出 session.status_idle 事件。

构建完整应用

以下每个快速入门都将 Claude Managed Agents 与一个流行的聊天框架结合,构建出完整、可运行的应用程序。在每个示例中,框架负责渲染聊天界面,而托管会话在服务器端运行智能体循环:会话保存对话记录、在沙箱中运行工具,并流式传输由前端渲染的事件。

Chat SDK

一个使用 Vercel 的 Chat SDK 构建的浏览器聊天研究分析师。每个对话都是一个持久会话,在流式传输回复的同时,实时信息流会显示工具调用。更换 Chat SDK 适配器即可将同一处理程序迁移到 Slack、Teams、Discord 或 WhatsApp。

assistant-ui

一个使用 assistant-ui 基础组件构建的聊天式电子表格分析师。会话即线程列表,一个 reducer 将会话事件日志转换为消息和工具卡片,每条 bash 命令在运行前都会渲染一个内联的允许/拒绝关卡。

CopilotKit (AG-UI)

一个 CopilotKit 聊天中的个人理财助手。适用于 Claude Managed Agents 的 AG-UI 适配器将每个聊天线程映射到一个托管会话,并逐令牌流式传输回复,自定义工具会在对话中内联渲染交互式图表。

后续步骤

知识 wiki 快速入门

将文档语料库一次性提炼为知识 wiki,然后以极低的成本基于它回答重复的问题

文档内容持续同步更新