---
title: Premiers pas avec Claude Managed Agents
url: https://platform.claude.com/docs/fr/managed-agents/quickstart
description: Créez votre premier agent autonome.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Ce guide vous accompagne dans la création d'un agent, la configuration d'un environnement, le démarrage d'une session et le streaming des réponses de l'agent.
**Vous préférez un parcours interactif ?** Exécutez `/claude-api managed-agents-onboard` dans la dernière version de [Claude Code](https://claude.com/product/claude-code) pour bénéficier d'une configuration guidée et de réponses interactives à vos questions.
## Concepts fondamentaux
| Concept | Description |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agent** | Le modèle, l'invite système, les outils, les serveurs MCP et les compétences |
| **Environnement** | Configuration de l'endroit où les sessions s'exécutent : un bac à sable cloud géré par Anthropic, ou un bac à sable auto-hébergé sur votre propre infrastructure |
| **Session** | Une instance d'agent en cours d'exécution au sein d'un environnement, effectuant une tâche spécifique et générant des sorties |
| **Événements** | Messages échangés entre votre application et l'agent (tours de l'utilisateur, résultats d'outils, mises à jour de statut) |
## Prérequis
* Un [compte Claude Console](https://platform.claude.com)
* Une [clé API](https://platform.claude.com/settings/keys)
## Installer la CLI
```bash
brew install anthropics/tap/ant
```
Pour les environnements Linux, téléchargez directement le binaire de la version publiée.
```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
```
Vous trouverez toutes les versions sur la [page des versions GitHub](https://github.com/anthropics/anthropic-cli/releases).
Vous pouvez également installer la CLI à partir des sources à l'aide de `go install`. Nécessite Go 1.25 ou une version ultérieure.
```bash
go install github.com/anthropics/anthropic-cli/cmd/ant@latest
```
Le binaire est placé dans `$(go env GOPATH)/bin`. Ajoutez-le à votre `PATH` s'il n'y figure pas déjà :
```bash
export PATH="$PATH:$(go env GOPATH)/bin"
```
Vérifiez l'installation :
```bash
ant --version
```
## Installer le SDK
```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"
```
Définissez votre clé API comme variable d'environnement :
```bash
export ANTHROPIC_API_KEY="your-api-key-here"
```
## Créer votre première session
Créez un agent qui définit le modèle, le « system prompt » (invite système) et les outils disponibles.
```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"}
]
}'
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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/fr/cli-sdks-libraries/cli/apply) affiche l'ID de l'agent et l'enregistre dans `claude-lock.json`. Vous y ferez référence dans chaque session que vous créerez.
```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}")
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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}`);
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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}");
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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)
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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());
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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";
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
```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}"
```
Enregistrez l'`agent.id` renvoyé. Vous y ferez référence dans chaque session que vous créerez.
Le type d'outil `agent_toolset_20260401` active l'ensemble complet des outils d'agent prédéfinis (bash, opérations sur les fichiers, recherche web, et plus encore). Consultez [Outils](https://platform.claude.com/docs/fr/managed-agents/tools) pour la liste complète et les options de configuration propres à chaque outil.
Un environnement définit le « sandbox » (bac à sable) dans lequel votre agent s'exécute. Celui-ci utilise une [mise en réseau](https://platform.claude.com/docs/fr/managed-agents/environments#networking) `limited` avec les gestionnaires de paquets autorisés, de sorte que le code exécuté dans le sandbox peut atteindre les [registres de paquets et hébergeurs de code](https://platform.claude.com/docs/fr/managed-agents/environments#package-manager-hosts) publics. La recherche web et la récupération web s'exécutent en dehors du sandbox, et ce guide de démarrage rapide n'en a pas besoin. Avec une mise en réseau `limited`, la [liste `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)](https://platform.claude.com/docs/fr/managed-agents/environments#networking) s'applique également à elles. Elles ne renvoient aucune page ni aucun résultat de recherche dans cet environnement, car celui-ci ne répertorie aucun hôte. Pour votre propre agent, répertoriez les hôtes dont il a besoin dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).
```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}
}
}'
```
Enregistrez également l'`environment.id` renvoyé.
```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/fr/cli-sdks-libraries/cli/apply) enregistre également l'ID de l'environnement dans `claude-lock.json`. Pour créer l'agent et l'environnement en une seule commande, passez les deux fichiers : `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}")
```
Enregistrez également l'`environment.id` renvoyé.
```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}`);
```
Enregistrez également l'`environment.id` renvoyé.
```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}");
```
Enregistrez également l'`environment.id` renvoyé.
```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)
```
Enregistrez également l'`environment.id` renvoyé.
```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());
```
Enregistrez également l'`environment.id` renvoyé.
```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";
```
Enregistrez également l'`environment.id` renvoyé.
```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}"
```
Enregistrez également l'`environment.id` renvoyé.
Ce guide de démarrage rapide utilise un environnement cloud. Pour décider s'il convient plutôt d'exécuter les outils sur votre propre infrastructure avec un
[sandbox auto-hébergé](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes)
, consultez
[Choisir un environnement d'agent](https://platform.claude.com/docs/fr/managed-agents/choosing-an-environment)
.
Créez une session qui fait référence à votre agent et à votre environnement.
```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}"
```
Ouvrez un flux, envoyez un événement utilisateur, puis traitez les événements au fur et à mesure de leur arrivée :
Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le [SDK Claude](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour l'exécuter.
Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le [SDK Claude](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour l'exécuter.
```python Python
with client.beta.sessions.events.stream(session.id) as stream:
# Envoyer le message utilisateur après l'ouverture du flux
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",
},
],
},
],
)
# Traiter les événements de streaming
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);
// Envoyer le message utilisateur après l'ouverture du stream
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",
},
],
},
],
});
// Traiter les événements de streaming
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);
// Envoyer le message utilisateur après l'ouverture du flux
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",
},
],
},
],
});
// Traiter les événements de streaming
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()
// Envoyer le message utilisateur après l'ouverture du flux
_, 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)
}
// Traiter les événements en streaming
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())) {
// Envoyer le message utilisateur après l'ouverture du stream
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());
// Traiter les événements de streaming
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);
// Envoyer le message utilisateur après l'ouverture du 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'],
],
],
],
);
// Traiter les événements de streaming
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)
# Envoyer le message utilisateur après l'ouverture du 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"}]
}]
)
# Traiter les événements de streaming
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
# ignorer les autres types d'événements
end
end
```
L'agent écrit un script Python, l'exécute dans le sandbox et vérifie que le fichier de sortie a bien été créé. Votre sortie ressemble à ceci :
```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.
```
## Ce qui se passe
Lorsque vous envoyez un événement utilisateur, Claude Managed Agents :
1. **Provisionne un sandbox :** la configuration de votre environnement détermine la manière dont il est construit.
2. **Exécute la boucle d'agent :** Claude détermine quels outils utiliser en fonction de votre message.
3. **Exécute les outils :** les écritures de fichiers, les commandes bash et les autres appels d'outils s'exécutent à l'intérieur du sandbox.
4. **Diffuse les événements en streaming :** vous recevez des mises à jour en temps réel pendant que l'agent travaille.
5. **Passe en veille :** l'agent émet un événement `session.status_idle` lorsqu'il n'a plus rien à faire.
## Créer une application complète
Chacun de ces guides de démarrage rapide associe Claude Managed Agents à un framework de chat populaire pour constituer une application complète et exécutable. Dans chacun d'eux, le framework affiche l'interface de chat tandis qu'une session gérée exécute la boucle d'agent côté serveur : la session conserve la transcription, exécute les outils dans un sandbox et diffuse en streaming les événements que le front-end affiche.
Un analyste de recherche dans un chat de navigateur construit avec le Chat SDK de Vercel. Chaque conversation correspond à une session persistante qui diffuse sa réponse en streaming tandis qu'un flux en direct affiche les appels d'outils. Remplacer l'adaptateur Chat SDK permet de déplacer le même gestionnaire vers Slack, Teams, Discord ou WhatsApp.
Un analyste de feuilles de calcul dans un chat construit à partir des primitives assistant-ui. Les sessions constituent la liste des fils de discussion, un seul reducer transforme le journal d'événements de la session en messages et en cartes d'outils, et chaque commande bash affiche une barrière Autoriser/Refuser en ligne avant de s'exécuter.
Un assistant de finances personnelles dans un chat CopilotKit. L'adaptateur AG-UI pour Claude Managed Agents associe chaque fil de discussion à une session gérée et diffuse les réponses en streaming token par token, et des outils personnalisés affichent des graphiques interactifs directement dans la conversation.
## Étapes suivantes
Créez des configurations d'agent réutilisables et versionnées
Personnalisez les paramètres réseau et de sandbox
Activez des outils spécifiques pour votre agent
Gérez les événements et orientez l'agent en cours d'exécution
Exécutez votre agent selon une planification cron récurrente
Distillez une seule fois un corpus de documents en un wiki de connaissances, puis répondez aux questions récurrentes à partir de celui-ci pour une fraction du coût