Agents IA

Architecturer des agents toujours actifs grâce aux boîtes de réception d'événements et à la mémoire durable

Une analyse technique des cinq primitives fondamentales nécessaires pour créer des agents IA proactifs et dotés d'état, capables d'opérer sur plusieurs sessions sans supervision constante.

Illustration d'un sablier numérique sur un rack de serveurs représentant les exécutions d'agents minutées et le stockage sécurisé des données.
Illustration générée pour cet article

Traduit automatiquement depuis l'original anglais.

Le concept d'agents d'intelligence artificielle toujours actifs gagne en traction à mesure que les capacités des modèles s'améliorent et que leurs coûts diminuent. Ces systèmes ne fonctionnent pas en continu ; ils se réveillent périodiquement pour traiter des événements, exécuter des tâches, puis retourner dans un état dormant. Ce changement architectural permet au logiciel d'agir de manière proactive plutôt que de simplement réagir aux instructions directes de l'utilisateur.

Les avancées récentes dans les grands modèles de langage ont rendu cette approche plus viable en améliorant le jugement et en réduisant le coût par tâche pour les travaux à long terme. Par exemple, les nouveaux modèles ont démontré des réductions significatives de coûts sur des benchmarks complexes de codage par rapport à leurs prédécesseurs. Les développeurs explorent désormais comment intégrer ces comportements persistants et dotés d'état dans leurs produits, dépassant les simples interfaces de chat pour aller vers des workflows autonomes.

Ce qui s'est passé

Les agents toujours actifs sont définis par leur capacité à maintenir le contexte entre des sessions disjointes et à agir sans supervision humaine immédiate. Bien qu'ils semblent constamment actifs du point de vue de l'utilisateur, le système sous-jacent fonctionne par cycles. Chaque cycle, appelé une exécution (run), commence lorsqu'un événement déclenche l'agent, passe par l'exécution de la tâche, et se termine lorsque l'agent sauvegarde son état avant de se rendormir.

L'architecture soutenant ces agents repose sur cinq primitives spécifiques : une boîte de réception d'événements, des minuteurs, la mémoire, les permissions et une boîte d'envoi. Ces composants gèrent quand l'agent se réveille, quelles informations il conserve, et comment il interagit avec les systèmes externes en toute sécurité. La conception privilégie la durabilité et la sécurité, garantissant que les événements ne sont pas perdus lors de plantages et que les actions sensibles sont correctement contrôlées.

Cette structure sépare le mécanisme de déclenchement de la logique d'exécution. Au lieu que des services externes appellent directement l'agent, ce qui peut entraîner des conditions de course ou des pertes de données, les événements sont mis en file d'attente dans un stockage durable. Un worker en arrière-plan traite ensuite ces événements séquentiellement ou par lots, assurant que l'état de l'agent reste cohérent et qu'aucun travail n'est dupliqué ou manqué en raison de pannes transitoires.

Comment cela fonctionne

La boîte de réception d'événements sert de système nerveux central pour les déclencheurs entrants. Elle se compose d'une table de base de données durable, d'un gestionnaire HTTP et d'un worker en arrière-plan. Lorsqu'une source externe envoie un webhook ou qu'une tâche planifiée se déclenche, le gestionnaire écrit l'événement dans la base de données et accuse réception rapidement. Cela empêche la source de dépasser le délai d'attente tout en permettant une validation plus approfondie ultérieurement lors de l'exécution.

Le worker interroge la boîte de réception pour trouver les événements en attente. Si plusieurs événements arrivent pour le même utilisateur, le worker peut les regrouper en une seule exécution pour améliorer l'efficacité. Crucialement, un seul worker doit être actif par boîte de réception à tout moment pour éviter les modifications concurrentes. Si un worker échoue en cours d'exécution, une autre instance peut reprendre l'événement non traité depuis la base de données, assurant ainsi la fiabilité.

