top of page

Les agents Amazon Bedrock bénéficient d’une architecture de référence Spring AI

il y a 43 minutes
14 min de lecture

AWS a publié le 11 novembre une architecture de référence pour les agents Amazon Bedrock, reliant des applications Java à des outils, à la mémoire conversationnelle et à un déploiement géré. Ses exemples transposent des modèles de développement Spring familiers aux applications d’agents. Ils maintiennent toutefois une distinction importante : déployer un agent ne prouve pas que ses décisions sont fiables.

Cette publication s’adresse aux équipes Java d’entreprise qui déterminent quelle part de leur infrastructure logicielle existante elles peuvent conserver en adoptant des agents. Spring AI, un framework reliant les applications Spring aux modèles d’IA et aux services associés, fournit la couche applicative. Amazon Bedrock AgentCore, ensemble de services AWS destinés à héberger et exploiter des agents, fournit l’infrastructure de support.

La tension centrale oppose l’ingénierie applicative familière à un comportement décisionnel moins connu. Un service peut traiter correctement des requêtes au niveau réseau tout en choisissant une action inappropriée. AWS propose un point de départ pratique pour relier ces couches, mais les acheteurs ont toujours besoin de preuves concernant les résultats, les autorisations et la reprise après incident.

Ce qui change pour les agents Amazon Bedrock

AWS a fourni une référence d’implémentation, plutôt que d’annoncer un nouveau modèle Bedrock ou d’établir la fiabilité d’un fonctionnement autonome.

L’architecture d’agent Java couvre un assistant de voyage et un système de traitement de documents. Les exemples relient l’appel d’outils, la mémoire conversationnelle, la résilience et le déploiement. L’appel d’outils signifie que le modèle demande une fonction applicative, exécutée par le logiciel qui l’entoure.

Le système documentaire utilise des règles de routage et d’évaluation. L’exécution parallèle par des spécialistes reste une extension facultative, et son point de terminaison de traitement par lots traite les documents séquentiellement. Le service de garde-fou de démonstration diffère également des Bedrock Guardrails de production. Le traçage distribué et une boucle de retour d’évaluation automatisée nécessitent une implémentation supplémentaire.

Ces limites comptent, car les diagrammes d’architecture condensent des distinctions qui deviennent déterminantes lors des achats. Un diagramme peut montrer une connexion à un service sans établir que chaque déploiement le configure. Un composant peut prendre en charge une capacité sans que l’exemple n’exerce cette capacité dans des conditions réalistes.

Pour les développeurs, la référence réduit l’incertitude sur l’emplacement du code applicatif. Pour les responsables de l’ingénierie, elle fournit un élément concret à examiner avant de choisir un framework. Pour les évaluateurs de sécurité, elle fait apparaître des questions qu’une démonstration de chat soignée masque souvent.

Une architecture de référence joue un rôle probant différent d’un rapport de déploiement chez un client. Elle explique une approche et fournit des éléments d’implémentation. Elle n’établit pas les performances pour les types de documents, les contrôles d’accès, les conditions d’exploitation ou les exceptions métier d’une organisation.

Prenons un assistant interne qui récupère des informations de voyage et propose un itinéraire. Une réponse convaincante démontre une interaction utile. Elle ne démontre pas l’autorisation d’acheter des billets, de modifier des réservations ou de divulguer les préférences d’un autre employé.

La même distinction s’applique au traitement de documents. Extraire un champ avec succès diffère de l’approbation d’une transaction fondée sur ce champ. Les équipes applicatives doivent identifier où s’arrête l’interprétation et où commence l’action à conséquences.

Cette publication est donc pertinente au-delà de la syntaxe Java. Elle oriente la discussion vers des limites applicatives que les équipes d’entreprise peuvent examiner. L’architecture offre à ces équipes un vocabulaire de départ, tandis que leurs propres charges de travail doivent fournir les critères d’acceptation.

Le changement immédiat est donc pratique plutôt qu’universel. Les développeurs disposent d’un autre chemin concret entre une interaction avec un modèle et un service déployé. Ils doivent encore décider quelles décisions méritent l’automatisation, lesquelles exigent une confirmation et lesquelles doivent rester hors de l’autorité de l’agent.

