AWS vient de mettre fin à la phase pilote de l'IA.

Quatre-vingt-quinze pour cent des projets pilotes d'IA en entreprise échouent. Ce chiffre, tiré d'un rapport largement cité du MIT, a résonné dans les salles de réunion comme une alarme cette année, car il met en lumière une réalité brutale : la plupart des IA d'entreprise ne dépassent jamais le stade de la démonstration attrayante. Les budgets sont engloutis, les présentations sont impressionnantes, puis le projet pilote meurt discrètement avant d'atteindre un véritable client ou un flux de travail de production.

Sous ce taux d'échec se cache un problème simple : les entreprises n'ont pas confiance dans les systèmes non déterministes qu'elles ne peuvent pas contrôler entièrement. Les logiciels traditionnels se comportent de manière prévisible ; la même entrée produit la même sortie à chaque fois. Les grands modèles de langage improvisent. Ils hallucinent, interprètent mal les politiques et inventent parfois des données — des comportements inacceptables lorsqu'il s'agit de déplacer de l'argent, de manipuler des dossiers médicaux ou d'interagir avec des API internes.

Une démonstration élégante de chatbot dans une salle de conférence repose sur des invites soigneusement choisies, des données sélectionnées et un public indulgent. Un système d'IA de production fonctionne avec des tickets chaotiques, des entrées CRM incomplètes, des clients en colère et des agents de conformité qui supposent que tout ira mal. Cet écart entre la démonstration et le déploiement est l'endroit où les pilotes vont mourir. Le système qui semblait magique dans un environnement de test a soudainement besoin de pistes d'audit, de limites de taux, de budgets d'erreurs et de scénarios d'incidents.

La plupart des entreprises découvrent cela seulement après que le pilote a « réussi » techniquement mais a échoué au niveau organisationnel. Les équipes de sécurité bloquent l'accès à des outils critiques. Le service juridique exige des garanties solides sur l'utilisation des données. Les équipes opérationnelles ne peuvent pas comprendre pourquoi un agent a décidé de rembourser 5 000 $ au lieu de 50 $. Sans garde-fous, évaluations et observabilité intégrés, l'IA devient une boîte noire sans responsabilité fixée à des systèmes essentiels à la mission.

C'est pourquoi l'IA « agentique » a stagné dans ce que de nombreuses équipes appellent désormais le purgatoire des pilotes. Les agents peuvent appeler des outils, déclencher des flux de travail et agir de manière autonome, mais les entreprises manquent d'un moyen de prouver systématiquement qu'elles sont sûres, mesurables et susceptibles de s'améliorer au fil du temps. L'industrie n'a pas seulement besoin de meilleurs modèles ; elle nécessite une infrastructure qui considère la politique, l'évaluation et la mémoire comme des éléments essentiels, et non comme des réflexions après coup.

C'est le changement que AWS cible désormais ouvertement : transformer l'IA d'un jouet expérimental en une infrastructure gouvernée que les entreprises peuvent réellement utiliser à grande échelle.

AWS re:Invent est devenu un exercice concret pour l'IA d'entreprise, et AgentCore est la réponse d'AWS au taux d'échec des pilotes de 95 % qui pèse sur les épaules des DSI. Au lieu d'un autre SDK "créez votre propre agent", AgentCore se présente comme une plateforme de production : une passerelle gérée, un moteur de politique, un système d'évaluation et une couche de mémoire conçus pour empêcher les agents de devenir indisciplinés à grande échelle.

AWS est clair sur sa clientèle cible : des entreprises qui ont déjà réalisé des démonstrations impressionnantes avant de se heurter à des obstacles liés à la sécurité, à la conformité et à la fiabilité. AgentCore promet des agents capables de fonctionner sur n'importe quel modèle, d'accéder à des outils internes et à des API, tout en respectant les règles d'entreprise, les SLA et les pistes de vérification. Pas de surveillance de l'infrastructure, pas de code de raccordement unique.

Lors de re:Invent, AWS a élevé trois idées au rang de composants de première classe, toujours activés d'AgentCore : Politique, Evaluations et Mémoire épisodique. Ce ne sont pas des options facultatives ; elles se situent directement dans le chemin d'exécution de l'agent, inspectant chaque requête et chaque appel d'outil.

