Guide

Strands Agents : moins d'échafaudage autour du modèle

Strands Agents est le toolkit open source d'AWS pour créer des agents : outils en simples fonctions, patterns multi-agents, sécurité, déploiement et comparaison.

L'équipe CodeWorlds13 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article10

Strands est un toolkit open source d'AWS pour construire des agents, qui repose sur une idée : moins on impose de choses au modèle à l'avance, mieux c'est. Vous fournissez un modèle, des instructions et un ensemble d'outils, puis vous lui laissez la décision de ce qu'il faut appeler et dans quel ordre.

Le projet est publié sous une licence permissive et, malgré son origine, il n'exige aucune infrastructure AWS. Il fonctionne avec des modèles de plusieurs fournisseurs, et l'intégration avec les services d'Amazon est un choix par défaut pratique, pas une condition d'utilisation.

Cette approche s'oppose aux bibliothèques qui construisent un graphe de flux explicite. Là-bas, vous décrivez le chemin ; ici, vous décrivez les possibilités et le modèle choisit le chemin. Les deux écoles ont leurs arguments, et je décris plus bas quand chacune l'emporte.

L'agent fonctionnel le plus simple

Bash
pip install strands-agents strands-agents-tools
Python
from strands import Agent, tool

@tool
def check_stock(sku: str) -> int:
    """Returns the number of units available in the warehouse for a product code."""
    return warehouse.count(sku)

@tool
def place_order(sku: str, units: int) -> str:
    """Places an order and returns its number."""
    return orders.create(sku, units)

agent = Agent(
    tools=[check_stock, place_order],
    system_prompt="You handle orders. Always check stock before placing one.",
)

print(agent("Order two pairs of shoes with code BT-42."))

Un outil est une fonction ordinaire avec un décorateur. Le nom, les types des arguments et la docstring deviennent le schéma que voit le modèle, donc il n'y a pas de fichier de définitions séparé à maintenir à côté du code.

C'est pratique, et ça a une conséquence à garder en tête dès le départ. La description d'une fonction cesse d'être un commentaire pour le développeur et devient une partie du prompt. Une phrase qui dit clairement quand appeler l'outil améliore la précision plus que n'importe quelle modification de l'instruction système, alors qu'une description du type « fonction auxiliaire pour le stock » n'apprend rien au modèle.

Une boucle qui tourne toute seule

Le toolkit prend en charge le cycle que vous écrivez à la main face à une API brute : envoyer la requête, lire la demande d'appel d'outil, exécuter la fonction, renvoyer le résultat, et recommencer jusqu'à la réponse finale.

Ça paraît mineur, jusqu'à ce qu'on compte combien de choses doivent être gérées correctement dans cette boucle. Les appels simultanés à plusieurs outils dans un même tour. Une erreur de fonction qui doit revenir au modèle sous forme de message plutôt que faire planter le programme. Une limite de tours qui protège contre le tournis en rond. Un historique de conversation tronqué dès qu'il dépasse la fenêtre de contexte.

Ce dernier point est le plus souvent oublié dans une implémentation faite maison. Une conversation grandit à chaque tour, puisqu'elle transporte tous les messages et résultats d'outils précédents, donc une longue exécution atteint soit la limite de contexte, soit un coût plusieurs fois supérieur à ce que vous aviez prévu. Le toolkit gère la troncature et le résumé de l'historique, et vérifier quelle stratégie il applique par défaut avant de passer en production est un bon investissement.

Le streaming fonctionne au niveau des événements : en plus de la réponse qui se forme, vous pouvez montrer à l'utilisateur que l'agent est en train de vérifier le stock de l'entrepôt. Sur une exécution d'une demi-minute, cette différence décide si quelqu'un attend ou non.

Patterns multi-agents

La version un a ajouté quatre façons de combiner des agents, et leurs différences méritent d'être comprises, car elles couvrent des besoins distincts.

L'agent comme outil est la variante la plus simple : un agent en appelle un autre exactement comme il appelle une fonction ordinaire. Elle convient à un découpage par spécialité, où un agent principal oriente la question vers le bon expert.

Un swarm est un groupe d'agents qui travaillent sur un problème commun avec la possibilité de se passer la main. Souple, mais le plus difficile à prévoir, car l'ordre de prise de parole émerge de l'exécution.

Un graphe est un arrangement déterministe : des nœuds reliés par des arêtes, exécutés selon leurs dépendances, où la sortie d'un nœud alimente l'entrée du suivant. C'est le choix pour les processus qui doivent s'exécuter à l'identique à chaque fois.

Un workflow décrit des tâches avec des dépendances déclarées explicitement, plus proche d'un ordonnanceur classique que d'une conversation.

Le conseil pratique rejoint celui des autres bibliothèques de cette catégorie : commencez par l'arrangement le plus simple que vous pouvez défendre. L'agent comme outil couvre étonnamment de cas, alors que le swarm paraît le plus intéressant et déçoit le plus souvent en production, puisque la même entrée produit des exécutions différentes.

Outils prêts à l'emploi et outils personnalisés