Considérer les exemples comme des points de départ inspectables clarifie leur valeur. Les équipes peuvent examiner chaque limite avant d’accepter la promesse plus large d’un fonctionnement autonome.

Les équipes Java peuvent conserver leur stack, mais héritent de nouvelles décisions

La pression repose sur les responsables applicatifs, qui doivent transformer les démonstrations d’agents en services métier responsables.

Le dépôt d’exemples d’agents contient des backends Java et des interfaces navigateur distinctes. Son déploiement documenté construit des images de conteneur ARM64, les stocke dans Amazon Elastic Container Registry et provisionne AgentCore Runtime via Terraform.

Une image de conteneur regroupe le code applicatif et ses dépendances pour l’exécution. Terraform décrit l’infrastructure sous forme de configuration. Ces choix rendent le chemin de déploiement reconnaissable pour les équipes qui exploitent déjà des applications cloud.

Toutefois, les exigences de configuration du dépôt diffèrent de certaines parties du guide du blog, notamment concernant les versions des outils frontend et d’infrastructure. Les développeurs devraient examiner les exigences correspondant à la révision qu’ils ont choisie. Une liste de prérequis copiée ne devrait pas remplacer l’examen du logiciel réellement déployé.

Le principal avantage organisationnel réside dans la continuité. Une équipe peut évaluer un agent à travers ses processus existants de revue de code, d’approbation des mises en production et de responsabilité opérationnelle. Cela réduit la nécessité d’introduire un processus de développement distinct simplement parce qu’un modèle intervient.

Cette continuité crée également un risque de fausse familiarité. Le comportement d’une application conventionnelle suit souvent des branches explicites écrites par des développeurs. Un agent introduit des actions choisies par le modèle au sein de ces branches. Des mécanismes de déploiement familiers ne rendent pas ces choix aussi prévisibles.

Une équipe plateforme fait donc face à une question d’examen différente. Vérifier que l’application démarre est nécessaire, mais insuffisant. Les évaluateurs doivent aussi comprendre quelles actions le modèle peut demander et ce que le code environnant autorise.

Par exemple, un assistant destiné aux employés peut accéder à un système de notes de frais. Consulter les règles de remboursement et soumettre une demande de remboursement représentent des autorisations différentes. Donner aux deux opérations la même interface conversationnelle ne devrait pas effacer leurs conséquences distinctes.

Les chefs de produit ont une responsabilité connexe. Ils doivent décrire les résultats autorisés du service avec suffisamment de précision pour que les ingénieurs puissent les tester. « Gérer les questions de frais » laisse davantage d’ambiguïté que l’identification des requêtes prises en charge et des points d’approbation requis.

Les équipes d’exploitation héritent d’une autre limite. Un agent peut échouer en raison d’une infrastructure indisponible, d’une interprétation erronée, d’une sélection d’outil inappropriée ou d’une exception métier non résolue. Ces échecs exigent des réponses différentes, même lorsque les utilisateurs les décrivent tous comme une mauvaise réponse.

Les équipes de support ont également besoin de journaux expliquant ce qui s’est passé. Une réponse finale seule peut masquer une recherche échouée, une action répétée ou une escalade infructueuse. Des preuves opérationnelles utiles doivent relier la demande de l’utilisateur au comportement applicatif qui en résulte.

Pour les équipes qui documentent ces décisions, une base de connaissances interrogeable peut maintenir accessibles les hypothèses de conception et les conseils opérationnels. Cette documentation aide les évaluateurs et les mainteneurs ; elle doit rester distincte de la mémoire conversationnelle de l’agent.

L’opportunité architecturale consiste à préserver les responsabilités établies tout en ajoutant une nouvelle couche décisionnelle. Le défi de gestion consiste à garantir que quelqu’un est explicitement responsable de cette couche. Dans le cas contraire, le comportement du modèle peut se retrouver entre le développement applicatif, les opérations d’infrastructure et la politique métier.