Les minuteurs permettent un comportement proactif en planifiant des actions futures. Ils sont stockés dans une table durable séparée et gérés par un service de planification. Le planificateur recherche les minuteurs arrivés à échéance, met à jour leur statut et injecte les événements correspondants dans la boîte de réception. Cela permet à l'agent de faire le suivi des tâches précédentes ou d'effectuer des fonctions récurrentes comme l'envoi de résumés quotidiens sans nécessiter de déclencheurs externes constants.

La mémoire est gérée via un système basé sur des fichiers mappé à un stockage durable. L'agent charge les instructions utilisateur, les notes, les messages passés et les fichiers de progression des tâches au début de chaque exécution. Pour garder les fenêtres de contexte gérables et les coûts bas, seuls les index essentiels sont chargés initialement, les fichiers détaillés étant récupérés uniquement si nécessaire. Cette séparation garantit que les informations critiques persistent même si le worker redémarre.

Détails clés

  • Les agents toujours actifs fonctionnent en exécutions discrètes déclenchées par des événements, plutôt que de tourner en continu.
  • La boîte de réception d'événements découple les sources d'événements de l'agent, utilisant une base de données pour assurer la durabilité et prévenir la perte de données.
  • Les minuteurs permettent aux agents de planifier des suivis et des tâches récurrentes, en injectant des événements dans la boîte de réception à échéance.
  • La mémoire est stockée externalement dans des fichiers ou des objets, contenant les préférences utilisateur, la progression des tâches et l'historique des conversations.
  • Les permissions sont gérées via un proxy de credentials et des classificateurs en mode automatique, avec des appels d'outils différés pour les actions à haut risque.
  • La boîte d'envoi délivre les résultats finaux aux utilisateurs, évitant la nécessité de diffuser chaque étape intermédiaire du processus de raisonnement.

Pourquoi c'est important

Pour les ingénieurs logiciels construisant des produits IA, cette architecture résout les problèmes de fiabilité inhérents aux interfaces de chat sans état. En traitant les événements comme des enregistrements durables dans une base de données, les développeurs peuvent garantir qu'aucune requête utilisateur n'est perdue en raison de bugs réseau ou de redémarrages de serveur. Cette fiabilité est essentielle pour les outils professionnels où manquer une tâche pourrait avoir des conséquences graves.

La séparation de la mémoire de la fenêtre de contexte immédiate répond également aux préoccupations de coût et de performance. À mesure que les agents s'engagent dans des conversations plus longues et des tâches plus complexes, conserver tout l'historique dans le prompt devient coûteux et lent. Externaliser la mémoire permet à l'agent de maintenir un contexte à long terme sans alourdir chaque requête unique, rendant le système scalable pour une utilisation intensive.

De plus, le modèle de permissions fournit un filet de sécurité nécessaire pour les actions autonomes. En différant les appels d'outils à haut risque et en utilisant des proxies pour les credentials, les développeurs peuvent construire des agents qui agissent au nom des utilisateurs sans exposer des données sensibles ni effectuer des opérations dangereuses sans contrôle. Cet équilibre entre autonomie et contrôle est critique pour l'adoption en entreprise.

Ce que vous pouvez faire

  • Implémentez une boîte de réception d'événements durable en utilisant une base de données relationnelle pour mettre en file d'attente les webhooks entrants et les tâches planifiées.
  • Concevez un worker en arrière-plan qui traite une boîte de réception à la fois pour éviter les conditions de course et le travail dupliqué.
  • Stockez la mémoire de l'agent dans des fichiers externes ou un stockage d'objets, en ne chargeant que les index dans la fenêtre de contexte initialement.
  • Utilisez un proxy de credentials pour injecter des secrets dans les requêtes API, gardant les tokens hors de l'environnement direct de l'agent.
  • Créez un service de planification qui interroge une table de minuteurs et injecte les événements arrivés à échéance dans la boîte de réception principale.
  • Construisez un mécanisme de boîte d'envoi pour délivrer des résultats résumés aux utilisateurs au lieu de diffuser les étapes brutes du raisonnement.
  • #ai agents
  • #system architecture
  • #webhooks
  • #backend engineering
  • #llm ops

Outils de la Boutique Bytechap

Continuer la lecture

Tous les articles