Un paquet séparé fournit des dizaines d'outils prêts à l'emploi, et savoir ce qui existe avant d'écrire vos propres équivalents est rentable.

L'ensemble couvre les opérations sur les fichiers, l'exécution de code, les requêtes HTTP, la gestion de la mémoire, le travail sur les images et les intégrations avec des services cloud. Pour un prototype, ça fait gagner une heure, et ça fournit au passage un bon modèle pour décrire vos propres fonctions.

Trois règles pour les outils personnalisés évitent le plus d'ennuis.

La première concerne les valeurs de retour. Une fonction doit renvoyer des données plutôt qu'une phrase toute faite pour l'utilisateur, car composer la réponse est le travail du modèle. Un outil qui renvoie « Désolé, je n'ai pas trouvé ce produit » au lieu d'une valeur vide prive le modèle de la possibilité de réagir de façon sensée et casse la réponse dans une autre langue.

La deuxième concerne les erreurs. Une exception levée dans un outil doit revenir au modèle sous forme de message, pour qu'il puisse corriger les arguments et réessayer. Un code qui fait tomber toute l'exécution à la première faute de frappe dans un nom de produit gaspille une capacité que cet arrangement offre gratuitement.

La troisième concerne le périmètre. Un outil qui fait une seule chose est choisi plus précisément qu'un outil à sept modes pilotés par un paramètre. Le modèle choisit d'après la description, et une description de sept modes à la fois est par nature floue.

Sécurité des outils

Cette partie mérite un traitement à part, car, quand le contrôle est confié au modèle, le risque ne ressemble pas à celui d'un flux explicite.

Les arguments passés à une fonction viennent d'un texte généré par le modèle, et le modèle lit aussi des données d'entrée, y compris du contenu récupéré à l'extérieur. Cela signifie qu'un document contenant une instruction cachée peut influencer quel outil est appelé et avec quoi.

Trois garde-fous règlent l'essentiel. Le premier est de séparer les outils de lecture et ceux qui modifient l'état, ces derniers exigeant une confirmation ou agissant sur un périmètre étroit et explicitement borné. Le deuxième est d'isoler tout ce qui exécute du code ou des commandes système, dans un environnement sans accès au réseau et avec une limite de temps. Le troisième est de passer des identifiants plutôt que des données sensibles, en substituant les vraies valeurs uniquement à l'intérieur de la fonction, hors de portée de la conversation.

Rappelez-vous aussi que les permissions d'un agent sont celles du processus dans lequel il tourne. Un agent lancé sous un rôle à large accès aux ressources cloud peut faire exactement ce que ce rôle autorise, quoi que vous ayez écrit dans les instructions système.

Modèles et portabilité

La bibliothèque ne vous enferme pas chez un seul fournisseur, ce qui mérite d'être noté dans un toolkit publié par un fournisseur cloud.

Au-delà des services d'Amazon, les modèles pris en charge incluent Claude, OpenAI, les offres de Google et des modèles exécutés en local via Ollama. Changer de fournisseur revient à remplacer l'objet modèle passé à l'agent.

Un protocole de communication entre agents de fournisseurs différents est aussi pris en charge, ce qui compte quand votre agent doit discuter avec celui de quelqu'un d'autre. La compatibilité entre ces standards est parfois partielle, donc vérifiez votre cas précis avant de l'inscrire dans un document d'architecture.

Cette portabilité a un usage pratique pour comparer les modèles. Le même agent exécuté avec trois modèles différents sur votre propre jeu de cas en dit plus que n'importe quel benchmark public, puisqu'il mesure votre tâche et non une tâche moyenne.

Sachez toutefois qu'un code portable ne signifie pas un comportement portable. Les modèles diffèrent par leur propension à appeler des outils, par la façon dont ils gèrent plusieurs appels dans un même tour et par leur réaction à une erreur renvoyée par une fonction. Une instruction système réglée pour un modèle peut donner de bien moins bons résultats après un changement de fournisseur, alors que vous n'avez pas touché une seule ligne de code. C'est une raison de plus pour laquelle un jeu de cas avec des résultats attendus est ici nécessaire plutôt que facultatif.

Déploiement et observabilité

Un agent est un objet Python ordinaire, donc le déploiement n'exige aucun runtime spécial. Il tourne dans une fonction serverless, dans un conteneur, sur un cluster ou dans un service managé conçu pour les agents, le code restant le même dans ce dernier cas.

Cette dernière propriété est plus pratique qu'il n'y paraît. Un agent exécuté en local et un agent dans un service managé sont le même code invoqué de la même manière, donc le développement local ne diffère pas de la production, ce qui supprime toute une classe de différences qui n'apparaissent qu'après un déploiement.

Distinguez ce service de l'ancien produit à console du même fournisseur, car les noms se confondent. Bedrock Agents permet d'assembler un agent en cliquant, sans code, mais il s'appelle désormais Agents Classic, il est fermé aux nouveaux comptes depuis le 30 juillet 2026 et son catalogue de modèles est gelé. Démarrer un projet sur ce cloud revient donc à choisir entre ce toolkit et le successeur de ce service, la voie Agents Classic étant fermée quelle que soit sa pertinence.