Cette question de responsabilité devrait précéder une autonomie plus étendue. Élargir les accès avant d’attribuer les responsabilités rend les incidents ultérieurs plus difficiles à diagnostiquer et à résoudre.

L’appel d’outils fait de l’application la limite d’exécution

Le modèle peut proposer une action, mais le code applicatif doit déterminer si cette action est acceptable.

La documentation sur l’appel d’outils de Spring AI décrit une boucle dans laquelle le modèle demande des fonctions et le framework exécute les outils correspondants. Les résultats sont renvoyés au modèle pour un traitement ultérieur. La documentation distingue explicitement cette organisation du fait de donner au modèle un accès direct aux interfaces applicatives sous-jacentes.

Cette séparation constitue la manière la plus utile d’évaluer l’architecture. La demande d’un modèle représente une intention proposée. L’implémentation autour de l’outil détermine si cette intention devient une action externe.

Imaginons un assistant de voyage hypothétique traitant une demande d’organisation d’itinéraire. Consulter la météo est informatif. Réserver une chambre modifie un système externe. Cette différence devrait apparaître dans le comportement d’autorisation et de confirmation, même si les deux outils semblent similaires au modèle.

Un nom d’outil descriptif n’établit pas cette limite. Pas plus qu’une instruction demandant au modèle d’être prudent. L’application a besoin de contrôles qui restent efficaces lorsque le modèle comprend mal une demande ou reçoit des informations trompeuses.

La validation des entrées, qui vérifie si les valeurs fournies satisfont aux exigences de l’application, répond à une partie de ce problème. Une destination doit exister, une date doit être interprétable et une demande doit se rapporter à une ressource autorisée. Ces contrôles devraient avoir lieu avant toute exécution à conséquences.

L’autorisation répond à une question distincte : l’utilisateur identifié peut-il effectuer l’opération demandée ? Des arguments valides peuvent toujours décrire une action non autorisée. Réunir ces contrôles sous une notion vague de « sortie sûre » rend les défaillances plus difficiles à identifier.

La conception des outils affecte aussi la reprise. Une recherche peut généralement être répétée sans modifier l’état métier. Répéter une soumission peut créer du travail en double. L’idempotence, selon laquelle des requêtes équivalentes répétées ne produisent aucun effet métier supplémentaire, devient importante lorsque des actions peuvent être réessayées.

Il s’agit d’une implication technique de l’architecture, plutôt que d’une preuve que chaque outil d’exemple met en œuvre ces protections. Les équipes adaptant les exemples devraient examiner le comportement réel de chaque outil. Les effets de bord autorisés comptent davantage que l’étiquette conversationnelle.

La même discipline s’applique lorsque les outils renvoient des informations au modèle. Une réponse peut contenir des dossiers incomplets, du texte inattendu ou un message d’erreur. Traiter chaque réponse comme un contexte fiable peut transformer un problème en aval en recommandation incorrecte.

Les responsables applicatifs devraient décider ce que l’agent voit lorsqu’un outil échoue. Un résultat d’échec clair donne au modèle la possibilité d’expliquer l’incertitude. Un résultat vide qui ressemble à une réussite peut encourager une réponse non étayée.

L’interface doit également rendre compte honnêtement de l’achèvement. Un modèle générant une réponse fluide ne prouve pas qu’une opération demandée a réussi. La réussite devrait dépendre des preuves fournies par le système responsable de l’opération.

C’est ici que les modèles applicatifs familiers de l’architecture deviennent utiles. Les limites de service existantes peuvent appliquer des autorisations, valider des enregistrements et consigner les résultats. Le modèle peut fonctionner dans ces limites sans devenir leur autorité.

L’implémentation la plus robuste préserve cette séparation même lorsque la conversation se complexifie. L’ajout d’outils devrait accroître les capacités utiles tout en maintenant les décisions d’exécution inspectables et contraintes.

La mémoire et le routage multi-agent élargissent la surface de contrôle

Un contexte supplémentaire et des rôles spécialisés créent davantage de comportements à valider, sans augmenter automatiquement la fiabilité.