La politique transforme des règles en langage naturel en garde-fous exécutables. Vous pouvez écrire des contraintes telles que « interdire les messages Slack à moins que l'utilisateur n'ait le droit de messagerie » ou « bloquer les URL contenant 'interne' à moins que le nom d'utilisateur ne commence par admin », et AgentCore compile cela en code qui s'exécute en millisecondes. Le moteur de politique se trouve derrière la passerelle AgentCore, décidant quels outils un agent peut appeler avant que quoi que ce soit ne touche Salesforce, Slack ou des systèmes internes.

Les évaluations attaquent l'autre moitié du problème de confiance : la dérive de qualité et l'échec silencieux. AgentCore est livré avec des évals prêtes à l'emploi pour la précision, la sécurité, le suivi des instructions et l'utilisation des outils, ainsi que des interfaces pour des métriques personnalisées, allant de la voix de marque à la précision spécifique au domaine. Les équipes peuvent exécuter des évaluations à la demande ou en continu, puis intégrer les scores dans des piles de monitoring pour décider quand un agent est prêt à quitter le purgatoire du « pilote ».

La mémoire épisodique complète le tableau en permettant aux agents d'apprendre de leurs succès et de leurs échecs lors de nombreuses sessions, et pas seulement d'un seul fil de discussion. Ces souvenirs influencent à la fois le comportement en temps réel et les évaluations, de sorte que les entreprises peuvent suivre si les agents s'améliorent réellement au lieu de simplement improviser plus rapidement.

La politique dans AgentCore est la tentative d'AWS d'incorporer le bon sens commercial dans l'IA. Au lieu d'enfouir des règles dans des invites fragiles, AgentCore expose la Politique comme un niveau de contrôle de première classe qui se situe entre les agents et les outils, les données et les systèmes qu'ils souhaitent utiliser. Chaque demande passe par ce moteur de politique avant que quoi que ce soit d'autre ne se produise.

Ce design est important car les modèles modernes ne sont plus seulement des jouets d'autocomplétion. Des recherches menées par Anthropic et d'autres documentent des capacités telles que la tromperie, la fausse représentation stratégique et les tentatives d'exfiltration de données lorsque les modèles ont accès à des outils sensibles ou des réseaux internes. Les entreprises ne peuvent pas se fier à des impressions vagues et des anecdotes de red team lorsque une erreur pourrait entraîner une fuite de données clients ou déclencher une transaction financière.

La politique offre aux entreprises un moyen centralisé et évolutif de définir ce que les agents peuvent et ne peuvent pas faire, puis de le faire appliquer en temps réel. Vous décrivez les contraintes en langage naturel : « interdire les messages Slack à moins que l'utilisateur ait le droit de messagerie », « bloquer les URL contenant 'interne' à moins que le nom d'utilisateur commence par admin » — et AgentCore génère automatiquement le code de politique programmatique. Ce code s'exécute en millisecondes, suffisamment rapidement pour être en première ligne pour des milliers de requêtes par seconde.

Sous le capot, chaque appel d'agent passe par la passerelle AgentCore, qui consulte le moteur de politique avant d'exposer tout outil. Si la politique refuse l'accès, l'agent ne voit même pas la capacité, que ce soit une API Salesforce, un seau S3 ou un point de terminaison de paiements. La politique opère au niveau de l'infrastructure, pas à la merci de ce que le modèle « a envie » de faire.

Contrastons cela avec la manière dont la plupart des équipes déploient des agents aujourd'hui. Elles fourrent un paragraphe de « ne divulguez pas de secrets, ne naviguez pas sur les sites internes, ne validez pas de remboursements supérieurs à 100 $ » dans un prompt système et espèrent que le modèle obéisse. Cela fonctionne bien dans une démonstration ; cela échoue dès que vous passez à des centaines de flux de travail, des dizaines d'outils et des millions d'appels.

Les instructions au niveau de l'invite échouent également silencieusement. Les modèles hallucinent, ignorent les instructions sous pression ou sont contournés par des entrées astucieuses, et vous ne le réalisez généralement qu'après qu'un problème se soit produit. La politique dans AgentCore renverse cela : la gouvernance vit en dehors du modèle, gérée de manière centralisée, versionnée, auditée et testable avec des techniques de raisonnement automatisé qui vérifient formellement les hallucinations et les violations de règles.

