Claude Platform Docs
  • Messages
  • Agents gérés
  • Administration

Search...
⌘K
Premiers pas
AperçuDémarrage rapidePrototyper dans la Console
Définir votre agent
Configuration de l'agentOutilsConnecteur MCPPolitiques d'autorisationCompétences d'agent
Configurer l'environnement de l'agent
Configuration de l'environnement cloudRéférence de la sandbox cloud
Déléguer du travail à votre agent
Démarrer une sessionOpérations de sessionFlux d'événements de sessionS'abonner aux webhooksDéfinir les résultatsS'authentifier avec des coffres-forts
Gérer le contexte de l'agent
Accéder à GitHubJoindre et télécharger des fichiers
Orchestration avancée
Sessions multi-agentsDéploiements planifiés
Référence
Référence des agents gérés
Travailler avec des fichiers
API FilesPrise en charge des PDF
Compétences
AperçuBonnes pratiquesCompétences pour l'entreprise
MCP
Serveurs MCP distants
Claude sur les plateformes cloud
Claude Platform sur AWS

Log in
Démarrage rapide
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Claude Platform Docs

Solutions

  • AI agents
  • Code modernization
  • Coding
  • Customer support
  • Education
  • Financial services
  • Government
  • Life sciences

Partners

  • Claude on AWS
  • Claude on Google Cloud

Learn

  • Blog
  • Courses
  • Use cases
  • Connectors
  • Customer stories
  • Engineering at Anthropic
  • Events
  • Powered by Claude
  • Service partners
  • Startups program

Company

  • Anthropic
  • Careers
  • Economic Futures
  • Research
  • News
  • Responsible Scaling Policy
  • Security and compliance
  • Transparency

Learn

  • Blog
  • Courses
  • Use cases
  • Connectors
  • Customer stories
  • Engineering at Anthropic
  • Events
  • Powered by Claude
  • Service partners
  • Startups program

Help and security

  • Availability
  • Status
  • Support
  • Discord

Terms and policies

  • Privacy policy
  • Responsible disclosure policy
  • Terms of service: Commercial
  • Terms of service: Consumer
  • Usage policy
Agents gérés/Premiers pas

Premiers pas avec Claude Managed Agents

Créez votre premier agent autonome.

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 une présentation interactive ? Exécutez /claude-api managed-agents-onboard dans la dernière version de Claude Code pour une configuration guidée et des questions-réponses interactives.

Concepts fondamentaux

ConceptDescription
AgentLe modèle, l'invite système, les outils, les serveurs MCP et les compétences
EnvironnementConfiguration 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
SessionUne instance d'agent en cours d'exécution dans un environnement, effectuant une tâche spécifique et générant des sorties
ÉvénementsMessages échangés entre votre application et l'agent (tours de l'utilisateur, résultats d'outils, mises à jour de statut)

Prérequis

  • Un compte Console Anthropic
  • Une clé API

Installer la CLI

Vérifiez l'installation :

ant --version

Installer le SDK

Définissez votre clé API comme variable d'environnement :

export ANTHROPIC_API_KEY="your-api-key-here"

Créer votre première session



Toutes les requêtes à l'API Managed Agents nécessitent l'en-tête bêta managed-agents-2026-04-01. Le SDK définit automatiquement l'en-tête bêta.

  1. 1

    Créer un agent

    Créez un agent qui définit le modèle, l'invite système et les outils disponibles.

    ant beta:agents create \
      --name "Coding Assistant" \
      --model '{id: claude-opus-4-8}' \
      --system "You are a helpful coding assistant. Write clean, well-documented code." \
      --tool '{type: agent_toolset_20260401}'

    Le type d'outil agent_toolset_20260401 active l'ensemble complet des outils d'agent préconfigurés (bash, opérations sur les fichiers, recherche web, et plus encore). Consultez Outils pour la liste complète et les options de configuration par outil.

    Enregistrez l'agent.id retourné. Vous le référencerez dans chaque session que vous créerez.

  2. 2

    Créer un environnement

    Un environnement définit le bac à sable (sandbox) dans lequel votre agent s'exécute.

    ant beta:environments create \
      --name "quickstart-env" \
      --config '{type: cloud, networking: {type: unrestricted}}'

    Enregistrez l'environment.id retourné. Vous le référencerez dans chaque session que vous créerez.

    
    Pour exécuter le bac à sable sur votre propre infrastructure plutôt que sur un bac à sable cloud, consultez Bacs à sable auto-hébergés.
  3. 3

    Démarrer une session

    Créez une session qui référence votre agent et votre environnement.

    session = client.beta.sessions.create(
        agent=agent.id,
        environment_id=environment.id,
        title="Quickstart session",
    )
    
    print(f"Session ID: {session.id}")
  4. 4

    Envoyer un message et diffuser la réponse en streaming

    Ouvrez un flux, envoyez un événement utilisateur, puis traitez les événements au fur et à mesure de leur arrivée :

    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:
                        print(block.text, end="")
                case "agent.tool_use":
                    print(f"\n[Using tool: {event.name}]")
                case "session.status_idle":
                    print("\n\nAgent finished.")
                    break

    L'agent écrit un script Python, l'exécute dans le bac à sable et vérifie que le fichier de sortie a été créé. Votre sortie ressemble à ceci :

    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 bac à sable : La configuration de votre environnement détermine comment il est construit.
  2. Exécute la boucle de l'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 bac à sable.
  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.

Étapes suivantes

Définir votre agent

Créez des configurations d'agent réutilisables et versionnées


Configurer les environnements

Personnalisez les paramètres réseau et du bac à sable


Outils d'agent

Activez des outils spécifiques pour votre agent


Flux d'événements de session

Gérez les événements et orientez l'agent en cours d'exécution

Déploiements planifiés

Exécutez votre agent selon une planification cron récurrente

Was this page helpful?

  • Concepts fondamentaux
  • Prérequis
  • Installer la CLI
  • Installer le SDK
  • Créer votre première session
  • Ce qui se passe
  • Étapes suivantes