La mémoire conversationnelle conserve des informations pour des interactions ultérieures. Elle peut rendre un assistant utile tout au long d’une tâche, mais le contexte conservé soulève des questions de responsabilité, d’exactitude et de suppression.

Une préférence mémorisée ne devrait pas devenir silencieusement une autorité permanente. Un employé peut changer de destination, retirer une demande ou corriger une déclaration antérieure. Une application doit pouvoir résoudre ces changements sans traiter chaque message historique comme s’il était également actuel.

La mémoire doit aussi entretenir une relation claire avec les registres détenus ailleurs. Une conversation peut décrire une approbation, alors que le système métier n’en enregistre aucune. Le système responsable de la transaction doit rester la source d’autorité.

L’identité rend cette distinction particulièrement importante. Les recommandations de sécurité d’exécution d’AWS indiquent que les backends doivent appliquer des correspondances entre utilisateurs et sessions. L’isolation à l’exécution n’établit pas qu’un identifiant de session fourni appartient à l’utilisateur qui en fait la demande.

L’isolation consiste à séparer les environnements d’exécution. L’autorisation consiste à décider qui peut accéder à une ressource. Confondre ces concepts laisse un écart entre la protection de l’infrastructure et l’accès applicatif.

Un assistant de support hypothétique illustre ce problème. Un environnement d’exécution peut rester isolé tandis que l’application charge la conversation du mauvais client. Protéger l’environnement ne corrige pas une décision erronée quant à l’historique à récupérer.

Le routage vers des spécialistes introduit un autre type de frontière. Un routeur choisit quel chemin de traitement reçoit une requête. Un spécialiste traite ensuite une tâche plus ciblée. Cette organisation peut clarifier les responsabilités, mais le choix initial de routage devient une décision supplémentaire à valider.

Considérez un document associant un contrat à des pièces jointes financières. Une étiquette suggérant un contenu juridique n’établit pas que chaque question pertinente relève du droit. L’application a besoin d’une politique couvrant l’ambiguïté, les contenus mixtes et les demandes non prises en charge.

Un évaluateur ajoute une autre distinction. Un évaluateur fondé sur des règles vérifie les sorties selon des conditions configurées. Un évaluateur basé sur un modèle produit un jugement. Les deux peuvent être utiles, mais leurs modes de défaillance et leur valeur probante diffèrent.

Une règle peut détecter systématiquement un champ manquant tout en ne permettant pas d’établir si un champ renseigné est exact. Un évaluateur basé sur un modèle peut relever des incohérences tout en partageant les hypothèses du modèle d’origine. Un simple accord ne devrait pas constituer une preuve.

La comparaison sectorielle pertinente est architecturale. Les modèles de conception d’agents d’Anthropic distinguent les workflows prédéfinis des agents qui dirigent dynamiquement leurs propres processus. Ces recommandations privilégient des approches simples et composables, puis l’ajout de complexité lorsque la tâche l’exige.

Cette perspective contrebalance utilement l’idée que le recours à plusieurs agents serait une destination inévitable. Un chemin de traitement prévisible peut être plus facile à inspecter qu’un système qui choisit sa propre séquence. Le comportement dynamique nécessite une justification propre à la charge de travail.

Pour les équipes Java, la décision doit suivre l’incertitude de la tâche. Si une séquence connue traite le travail de manière fiable, une coordination supplémentaire doit apporter des bénéfices mesurables. Les étiquettes de spécialistes ne procurent pas à elles seules ces bénéfices.

Le traitement parallèle mérite le même examen. Des travaux indépendants peuvent être exécutés simultanément, mais les travaux dépendants exigent toujours un ordre. La combinaison des résultats nécessite également des règles en cas de désaccord, de sorties manquantes et d’échec partiel.

La question pratique est de savoir si la coordination ajoutée améliore les résultats acceptés après prise en compte de l’examen et de la reprise. Cette question reste pertinente quel que soit le framework ou le service cloud utilisé.

La résilience maintient les services disponibles, pas les décisions correctes

Les mécanismes de récupération traitent les défaillances opérationnelles, tandis que la qualité des résultats exige des preuves distinctes.

