---
title: Erste Schritte mit Claude Managed Agents
url: https://platform.claude.com/docs/de/managed-agents/quickstart
description: Erstelle deinen ersten autonomen Agenten.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Dieser Leitfaden führt dich durch das Erstellen eines Agenten, das Einrichten einer Umgebung, das Starten einer Session und das Streaming von Agentenantworten.
**Lieber eine interaktive Anleitung?** Führe `/claude-api managed-agents-onboard` in der neuesten Version von [Claude Code](https://claude.com/product/claude-code) aus, um eine geführte Einrichtung und interaktive Fragen und Antworten zu erhalten.
## Kernkonzepte
| Konzept | Beschreibung |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agent** | Das Modell, der System-Prompt, Tools, MCP-Server und Skills |
| **Environment** | Konfiguration dafür, wo Sessions ausgeführt werden: eine von Anthropic verwaltete Cloud-Sandbox oder eine selbst gehostete Sandbox auf deiner eigenen Infrastruktur |
| **Session** | Eine laufende Agent-Instanz innerhalb eines Environments, die eine bestimmte Aufgabe ausführt und Ausgaben erzeugt |
| **Events** | Nachrichten, die zwischen deiner Anwendung und dem Agenten ausgetauscht werden (Benutzer-Turns, Tool-Ergebnisse, Statusaktualisierungen) |
## Voraussetzungen
* Ein [Claude Console-Konto](https://platform.claude.com)
* Ein [API-Key](https://platform.claude.com/settings/keys)
## Die CLI installieren
```bash
brew install anthropics/tap/ant
```
Lade für Linux-Umgebungen die Release-Binärdatei direkt herunter.
```bash
VERSION=1.42.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
```
Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
Du kannst die CLI auch mit `go install` aus dem Quellcode installieren. Erfordert Go 1.25 oder neuer.
```bash
go install github.com/anthropics/anthropic-cli/cmd/ant@latest
```
Die Binärdatei wird in `$(go env GOPATH)/bin` abgelegt. Füge dieses Verzeichnis zu deinem `PATH` hinzu, falls es dort noch nicht enthalten ist:
```bash
export PATH="$PATH:$(go env GOPATH)/bin"
```
Überprüfe die Installation:
```bash
ant --version
```
## Das SDK installieren
```bash
pip install anthropic
```
```bash
npm install @anthropic-ai/sdk
```
```groovy Gradle
implementation("com.anthropic:anthropic-java:2.73.0")
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```bash
dotnet add package Anthropic
```
```bash
bundle add anthropic
```
```bash
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
```
Lege deinen API-Key als Umgebungsvariable fest:
```bash
export ANTHROPIC_API_KEY="your-api-key-here"
```
## Deine erste Session erstellen
Erstelle einen Agenten, der das Modell, den System-Prompt und die verfügbaren Tools definiert.
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-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"}
]
}'
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```bash CLI
ant apply coding-assistant.md
```
```markdown
---
name: Coding Assistant
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
---
You are a helpful coding assistant. Write clean, well-documented code.
```
[`ant apply`](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/apply) gibt die ID des Agenten aus und speichert sie in `claude-lock.json`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```python Python
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"},
],
)
print(f"Agent ID: {agent.id}, version: {agent.version}")
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```typescript TypeScript
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" },
],
});
console.log(`Agent ID: ${agent.id}, version: ${agent.version}`);
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```csharp C#
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
{
Type = "agent_toolset_20260401",
},
],
});
Console.WriteLine($"Agent ID: {agent.ID}, version: {agent.Version}");
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```go Go
package main
import (
"context"
"fmt"
"github.com/anthropics/anthropic-sdk-go"
)
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{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
},
}},
})
if err != nil {
panic(err)
}
fmt.Printf("Agent ID: %s, version: %d\n", agent.ID, agent.Version)
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```java Java
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.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.BetaManagedAgentsStreamSessionEvents;
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()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.build())
.build());
IO.println("Agent ID: " + agent.id() + ", version: " + agent.version());
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```php PHP
use Anthropic\Client;
$client = new Client();
$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'],
],
);
echo "Agent ID: {$agent->id}, version: {$agent->version}\n";
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
```ruby Ruby
require "anthropic"
client = Anthropic::Client.new
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"}]
)
puts "Agent ID: #{agent.id}, version: #{agent.version}"
```
Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
Der Tool-Typ `agent_toolset_20260401` aktiviert den vollständigen Satz vorgefertigter Agenten-Tools (Bash, Dateioperationen, Websuche und mehr). Unter [Tools](https://platform.claude.com/docs/de/managed-agents/tools) findest du die vollständige Liste und die Konfigurationsoptionen für jedes Tool.
Eine Umgebung definiert die Sandbox, in der dein Agent läuft. Diese hier verwendet `limited` [Networking](https://platform.claude.com/docs/de/managed-agents/environments#networking) mit erlaubten Paketmanagern, sodass Code, der in der Sandbox läuft, öffentliche [Paket-Registries und Code-Hosts](https://platform.claude.com/docs/de/managed-agents/environments#package-manager-hosts) erreichen kann. Websuche und Web-Fetch laufen außerhalb der Sandbox, und dieser Schnellstart benötigt sie nicht. Bei `limited` Networking gilt die [`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)-Liste](https://platform.claude.com/docs/de/managed-agents/environments#networking) auch für sie. Sie liefern in dieser Umgebung keine Seiten oder Suchergebnisse, da sie keine Hosts auflistet. Liste für deinen eigenen Agenten die benötigten Hosts in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) auf.
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "quickstart-env",
"config": {
"type": "cloud",
"networking": {"type": "limited", "allow_package_managers": true}
}
}'
```
Speichere auch die zurückgegebene `environment.id`.
```bash CLI
ant apply environment.yaml
```
```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`](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/apply) speichert auch die ID der Umgebung in `claude-lock.json`. Um den Agenten und die Umgebung mit einem Befehl zu erstellen, übergib beide Dateien: `ant apply coding-assistant.md environment.yaml`.
```python Python
environment = client.beta.environments.create(
name="quickstart-env",
config={
"type": "cloud",
"networking": {"type": "limited", "allow_package_managers": True},
},
)
print(f"Environment ID: {environment.id}")
```
Speichere auch die zurückgegebene `environment.id`.
```typescript TypeScript
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}`);
```
Speichere auch die zurückgegebene `environment.id`.
```csharp C#
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}");
```
Speichere auch die zurückgegebene `environment.id`.
```go Go
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)
```
Speichere auch die zurückgegebene `environment.id`.
```java Java
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());
```
Speichere auch die zurückgegebene `environment.id`.
```php PHP
$environment = $client->beta->environments->create(
name: 'quickstart-env',
config: [
'type' => 'cloud',
'networking' => ['type' => 'limited', 'allow_package_managers' => true],
],
);
echo "Environment ID: {$environment->id}\n";
```
Speichere auch die zurückgegebene `environment.id`.
```ruby Ruby
environment = client.beta.environments.create(
name: "quickstart-env",
config: {type: "cloud", networking: {type: "limited", allow_package_managers: true}}
)
puts "Environment ID: #{environment.id}"
```
Speichere auch die zurückgegebene `environment.id`.
Dieser Schnellstart verwendet eine Cloud-Umgebung. Um zu entscheiden, ob du Tools stattdessen mit einer
[selbst gehosteten Sandbox](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes)
auf deiner eigenen Infrastruktur ausführen möchtest, siehe
[Eine Agent-Umgebung auswählen](https://platform.claude.com/docs/de/managed-agents/choosing-an-environment)
.
Erstelle eine Session, die deinen Agenten und deine Umgebung referenziert.
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"agent": "'"$AGENT_ID"'",
"environment_id": "'"$ENVIRONMENT_ID"'",
"title": "Quickstart session"
}'
```
```bash CLI
ant beta:sessions create \
--agent "$AGENT_ID" \
--environment-id "$ENVIRONMENT_ID" \
--title "Quickstart session"
```
```python Python
session = client.beta.sessions.create(
agent=agent.id,
environment_id=environment.id,
title="Quickstart session",
)
print(f"Session ID: {session.id}")
```
```typescript TypeScript
const session = await client.beta.sessions.create({
agent: agent.id,
environment_id: environment.id,
title: "Quickstart session",
});
console.log(`Session ID: ${session.id}`);
```
```csharp C#
var session = await client.Beta.Sessions.Create(new()
{
Agent = agent.ID,
EnvironmentID = environment.ID,
Title = "Quickstart session",
});
Console.WriteLine($"Session ID: {session.ID}");
```
```go Go
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)
```
```java Java
var session = client.beta().sessions().create(SessionCreateParams.builder()
.agent(agent.id())
.environmentId(environment.id())
.title("Quickstart session")
.build());
IO.println("Session ID: " + session.id());
```
```php PHP
$session = $client->beta->sessions->create(
agent: $agent->id,
environmentID: $environment->id,
title: 'Quickstart session',
);
echo "Session ID: {$session->id}\n";
```
```ruby Ruby
session = client.beta.sessions.create(
agent: agent.id,
environment_id: environment.id,
title: "Quickstart session"
)
puts "Session ID: #{session.id}"
```
Öffne einen Stream, sende ein User-Event und verarbeite dann die Events, sobald sie eintreffen:
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
```python Python
with client.beta.sessions.events.stream(session.id) as stream:
# Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
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",
},
],
},
],
)
# Verarbeite Streaming-Events
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
```
```typescript TypeScript
const stream = await client.beta.sessions.events.stream(session.id);
// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
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",
},
],
},
],
});
// Verarbeite Streaming-Events
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;
}
}
```
```csharp C#
var stream = client.Beta.Sessions.Events.StreamStreaming(session.ID);
// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
await client.Beta.Sessions.Events.Send(session.ID, new()
{
Events =
[
new BetaManagedAgentsUserMessageEventParams
{
Type = "user.message",
Content =
[
new BetaManagedAgentsTextBlock
{
Type = "text",
Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
],
},
],
});
// Verarbeite Streaming-Events
await foreach (var ev in stream)
{
if (ev.Value is BetaManagedAgentsAgentMessageEvent message)
{
foreach (var block in message.Content)
{
if (block.Value is BetaManagedAgentsTextBlock textBlock)
{
Console.Write(textBlock.Text);
}
}
}
else if (ev.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
{
Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
}
else if (ev.Value is BetaManagedAgentsSessionStatusIdleEvent)
{
Console.WriteLine("\n\nAgent finished.");
break;
}
}
```
```go Go
stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
defer stream.Close()
// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
OfText: &anthropic.BetaManagedAgentsTextBlockParam{
Type: anthropic.BetaManagedAgentsTextBlockTypeText,
Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
}},
},
}},
})
if err != nil {
panic(err)
}
// Verarbeite Streaming-Events
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)
}
```
```java Java
try (var stream = client.beta().sessions().events().streamStreaming(session.id())) {
// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
client.beta().sessions().events().send(session.id(), EventSendParams.builder()
.addEvent(BetaManagedAgentsUserMessageEventParams.builder()
.type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
.addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
.build())
.build());
// Verarbeite Streaming-Events
loop:
for (var event : (Iterable) stream.stream()::iterator) {
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;
}
}
}
}
```
```php PHP
$stream = $client->beta->sessions->events->streamStream($session->id);
// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
$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'],
],
],
],
);
// Verarbeite Streaming-Ereignisse
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;
}
}
```
```ruby Ruby
stream = client.beta.sessions.events.stream_events(session.id)
# Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
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"}]
}]
)
# Verarbeite Streaming-Events
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
# ignoriere andere Event-Typen
end
end
```
Der Agent schreibt ein Python-Skript, führt es in der Sandbox aus und überprüft, ob die Ausgabedatei erstellt wurde. Deine Ausgabe sieht ungefähr so aus:
```text wrap
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.
```
## Was passiert
Wenn du ein User-Event sendest, führt Claude Managed Agents Folgendes aus:
1. **Stellt eine Sandbox bereit:** Deine Umgebungskonfiguration bestimmt, wie sie aufgebaut wird.
2. **Führt die Agentenschleife aus:** Claude bestimmt anhand deiner Nachricht, welche Tools verwendet werden.
3. **Führt Tools aus:** Dateischreibvorgänge, bash-Befehle und andere Tool-Aufrufe laufen innerhalb der Sandbox.
4. **Streamt Events:** Du erhältst Echtzeit-Updates, während der Agent arbeitet.
5. **Geht in den Leerlauf:** Der Agent sendet ein `session.status_idle`-Event, wenn er nichts mehr zu tun hat.
## Eine vollständige App erstellen
Jeder dieser Quickstarts kombiniert Claude Managed Agents mit einem beliebten Chat-Framework zu einer vollständigen, lauffähigen Anwendung. In jedem davon rendert das Framework die Chat-Oberfläche, während eine verwaltete Session die Agentenschleife serverseitig ausführt: Die Session hält das Transkript, führt Tools in einer Sandbox aus und streamt Events, die das Frontend rendert.
Ein Recherche-Analyst in einem Browser-Chat, erstellt mit dem Chat SDK von Vercel. Jede Unterhaltung ist eine persistente Session, die ihre Antwort streamt, während ein Live-Feed die Tool-Aufrufe anzeigt. Durch Austauschen des Chat-SDK-Adapters lässt sich derselbe Handler auf Slack, Teams, Discord oder WhatsApp übertragen.
Ein Tabellenkalkulations-Analyst in einem Chat, der aus assistant-ui-Primitiven aufgebaut ist. Sessions bilden die Thread-Liste, ein Reducer wandelt das Session-Event-Log in Nachrichten und Tool-Karten um, und jeder bash-Befehl rendert vor seiner Ausführung eine Inline-Abfrage zum Erlauben/Ablehnen.
Ein persönlicher Finanzassistent in einem CopilotKit-Chat. Der AG-UI-Adapter für Claude Managed Agents ordnet jeden Chat-Thread einer verwalteten Session zu und streamt Antworten Token für Token, und benutzerdefinierte Tools rendern interaktive Diagramme inline in der Unterhaltung.
## Nächste Schritte
Erstelle wiederverwendbare, versionierte Agentenkonfigurationen
Passe Netzwerk- und Sandbox-Einstellungen an
Aktiviere bestimmte Tools für deinen Agenten
Verarbeite Events und steuere den Agenten während der Ausführung
Führe deinen Agenten nach einem wiederkehrenden Cron-Zeitplan aus
Destilliere einen Dokumentenkorpus einmalig in ein Wissens-Wiki und beantworte daraus wiederkehrende Fragen zu einem Bruchteil der Kosten