Pour les entreprises cherchant à dépasser les projets pilotes en IA, ce changement est la différence entre "s'il vous plaît, agissez correctement" et "ne peut pas mal se comporter par conception." AWS parie que ce type de plan de contrôle rigide, documenté sur la page officielle du produit Amazon Bedrock AgentCore, est ce qui permettra enfin de déployer les agents à grande échelle.

Les politiques dans AgentCore commencent en anglais simple, pas en YAML ou JSON. Les développeurs saisissent des instructions dans une zone de saisie exactement comme ils les expliqueraient à une équipe de sécurité : « Interdire les messages Slack sauf si l'utilisateur dispose du droit de messagerie. La consultation de sites web dont l'URL contient 'interne' est interdite, sauf si le nom d'utilisateur commence par 'admin'. Autoriser les messages Slack lorsque l'utilisateur fait partie du groupe autorisé. »

Derrière cette interface apparemment simple, AgentCore traite ces phrases comme du code source. Un compilateur de politiques analyse le langage naturel, résout des entités telles que « messages Slack », « portée de messagerie appropriée » et « nom d’utilisateur », et émet des règles programmatiques qui se lient directement aux outils, ressources et attributs d’identité de votre infrastructure.

Cette politique générée n'est pas un appel LLM lent à l'exécution. AgentCore la transforme en code de politique bas niveau, exécutable, qui fonctionne comme une logique déterministe, de sorte que chaque demande effectue des vérifications compilées au lieu de redemander un modèle. Vous rédigez la règle une fois en anglais, puis AgentCore la verrouille en tant que code rapide et testable.

AWS vous pousse à valider ces garde-fous comme tout autre système de production. Après avoir généré la politique, vous exécutez des cas de test dans la console, confirmant qu'un utilisateur sans le « droit de messagerie » ne peut pas envoyer de message Slack, tandis qu'un utilisateur administrateur peut ouvrir une URL interne. Pas de redéploiements, pas de réarchitecture — il suffit d'ajuster le texte, de régénérer et de retester.

L'échelle est l'endroit où cela cesse de ressembler à un jouet et commence à ressembler à une infrastructure. Le moteur de règles d'AgentCore se situe sur le chemin critique et évalue les règles en millisecondes, même lorsque les agents se déploient à travers des outils comme Slack, Salesforce et des API internes. AWS cible explicitement « des milliers de requêtes par seconde », ce qui rapproche cela d'un pare-feu plutôt que d'un plugin de chatbot.

AgentCore Gateway est le régulateur du trafic qui permet de fonctionner à ce volume. Chaque demande d'agent — qu'elle provienne d'un assistant interne, d'un client MCP ou d'une application externe — transite par le Gateway avant d'atteindre un outil ou une source de données. Le Gateway sollicite le moteur de politiques, qui décide, pour chaque demande, quels outils et ressources l'agent peut effectivement utiliser.

Cela signifie qu'une seule règle en langage naturel comme « interdire les messages Slack à moins que l'utilisateur ait le bon champ de droits de messagerie » devient une surface de contrôle globale. Tout agent tentant d'accéder à l'outil Slack est vérifié, à chaque fois, à vitesse maximale. Pas d'agents invisibles, pas de scripts oubliés, pas de chemins de contournement.

Pour les entreprises confrontées à ce taux d'échec de 95 % des pilotes d'IA, voici le changement essentiel : la politique passe de la présentation à la code, de la documentation au chemin d'exécution.

La confiance, et non les fonctionnalités, est ce qui tue la plupart des pilotes d'IA, et AWS le sait. Après Politique, le deuxième pilier d'AgentCore est Évaluations—un système d'évaluation des performances intégré pour les agents qui considère la qualité comme une partie du parcours d'exécution, et non comme un tableau de bord que vous ajoutez ultérieurement.

La plupart des entreprises effectuent l'évaluation à l'envers. Les équipes assemblent un agent, lancent un projet pilote, puis s'affairent à mesurer son efficacité. AgentCore renverse cette approche : AWS vous invite à définir d'abord les évaluations, à établir une ligne de base, puis à commencer à itérer, afin que chaque changement ait un impact mesurable au lieu de simplement « sembler plus intelligent ».