Une nouvelle tentative répète une opération après un échec. Un disjoncteur interrompt temporairement les appels à une dépendance défaillante. Un délai d’expiration limite le temps d’attente d’une opération. Ces mécanismes aident à contrôler le comportement du service, mais aucun ne détermine si une réponse est exacte.

Une application peut répondre rapidement avec une recommandation erronée. Elle peut aussi échouer proprement tout en laissant une opération métier partiellement terminée. La santé de l’infrastructure et l’achèvement de la tâche nécessitent donc des définitions distinctes.

Pour un assistant documentaire hypothétique, une réalisation réussie pourrait nécessiter une extraction exacte, une décision de routage appropriée et une disposition enregistrée. Recevoir une réponse syntaxiquement valide n’établit qu’une partie de cette chaîne.

La sortie structurée, qui place des informations générées dans un format prédéfini, aide le code applicatif à consommer les résultats. Elle n’établit pas que ces informations correspondent à la source. Une date correctement formatée peut tout de même être la mauvaise date.

La confiance exige une prudence similaire. Un score accompagnant un résultat ne devient utile que lorsque les équipes comprennent ce qu’il prédit pour leur propre charge de travail. Un score élevé ne devrait pas automatiquement prévaloir sur des preuves manquantes ou une restriction métier explicite.

La revue humaine doit également avoir une substance opérationnelle. Signaler un résultat diffère du fait de le placer là où une personne responsable peut l’évaluer. Un processus de revue nécessite un responsable, des éléments probants pertinents, une décision et un effet clair sur les actions ultérieures.

Une alerte que personne ne reçoit ne peut pas fournir une supervision significative. Une alerte reçue reste insuffisante lorsque l’évaluateur ne peut pas consulter le matériau source ni corriger le résultat. Les équipes doivent examiner le transfert complet.

Les contrôles de contenu traitent une autre partie du problème. Bedrock Guardrails permet un filtrage configurable des entrées et des réponses du modèle, notamment pour les contenus indésirables et les informations sensibles. Ces contrôles doivent être évalués au regard du cas d’usage de l’application plutôt que supposés efficaces du seul fait de leur présence.

Le filtrage de contenu et l’autorisation de transaction restent des responsabilités différentes. Une demande polie et ordinaire peut tout de même chercher à accéder aux dossiers d’une autre personne. Une réponse peut respecter les politiques de contenu tout en décrivant une action métier que l’utilisateur n’est pas autorisé à effectuer.

L’architecture exige donc des preuves à plusieurs frontières. Les équipes doivent savoir ce que l’utilisateur a demandé, ce que le modèle a proposé, ce que l’application a autorisé et ce que le système externe a terminé.

L’observabilité consiste à collecter des signaux permettant d’expliquer le comportement du système. Des signaux utiles facilitent l’enquête, mais leur collecte ne crée pas en elle-même une décision de mise en production. Il faut toujours définir quels résultats justifient le déploiement.

L’évaluation consiste à tester le comportement par rapport à des critères explicites à l’aide de tâches représentatives. Pour un agent d’entreprise, cela devrait inclure des demandes ordinaires, des entrées ambiguës, des dépendances indisponibles, des demandes non autorisées et des corrections apportées à un contexte antérieur.

L’objectif est de révéler les défaillances avant que les utilisateurs ne dépendent du service. Une démonstration optimisée autour d’interactions réussies ne peut pas répondre aux mêmes questions. Un tableau de bord affichant le nombre de requêtes sans indiquer si le travail était acceptable ne le peut pas davantage.

La confidentialité fait également partie de cette évaluation. L’enregistrement de conversations complètes et de résultats d’outils peut créer une collection distincte d’informations sensibles. Les équipes doivent décider quelles preuves leur sont nécessaires et comment l’accès ainsi que la conservation fonctionneront.

Pour les agents Amazon Bedrock, la frontière de mise en production doit suivre la tâche prise en charge. Un assistant interne de recherche et une application qui modifie des registres financiers justifient des critères d’acceptation différents. Partager un framework ne rend pas leurs risques opérationnels interchangeables.

