Claude Managed Agents : Anthropic simplifie l'IA autonome

Claude Managed Agents : une nouvelle ère pour les agents autonomes

Le 8 avril 2026, Anthropic a introduit en version bêta publique Claude Managed Agents, une infrastructure révolutionnaire qui permet d'exécuter des agents autonomes en déplaçant la charge d'exécution des développeurs vers un environnement hébergé. Ce système offre une solution clé en main où les développeurs peuvent définir un agent, configurer ses autorisations, et laisser Anthropic gérer l'exécution, éliminant ainsi le besoin de provisionner des serveurs ou de coder des logiques d'isolation.

Concepts clés de Claude Managed Agents

Claude Managed Agents repose sur quatre concepts fondamentaux :

• Agent : Il s'agit de la définition de l'agent, incluant le modèle, le prompt système, les connexions aux serveurs MCP et les compétences.
• Environnement : C'est l'espace où les sessions s'exécutent, soit dans un bac à sable cloud géré par Anthropic, soit auto-hébergé.
• Session : Une instance active d'un agent dans un environnement, accomplissant une tâche spécifique avec son propre système de fichiers et flux d'événements.
• Événements : Les messages échangés entre l'application et l'agent, incluant les interactions utilisateur et les résultats d'outils.

Tarification basée sur la consommation

La tarification de Claude Managed Agents est transparente, basée sur la consommation des tokens API Claude et le temps d'exécution actif. Les utilisateurs paient pour les tokens utilisés, un coût de 0,08 $ par heure de session active, et 10 $ par 1 000 recherches web. Le temps d'attente n'est pas facturé, ce qui aligne les coûts sur l'utilisation réelle.

Fonctionnalités avancées pour une gestion optimisée

Claude Managed Agents offre plusieurs fonctionnalités clés :

• Sandboxing sécurisé : Les agents opèrent dans des environnements sécurisés, avec une gestion des outils et des secrets par Anthropic.
• Sessions autonomes de longue durée : Les agents peuvent fonctionner pendant de longues périodes, avec une persistance des sessions même en cas de déconnexion réseau.
• Conception avec état : Les sessions conservent l'historique des conversations et l'état du bac à sable, bien que cela exclue la couverture Zero Data Retention et HIPAA BAA en raison de la persistance des sessions. Vous pouvez toutefois supprimer des sessions et des fichiers téléchargés à tout moment via l'API.
• Outils intégrés : Les agents ont accès à des commandes shell, à la recherche web, et peuvent se connecter à des outils externes via les serveurs MCP.
• Gouvernance et traçabilité : Les autorisations définies permettent une gestion précise des outils et des données accessibles par les agents.

Innovations récentes

Anthropic a récemment introduit trois fonctionnalités innovantes :

• Rêver : Un processus qui permet aux agents d'examiner leur travail passé pour s'améliorer. Ce processus, semblable à la consolidation de la mémoire dans le cerveau, aide à identifier les erreurs récurrentes, les flux de travail utiles et les préférences partagées par l'équipe.
• Résultats : Les agents travaillent vers un objectif défini, avec une évaluation séparée de la sortie pour des révisions automatiques. Un évaluateur indépendant évalue la sortie dans sa propre fenêtre de contexte, signalant les problèmes et invitant l'agent à réviser sans nécessiter une révision humaine pour chaque tentative.
• Orchestration multi-agents : Un agent principal peut déléguer des tâches à des sous-agents spécialisés, facilitant un travail parallèle et traçable. Ces agents travaillent en parallèle, partagent des fichiers, rendent compte au principal et laissent un flux de travail traçable dans la Console.

Mise en pratique : créer un agent

Pour créer un agent, il faut d'abord un compte Anthropic Console et une clé API. Après installation des outils nécessaires, vous pouvez définir un agent avec ses modèles et outils, créer un environnement d'exécution, et lancer une session pour accomplir des tâches spécifiques. Le script Python fourni permet de gérer ces étapes et de suivre l'exécution en temps réel.

Étape 0 : Prérequis

Vous aurez besoin d'un compte Anthropic Console et d'une clé API. Définissez la clé comme une variable d'environnement :

export ANTHROPIC_API_KEY="votre-clé-api-ici"

Ensuite, installez le CLI et le SDK :

brew install anthropics/tap/ant

Toutes les demandes d'agents gérés nécessitent l'en-tête managed-agents-2026-04-01 en version bêta, mais le SDK le définit automatiquement pour vous.

pip install anthropic

Étape 1 : Créer un agent

La définition de l'agent est l'endroit où vous définissez le modèle, le prompt système et les outils. Le type d'outil agent_toolset_20260401 active l'ensemble complet préconstruit.

ant beta:agents create \
--name "Assistant de codage" \
--model '{"id":"claude-haiku-4-5"}' \
--system "Vous êtes un assistant de codage utile. Écrivez un code propre et bien documenté." \
--tool '{"type":"agent_toolset_20260401"}'

Sauvegardez l'agent.id retourné. Vous le référencerez chaque fois que vous démarrerez une session.

Étape 2 : Créer un environnement

L'environnement est le modèle de conteneur dans lequel vos sessions s'exécutent.

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

Étape 3 : Exécuter une session

Une session est l'endroit où l'agent et l'environnement se rejoignent et effectuent réellement du travail. Le script Python ci-dessous en crée une, lui attribue une tâche et diffuse les événements vers votre terminal.

from anthropic import Anthropic
import os

# Lit ANTHROPIC_API_KEY depuis votre environnement.
# Assurez-vous d'avoir exécuté : export ANTHROPIC_API_KEY="votre-clé-api-ici"
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"].strip())

# IDs retournés par vos commandes `ant beta:agents create` et
# `ant beta:environments create`.
AGENT_ID = "VOTRE_AGENT_ID"
ENVIRONMENT_ID = "VOTRE_ENV_ID"

# 1. Créez une session qui référence l'agent + l'environnement.
session = client.beta.sessions.create(
    environment_id=ENVIRONMENT_ID,
    title="Session de démarrage rapide"
)
print(f"ID de session : {session.id}\n")

# 2. Ouvrez un flux, envoyez la tâche et traitez les événements au fur et à mesure qu'ils arrivent.
with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        {
            "type": "user.message",
            "content": "Créez un script Python qui trouve les 50 premiers nombres premiers, les enregistre dans primes.txt (un par ligne) et imprime le plus grand nombre premier et la somme de tous les 50 nombres premiers."
        }
    )
    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[Utilisation de l'outil : {event.name}]")
            case "session.status_idle":
                print("\n\nL'agent a terminé.")

Ce que fait le script dans l'ordre :

• Crée une session qui référence votre AGENT_ID de l'étape 1 et ENVIRONMENT_ID de l'étape 2, ce qui lie un modèle et des outils (l'agent) à un bac à sable d'exécution (l'environnement).

• Ouvre un flux d'événements et envoie un user.message décrivant la tâche que vous souhaitez que l'agent effectue.

• Itère sur les événements au fur et à mesure qu'ils arrivent, imprimant chaque agent.message, enregistrant chaque agent.tool_use que l'agent invoque à l'intérieur du bac à sable, et sortant sur session.status_idle lorsque l'exécution est terminée.

En arrière-plan, l'agent écrit le script, l'exécute à l'intérieur du conteneur, puis vérifie la sortie.