D'emblée, AgentCore est doté d'une batterie de signaux d'évaluation standard. AWS met en avant des dimensions telles que : - précision - utilité - concision - suivi des instructions - fidélité - pertinence des réponses - cohérence - comportement de refus

Ces signaux sont importants car les agents sont non déterministes. Une démonstration peut sembler parfaite, puis se dégrader discrètement une fois que vous connectez de véritables outils, un contexte bruyant et des données clients désordonnées. Une surveillance continue de ces dimensions d'évaluation est la manière dont vous détectez le dérive avant qu'un VP ne se retrouve avec une politique de remboursement halluciné dans sa boîte de réception.

AgentCore vous permet d'effectuer des évaluations à la demande ou de manière continue. Vous pouvez soumettre une nouvelle version de l'agent à un seuil de qualité, ou réaliser des évaluations en continu en production pour comparer le comportement d'une semaine sur l'autre. Cette référence devient votre étoile polaire : si la précision chute de 10 % après l'ajout d'un nouvel outil, vous savez exactement à quel moment vous avez perdu la confiance.

Les évaluations personnalisées comblent le fossé entre la qualité générique et la réalité commerciale. Si votre bot d'assistance doit refléter une voix de marque spécifique, vous pouvez codifier cela comme un signal personnalisé. Si votre équipe de conformité a besoin de garanties solides concernant les refus dans des flux de travail réglementés, vous pouvez rédiger une évaluation qui échoue toute réponse qui sort du cadre de la politique.

Parce que les évaluations se trouvent dans AgentCore, et non à part dans un outil BI, chaque score est lié à un chemin décisionnel traçable. Lorsqu'un agent s'écarte du script, vous pouvez retracer la chaîne depuis l'invite, jusqu'aux outils, à la mémoire, et au résultat final, afin de corriger le mode de panne réel, et pas seulement le symptôme.

Les évaluations prêtes à l'emploi ne font que répondre à moitié aux besoins des entreprises. Le véritable atout d'AgentCore réside dans les évaluations personnalisées, où les équipes définissent exactement ce à quoi ressemble un "bon" agent et évaluent continuellement selon ces critères, et pas seulement lors d'un benchmark en laboratoire une fois par trimestre. Ce changement transforme les évaluations d'une simple liste de contrôle QA statique en un système de gouvernance dynamique.

La propre démo d'AWS devient volontairement ludique : une évaluation "parle comme un pirate". Vous spécifiez littéralement que l'agent doit répondre en langage de pirate—"Ahoy", "matelot", jargon nautique—et l'évaluation personnalisée vérifie chaque réponse. Si la sortie ressemble davantage à LinkedIn qu'à Barbe Noire, l'évaluation échoue et le consigne.

Cette touche de pirate est une blague aux contours aiguisés. Changez le thème et vous obtiendrez un modèle d'entreprise sérieux : imposer une voix de marque à chaque agent en contact avec les clients. Un détaillant peut exiger des réponses amicales, concises, et sans émojis ; une banque peut demander un ton formel, un langage prudent, et des clauses de risque explicites. Une évaluation personnalisée note chaque réponse par rapport à ces règles et intègre ces données dans des tableaux de bord et des alertes.

Des cas d'utilisation plus complexes vont au-delà du ton. Un agent de santé pourrait avoir besoin de : - Suivre un processus de triage en plusieurs étapes - Afficher des clauses de non-responsabilité réglementaires spécifiques - Escalader à un humain sous des conditions de risque définies

Une évaluation sur mesure peut rejouer de vraies conversations, vérifier chaque étape et attribuer un résultat réussi/échoué sur le respect du flux de travail, et pas seulement sur la « pertinence ». C’est ainsi que les équipes cessent de deviner si un agent est sûr de pouvoir être lancé auprès des patients, des traders ou des techniciens de terrain.

Tout cela se connecte directement à Amazon CloudWatch. Des métriques standards telles que la latence et le taux d'erreur se trouvent à côté de scores personnalisés pour la correction, la conformité des flux de travail ou le jargon de pirate sur une seule timeline. Les équipes d'ingénierie, juridiques et marketing peuvent observer les mêmes graphiques, et lorsque quelque chose dévie, elles peuvent retracer cela à travers les journaux d'AgentCore et les politiques décrites dans Introducing Amazon Bedrock AgentCore - AWS Blog.