C’est ici le sens pratique de la préparation à la production : un comportement défini, des frontières appliquées, des résultats mesurables et une récupération opérationnelle pour le service particulier proposé.

Ce qu’il faut surveiller avant d’élargir l’autonomie

Les prochaines preuves utiles relieront l’architecture à des résultats métier reproductibles dans des conditions d’exploitation réalistes.

Le premier signal à surveiller au cours des prochains mois est l’existence de preuves d’évaluation propres à la charge de travail. Les équipes devraient rechercher des tâches documentées, des critères d’acceptation clairs et des résultats liés à des versions identifiables de l’application.

Les preuves les plus instructives incluraient des cas infructueux et les corrections qui en résultent. Cela renforcerait la confiance dans le fait que les développeurs comprennent les limites du système. Une liste de fonctionnalités plus longue, sans preuve de résultats, laisserait l’incertitude centrale sans réponse.

L’évaluation devrait aussi distinguer l’automatisation réussie du travail achevé grâce à une intervention humaine. La revue peut constituer un choix de conception approprié. Cependant, masquer sa contribution rend les performances autonomes difficiles à évaluer.

Le deuxième signal est une frontière d’identité complète et testée. Des preuves d’implémentation utiles relieraient les utilisateurs authentifiés aux sessions autorisées, à l’accès à la mémoire et à l’exécution des outils.

Un test négatif compte ici autant qu’une conversation réussie. Montrer qu’un utilisateur ne peut pas récupérer l’historique d’un autre utilisateur renforcerait l’argument en faveur du déploiement. S’appuyer sur des valeurs d’identité fournies par le client l’affaiblirait.

Le même examen devrait s’appliquer aux autorisations des outils. Un assistant à portée étroitement définie présente une promesse opérationnelle plus claire qu’un assistant bénéficiant d’un accès étendu et de garanties vagues. L’élargissement doit suivre la preuve que le service plus restreint se comporte comme prévu.

Le troisième signal est une récupération démontrée après une défaillance partielle. Les équipes devraient rechercher un comportement contrôlé lorsqu’une dépendance échoue après le début d’une action, qu’une réponse est interrompue ou qu’une revue devient nécessaire.

Des preuves utiles montreraient si les opérations sont répétées, comment le travail incomplet est identifié et qui peut le résoudre. Une récupération réussie renforcerait la confiance dans la conception opérationnelle. Un simple message de repli laisserait l’achèvement incertain.

Ces signaux n’exigent pas que chaque agent devienne un travailleur autonome à usage général. Une application limitée peut fournir des résultats utiles tout en conservant des points d’approbation explicites. La mesure pertinente est de savoir si elle achève le travail qu’elle prend en charge dans le cadre de son autorité déclarée.

AWS a fourni aux équipes Java une architecture concrète à examiner. Son importance à plus long terme dépendra de ce que les équipes pourront valider après l’avoir adaptée. Des modèles de développement familiers facilitent l’organisation de l’adoption ; des preuves de comportement facilitent sa justification.

Avant d’adopter la référence, choisissez une tâche délimitée et consignez ce que signifie un achèvement réussi. Identifiez les registres que l’agent peut lire, les opérations qu’il peut demander et les décisions qui nécessitent une approbation. Évaluez ensuite l’implémentation sur un travail représentatif, y compris des cas d’échec et de refus d’accès. Conservez ces constats avec les décisions de conception de l’application afin que les évolutions futures disposent d’un point de comparaison clair. N’élargissez le périmètre que lorsque les preuves justifient la prochaine autorisation ou le prochain workflow. Pour les agents Amazon Bedrock, la question de départ utile est concrète : quelle tâche votre équipe peut-elle vérifier depuis la demande initiale jusqu’au résultat métier final, y compris les moments où l’agent doit s’arrêter ?

 
 

Commencez pour Gratuit

Un premier assistant IA local avec gestion des connaissances personnelles

Pour une meilleure expérience IA,

remio ne supporte que Windows 10+ (x64) et M-Chip Macs actuellement.

Votre partenaire IA au travail
Faites-en plus avec remio

Planifiez. Créez. Livrez.
Tout au même endroit.

bottom of page