La télémétrie utilise un format très répandu, donc les exécutions se branchent sur les outils que l'équipe possède déjà. Une exécution apparaît comme un arbre : appels au modèle, appels d'outils, durées et consommation de tokens.

Trois mesures méritent d'être suivies dès le premier jour. Le nombre de tours par tâche dit si l'agent tourne en rond au lieu de finir. Le coût par tâche dit si la solution passe à l'échelle. La part des tâches menées à bien, mesurée sur un jeu de cas fixe, dit si une modification des instructions a amélioré quelque chose. Cette troisième est la seule qui permette de comparer deux versions d'un agent, et c'est celle qu'on vérifie le moins.

Strands face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
Strands AgentsTrès peu de code, déploiement dans les services AWSContrôle confié au modèle, moins de supervisionUne équipe sur une infrastructure AWS
LangGraphGraphe explicite, contrôle de l'état, diagnostic maturePlus de concepts et de code au départUn processus qui exige de la répétabilité
Microsoft Agent FrameworkUne variante .NET, des checkpointsAttraction vers AzureUne entreprise sur des technologies Microsoft
OpenAI Agents SDKConcepts minimaux, démarrage rapidePérimètre d'orchestration plus étroitUn agent simple avec des outils

La séparation tient à une question : qui décide de l'ordre des étapes. Si un processus a des étapes connues et doit s'exécuter à l'identique à chaque fois, un graphe explicite l'emporte, car il apporte de la répétabilité et un endroit à pointer quand quelque chose casse. Si la tâche est ouverte et qu'un plan rigide gêne, le contrôle piloté par le modèle donne un code plus court et de meilleurs résultats.

Le deuxième critère est l'infrastructure. Une équipe qui travaille dans les services d'Amazon obtient ici une intégration que les bibliothèques concurrentes n'ont pas, et c'est parfois décisif, quel que soit le reste.

Le troisième, comme toujours, est la question de la nécessité. Un agent avec trois outils et une seule étape, c'est un petit morceau de code qui appelle directement le modèle, sans bibliothèque intermédiaire. Une couche d'orchestration ne justifie sa place que lorsque vous avez besoin de gérer l'historique, les nouvelles tentatives, l'observabilité ou plusieurs agents qui travaillent en même temps.

Erreurs courantes

La première, ce sont des descriptions d'outils écrites pour un développeur. Le modèle ne voit que le nom, les types et la description, donc une phrase qui dit quand appeler une fonction compte plus que ce qu'elle fait.

La deuxième, c'est l'absence de limite de tours et de plafond de coût. Un agent en boucle fera des dizaines d'appels avant que quelqu'un s'en aperçoive, et un plafond est le seul mécanisme qui fonctionne sans votre attention.

La troisième, c'est d'ignorer la stratégie d'historique de conversation. Une longue exécution atteint soit la limite de contexte, soit un coût plusieurs fois supérieur à ce que vous aviez prévu.

La quatrième, c'est de confier au modèle un processus aux étapes connues. Le contrôle piloté par le modèle est un avantage sur les tâches ouvertes et un inconvénient quand l'ordre est de toute façon fixe.

La cinquième, ce sont des outils sans isolation. Une fonction qui exécute des commandes système ou modifie des données doit être soumise à une approbation ou à des contraintes, puisque les arguments viennent d'un texte généré par le modèle.

La sixième, c'est de migrer ou d'ajuster sans jeu de cas de test. Les agents ne renvoient pas de valeurs comparables avec un signe égal, donc sans résultats attendus, juger une modification relève de la devinette.

FAQ

Strands exige-t-il un compte AWS ?

Non. Le toolkit est ouvert et fonctionne avec des modèles de plusieurs fournisseurs, y compris des modèles exécutés en local. L'intégration avec les services d'Amazon est un choix par défaut pratique, pas une condition d'utilisation.

En quoi diffère-t-il de LangGraph ?

Par celui qui décide de l'ordre des étapes. LangGraph vous demande de décrire un graphe de flux ; ici, vous décrivez des outils et le modèle choisit le chemin. Un graphe donne de la répétabilité et un diagnostic plus facile, le contrôle piloté par le modèle donne un code plus court et de meilleurs résultats sur les tâches ouvertes.

Comment définit-on les outils ?

Comme des fonctions ordinaires avec un décorateur. Le nom, les types des arguments et la docstring forment le schéma que voit le modèle, donc il n'y a pas de fichier de définitions séparé à maintenir à côté du code.

Convient-il aux systèmes multi-agents ?

Oui, quatre arrangements sont disponibles : agent comme outil, swarm, graphe et workflow. Commencez par le premier, qui couvre la plupart des cas, car les arrangements plus libres sont plus difficiles à prévoir en production.

Comment savoir s'il convient à mon projet ?

Construisez-y un vrai processus de votre propre système et mesurez trois choses : le coût par exécution, le temps de réponse et la rapidité avec laquelle vous établissez la cause après une exécution en échec. La troisième mesure décide le plus souvent et c'est celle qu'on vérifie le moins.

La documentation se trouve sur le site du projet, et le code dans le dépôt GitHub.

À lire aussi