La mémoire épisodique transforme AgentCore d'un simple routeur de chatbot astucieux en quelque chose de plus proche d'un cerveau institutionnel. Au lieu de considérer chaque demande comme une transaction isolée, les agents peuvent désormais stocker et récupérer des expériences : ce qu'ils ont essayé, quels outils ils ont appelés, ce qui a fonctionné et ce qui a échoué.

Les agents d'entreprise traditionnels se comportent comme des poissons rouges. Ils répondent à un ticket, appellent une API, clôturent la boucle et oublient tout au moment où la réponse est envoyée. La mémoire épisodique inverse ce modèle, offrant à AgentCore un enregistrement persistant et interrogeable du comportement des agents au fil du temps.

Il est crucial de noter que cette mémoire est globale, et non personnelle. Elle ne s'attache pas au fil de discussion d'un utilisateur unique ou à un identifiant de session spécifique. Lorsque un agent trouve les bonnes étapes de remédiation pour un bug désagréable lié aux permissions S3, ces étapes deviennent une partie de la mémoire partagée dont chaque instance future de cet agent peut s'inspirer.

Cette propagation change la façon dont les organisations envisagent la « formation ». Au lieu de réentraîner les modèles ou de réécrire les demandes chaque fois qu'un nouveau cas limite apparaît, l'agent enregistre l'épisode, capture le contexte, marque le résultat comme réussi ou échoué, et le réutilise. Une interaction de support en janvier peut discrètement améliorer des milliers de cas similaires en mars.

La reconnaissance de motifs devient la fonctionnalité phare. Avec suffisamment d'épisodes enregistrés, les agents peuvent commencer à repérer que : - 80% des recherches de commandes échouées sont liées à une seule API héritée - Certains outils se déconnectent systématiquement sous des modèles de charge spécifiques - Une règle de politique particulière entraîne des refus inutiles pour des demandes sûres

Ces patterns influencent le processus de décision. L'agent peut anticipativement éviter les outils peu fiables, faire remonter plus rapidement les flux à haut risque ou choisir des chemins plus sûrs lorsque des tentatives précédentes ont entraîné des violations de politique. Au fil du temps, l'agent se comporte moins comme une fonction sans état et plus comme un manuel d'opérations en amélioration continue.

Parce que les évaluations se trouvent dans le même chemin d'exécution, AgentCore peut évaluer chaque épisode et stocker le résultat avec la mémoire. Cela complète le cycle : la politique contraint le comportement, les évaluations jugent les résultats, et la mémoire épisodique s'assure que chaque leçon durement acquise reste en mémoire tout au long du déploiement.

La mémoire cesse d'être un tour de magie une fois qu'elle est directement connectée aux évaluations. AgentCore considère désormais la mémoire épisodique comme une autre source de données pour ses contrôles de qualité, de sorte que chaque interaction alimente un cycle de rétroaction serré : agir, évaluer, apprendre, répéter. Ce cycle fonctionne en continu, et non pas comme un projet scientifique en MLOps trimestriel.

Au lieu de juger un agent uniquement sur une seule réponse, les évaluations peuvent désormais demander : « Étant donné ce que vous avez appris la semaine dernière, avez-vous réellement fait mieux aujourd'hui ? » AgentCore peut comparer les performances sur des tâches récurrentes à travers les épisodes : tickets identiques, flux de support similaires ou scénarios de remboursement répétés. Si la précision, la latence ou la conformité aux politiques ne s'améliorent pas après des dizaines ou des centaines de tentatives, votre agent « apprenant » ne fait que conserver des journaux.

Parce que la mémoire est de première classe, les évaluations peuvent imposer des objectifs longitudinaux, pas seulement une correction ponctuelle. Vous pouvez définir des cibles telles que « réduire les échecs d'appel d'outils de 30 % sur 500 épisodes » ou « réduire le temps moyen de traitement de 10 % pour les clients récurrents ». Ces métriques sont directement liées aux KPI commerciaux au lieu de scores de modèle abstraits.

L'observabilité devient également plus précise. Lorsqu'un agent échoue à une évaluation personnalisée — halluciner un prix, mal orienter un ticket, divulguer des données internes — vous pouvez retracer l'ensemble du chemin de raisonnement. AgentCore vous permet de revenir à travers la mémoire épisodique : quels outils il a appelés, quelles conversations antérieures il a réutilisées, quelles décisions de politique il a appliquées ou ignorées.

Cette trace transforme les post-mortems d'une simple conjecture en une analyse des causes profondes. Vous pouvez voir si l'agent : - A appris d'un mauvais exemple et a propagé l'erreur - A mal interprété un schéma de succès précédent - A ignoré un souvenir pertinent qui aurait dû modifier son plan

Une fois que vous savez quelle mémoire l'a égaré, vous pouvez tailler ou réécrire cet épisode, puis relancer le même ensemble d'évaluation pour vérifier la correction. La boucle de rétroaction se ferme : la mémoire change, le comportement change, les métriques évoluent—ou elles ne le font pas, et vous le savez immédiatement.

Les outils d'IA statiques se comportent comme des formulaires : mêmes entrées, mêmes sorties, sans sens de l'histoire. Avec une mémoire épisodique intégrée dans des évaluations de qualité en direct, les agents commencent à ressembler à des travailleurs numériques qui s'intègrent, se font coacher et s'améliorent. La politique les maintient dans les limites, les évaluations notent leur performance et la mémoire leur donne quelque chose sur quoi s'appuyer.

La politique intégrée, l'évaluation et la mémoire à l'intérieur d'AgentCore ne sont pas simplement des fonctionnalités pratiques ; elles se trouvent directement sur le chemin d'exécution de chaque étape de l'agent. Chaque appel d'outil, chaque accès aux ressources, chaque réponse passe par la même passerelle qui impose la politique et enregistre la mémoire épisodique avant que le modèle ne traite jamais de données sensibles.

Ce choix architectural est important. Parce que la politique se situe à la porte d'entrée, AgentCore peut appliquer des garde-fous à des milliers de demandes par seconde avec une latence de quelques millisecondes, plutôt que d'ajouter un « service de gouvernance » lent, qui s'exécute après coup. Les évaluations s'appuient sur les mêmes traces de bas niveau, de sorte que les contrôles de qualité voient le contexte exact utilisé par l'agent, et non un résumé approximatif.

La plupart des frameworks concurrents considèrent la sécurité et le monitoring comme des sidecars. Vous configurez : - Un proxy de politique séparé devant les outils - Un pipeline d'évaluation séparé dans un notebook ou un job CI - Un système de logging séparé pour l'observabilité

Ces éléments sont souvent désynchronisés, omettent des cas limites ou se brisent silencieusement lorsqu'une personne ajoute un nouvel outil ou modifie une invite.

Le design de premier ordre d'AgentCore signifie que les nouveaux outils et flux de travail héritent automatiquement des mêmes politiques, évaluations et comportements de mémoire. Lorsqu'un développeur enregistre un outil API ou MCP, la passerelle l'assujettit immédiatement au moteur de politique existant et aux hooks d'évaluation—pas d'appels SDK supplémentaires, pas de middleware personnalisé, pas d'enveloppements sur mesure par équipe.

Les équipes de production se soucient des modes de défaillance, pas des démonstrations. Avec AgentCore, un remboursement halluciné, une tentative d'exfiltration de données ou un flux de travail défaillant apparaissent tous à travers le même pipeline d'évaluation et de traçabilité que les équipes opérationnelles surveillent déjà. Comme la mémoire épisodique se trouve également dans ce chemin central, ces défaillances se réintègrent dans le comportement à long terme de l'agent plutôt que de disparaître dans des journaux.

Contrastons cela avec les piles d'évaluation "ajoutées" courantes, où les contrôles de qualité s'effectuent sur des journaux échantillonnés des heures plus tard. Au moment où une mauvaise décision apparaît sur un tableau de bord, l'agent a peut-être déjà répété cette erreur des milliers de fois. Une intégration profonde permet à AgentCore de réaliser des évaluations de manière continue et réactive, bloquant les déploiements ou redirigeant vers des humains lorsque les scores chutent.

AWS affirme en effet que les garde-fous, la mesure et l'apprentissage sont des éléments essentiels, et non des options supplémentaires. AgentCore intègre cette perspective dans son architecture, s'alignant sur l'élan plus large de re:Invent vers des plateformes d'IA orientées et axées sur la production, comme le souligne Les principales annonces d'AWS re:Invent 2025 - Blog AWS.

Quatre-vingt-quinze pour cent des pilotes d'IA en entreprise échouent dans l'environnement de test, car personne ne peut à la fois faire confiance et contrôler ce que les modèles font à grande échelle. L’AgentCore avec sa pile de Politiques, Évaluations et Mémoire Épisodique s'attaque directement à cette boucle d'échec : des garde-fous stricts définissent ce que les agents peuvent accéder, les évaluations vérifient leur comportement, et la mémoire leur permet de s'améliorer au lieu de répéter indéfiniment les mêmes erreurs.

Les politiques déplacent la gouvernance des présentations PowerPoint vers le chemin d'exécution. Des règles en langage clair, telles que "interdire les messages Slack à moins que l'utilisateur ait le périmètre d'accès adéquat", se transforment en code qui contrôle chaque appel d'outil via la passerelle AgentCore en millisecondes, à travers des milliers de requêtes par seconde, avec un raisonnement automatisé détectant les hallucinations et les comportements douteux avant qu'ils n'atteignent les systèmes de production.

Les évaluations transforment les débats flous sur “est-ce que cela fonctionne ?” en tableaux de bord et en tests de régression. Des métriques prêtes à l'emploi suivent la justesse, la sécurité, le respect des instructions et le choix des outils, tandis que les évaluations personnalisées intègrent les particularités du domaine—ton de la marque, contraintes légales, voire “parler comme un pirate” si cela a de l'importance—permettant ainsi aux équipes de déployer des agents avec la même rigueur qu'elles utilisent pour les API et les microservices.

La mémoire épisodique bouclera la boucle. Les agents ne fonctionnent plus comme des amnésiques ; ils portent en avant des schémas issus de succès et d'échecs passés à travers les utilisateurs, les flux de travail et les environnements, et les évaluations peuvent mesurer directement si ces souvenirs se traduisent par de meilleurs scores et moins d'incidents au fil du temps.

Prises ensemble, cette trifecta ressemble moins à une sortie de fonctionnalité et davantage à un nouveau plan directeur pour l'IA de production. Au lieu de bots fragiles et isolés, les entreprises obtiennent un tissu d'agents gouverné, observable et en amélioration autonome, capable de passer réellement d'un pilote à un déploiement à l'échelle de l'entreprise.

AgentCore se trouve désormais dans la même catégorie que Kubernetes ou IAM : invisible lorsqu'il fonctionne, fondamental lorsqu'il ne fonctionne pas. Alors que des agents automatisés commencent à gérer des tickets, des factures, des vérifications de sécurité et des changements de code, les plateformes qui intègrent le contrôle, la mesure et l'apprentissage au cœur de l'exécution détermineront quelles entreprises échapperont aux 95 % et lesquelles resteront bloquées dans d'interminables « expériences ».

Quelles sont les trois principales nouvelles fonctionnalités d'AWS AgentCore ?

Les trois annonces clés sont la Politique pour des garde-fous basés sur le langage naturel, les Évaluations pour un suivi continu de la qualité et des performances, et la Mémoire Épisodique pour permettre aux agents d'apprendre des interactions passées.

Comment la politique AgentCore garantit-elle la sécurité de l'IA ?

Il convertit des règles en anglais simplifié en code programmatique. Ces politiques sont vérifiées à un portail central en millisecondes avant qu'un agent puisse agir, empêchant ainsi des opérations non autorisées ou dangereuses.

AgentCore est-il lié à un modèle d'IA spécifique comme Claude ou Llama ?

Non, AgentCore est conçu pour être indépendant des modèles et des cadres. Cela permet aux entreprises de créer et de gérer des agents en utilisant n'importe quel grand modèle de langage sous-jacent qui correspond à leurs besoins.

Qu'est-ce qui rend les nouvelles fonctionnalités d'AgentCore différentes des autres solutions ?

Le principal facteur de différenciation est que la Politique, les Évaluations et la Mémoire sont intégrées en tant que « citoyens de première classe » au niveau le plus bas du chemin d'exécution de l'agent, plutôt que d'être ajoutées comme une réflexion après coup.