Comment Rewire a mis au point un assistant vocal capable de se réécrire après chaque mauvaise réponse

#Agents IA #RAG #Base de données VectorAI

Points clés à retenir

Rewire identifie les défaillances des agents, propose plusieurs solutions possibles et les valide en se référant à l'historique des appels avant de mettre à jour l'workflow.
La base de données Actian VectorAI stocke les corrections validées sous forme de modèles de défaillance persistants qui peuvent être récupérés et réutilisés d'une session à l'autre et dans différents domaines.
Rewire classe les défaillances par structure plutôt que par vocabulaire de domaine, en recensant des détails tels que le type de défaillance, le rôle du nœud, les outils et le comportement de vérification.
Une correction de tarification des freins a ensuite été récupérée par un agent du secteur de la santé et utilisée pour corriger une quote-part d'assurance fictive, bien qu'il n'y ait eu aucun vocabulaire commun.
L'auto-évolution inter-domaines repose sur le stockage de signatures de défaillance réutilisables et sur la validation de chaque correctif récupéré avant qu'il ne puisse modifier une workflow en production.

Ce projet avait initialement été présenté dans le cadre du hackathon « Self-Evolving Agents ».

L'agent vocal de Rewirea simulé un prix de freinage, identifié le nœud responsable de la défaillance, généré 33 solutions concurrentes, éliminé 27 d'entre elles lors de la validation, puis validé le correctif retenu dans la mémoire de la base de données Actian VectorAI. Un agent spécialisé dans la santé, développé par Rewire, a ensuite récupéré ce correctif, l'a associé à une quote-part d'assurance simulée et a corrigé l'erreur du premier coup, sans qu'il y ait le moindre vocabulaire commun entre les deux domaines.

Ce transfert fonctionne car Rewire indexe les schémas d'échec en fonction de leur structure plutôt que du langage de l'appel qui les a générés. L'encodage prend en compte le type d'échec, le rôle du nœud, les outils disponibles, ainsi que le fait que l'agent ait ou non affirmé une valeur qu'il n'avait jamais vérifiée.

Ce qui ressort de ce processus, c’est un modèle d’échec suffisamment précis pour que la recherche aboutisse à un résultat pertinent, même lorsque le domaine, l’interlocuteur et la question sont tous différents. Comme l’a expliqué Aayush Gupta, le créateur de Rewire : « Nous avons écrit la fonction d’aptitude. C’est elle qui a défini les règles. »

Si vous développez un agent auto-évolutif, cette page cas client explique quelle représentation des défaillances enregistrer et comment valider une solution récupérée avant qu’elle ne soit appliquée à une workflow en production.

TL;DR

Rewire identifie et corrige les défaillances des agents de manière autonome. Il remonte la défaillance jusqu'au nœud d'workflow responsable, génère plusieurs solutions possibles et les valide en les comparant aux appels précédents.
VectorAI DB stocke ces corrections dans une mémoire persistante. Rewire enregistre les corrections validées sous forme de modèles de défaillance réutilisables.
La mémoire s'étend d'un domaine à l'autre. Un agent du secteur de la santé a récupéré une correction initialement générée à la suite d'une erreur de tarification des freins et l'a utilisée pour corriger une quote-part fictive.

Pourquoi l'ingénierie des prompts n'est pas la bonne solution

Un correctif manuel apporté au message d'invite peut résoudre un problème connu, mais il ne s'applique qu'à une seule instance. Si la même erreur se produit dans une autre workflow, vous devez la repérer, réécrire le message d'invite et espérer que le prochain appel ne se solde pas par un autre type d'échec. Une mise à jour du message d'invite indiquant à Rewire de récupérer le prix approuvé avant de répondre ne garantit pas que l'agent fera appel à l'outil de recherche la prochaine fois.

Les invites modifient le comportement d'un modèle de manière probabiliste. En l'absence d'un mécanisme permettant de relier deux défaillances, la mémoire de l'agent n'apprend jamais que la même erreur s'applique à un autre domaine, tel que la participation aux frais de santé ou la franchise d'assurance. Une conversation différente mettra en évidence le même cas de défaillance.

La génération augmentée par la récupération (RAG) améliore les résultats récupérés par un agent, tandis que Rewire modifie l’instruction ou le comportement de l’ workflow e qui n’a pas réussi à déclencher la récupération lors du premier appel. L’agent vocal modifie son environnement d’exécution après chaque incident, tandis que la mémoire sémantique stocke les schémas d’échec récurrents sous forme de contexte réutilisable. Aayush décrit ainsi l’approche de Rewire face aux défaillances des agents : « Notre agent vocal détecte lui-même ses bugs et réécrit son propre graphe de conversation. Personne ne touche aux invites. »

Comment fonctionne la boucle d'auto-réécriture

La boucle d'agents auto-évolutive de Rewire transforme les défaillances des agents en modifications validées du graphe de conversation, et ce à travers cinq composants.

Dograh organise et adapte le déroulement de la conversation, Pioneer soutient le raisonnement de l’agent, et Senso évalue chaque réponse à la lumière des connaissances vérifiées et stocke la politique d’escalade. Le validateur du système remonte les défaillances jusqu’au nœud racine, génère des correctifs alternatifs, les compare localement aux appels historiques et met à jour le graphe en temps réel. Actian VectorAI DB stocke les signatures de défaillance indépendantes du domaine et les données de correctifs pour les solutions qui ont fait leurs preuves.

Ce schéma illustre le parcours d'une défaillance dans Rewire, depuis son diagnostic jusqu'à la génération d'une correction, sa validation et son enregistrement en mémoire.

repenser l'architecture auto-évolutive

Pioneer et Senso

Pioneer génère le comportement de l'agent, tandis que Senso fournit les connaissances vérifiées utilisées pour évaluer ce comportement.

Le point de terminaison de Pioneer, compatible avec OpenAI, héberge le modèle gpt-5.4-mini qui génère les réponses de l’agent. Chaque appel produit des données d’exécution pour l’ workflow, notamment le nœud, les instructions, les outils disponibles, les appels d’outils et les transitions. Rewire utilise ces traces pour déterminer comment l’agent a généré une réponse et où une erreur s’est produite.

Senso fournit le signal d'évaluation. Son point de terminaison de recherche récupère la réponse vérifiée et la référence correspondante pour la question posée par l'appelant. SensoOracle compare la réponse de l'agent à ces éléments de preuve et renvoie un verdict structuré comprenant le score de justesse, le degré d'ancrage, la valeur de référence, le type d'échec, le raisonnement diagnostique et le résultat de la remontée hiérarchique. Chaque solution proposée est évaluée à l'aune de ce verdict avant que Rewire ne puisse la valider.

Cette distinction permet à la boucle de prendre en compte les deux aspects de l'échec. Pioneer montre ce que l'agent a fait, tandis que Senso détermine ce qu'il aurait dû faire en se basant sur des connaissances vérifiées. Dans le cas de l'erreur de tarification, l'agent avait accès à l'outil de base de connaissances mais ne l'a pas utilisé. Senso a fourni le prix vérifié, ce qui a permis à Rewire d'identifier la réponse incorrecte et de l'intégrer dans la boucle d'évolution.

Identification des nœuds et génération de positions concurrentes

Rewire identifie d'abord le nœud à l'origine de la défaillance, puis génère trois solutions alternatives pour ce nœud, plutôt que de se limiter à une seule solution.

Le nœud à l'origine de la réponse erronée peut ne pas être le même que celui qui a provoqué le problème sous-jacent. Rewire utilise la technologie de Dograh node_transition les événements et l'historique d'exécution afin de remonter à la source de la défaillance. Il crée ensuite une signature de défaillance à partir de la structure de la défaillance et l'utilise pour déterminer lequel des quatre opérateurs de mutation ci-dessous est approprié :

append_constraint ajoute une contrainte comportementale à l'instruction existante du nœud.
add_tool_requirement exige que le nœud lance un outil spécifique dans une situation donnée.
rewrite_instruction remplace les instructions existantes d'un nœud.
change_transition modifie le routage du graphe.

« Rewire » sélectionné add_tool_requirement en raison d'un dysfonctionnement du système de tarification des freins. Le correctif a mis à jour pricing_lookup exiger une consultation de la base de connaissances avant de fournir des informations tarifaires spécifiques.

Avant que Rewire ne puisse appliquer cette modification au graphe en production, le validateur hébergé par Guild doit la tester. Le validateur applique chaque correctif à une copie locale de l’ workflow , puis le réapplique aux appels historiques. Rewire ne conserve un correctif candidat que s’il corrige l’erreur à l’origine du déclenchement sans altérer le comportement qui fonctionnait correctement auparavant. Le système intègre au graphe en production le correctif retenu présentant le score de confiance de validation le plus élevé.

L'allocation de mémoire Actian

La base de données Actian VectorAI stocke les correctifs validés par type de défaillance, ce qui permet à Rewire de les récupérer dans tous les domaines.

Rewire construit le vecteur à partir de la signature de l'échec. Cette signature recense le type d'échec, le rôle du nœud, les outils disponibles, l'appel de l'outil et indique si l'agent a déclaré une valeur spécifique. Elle exclut la question de l'appelant et les termes propres au domaine, de sorte que la recherche se concentre uniquement sur la structure de l'échec.

Ce bloc de code indique le moment précis où un correctif validé est intégré à la base de données VectorAI :

def store(self, patch: WorkflowPatch) -> str:
        """Embed the patch's failure signature, upsert with its flat payload.

        Returns the Actian point id (a uuid5 of `patch.patch_id`, so this is a
        true upsert — storing the same patch twice after validation flips it
        from candidate to promoted in place rather than duplicating it).
        """
        self._require_ready()
        vector = embed(patch.signature.to_embedding_text())
        pid = point_id_for(patch.patch_id)
        self.client.points.upsert(
            self.collection,
            [PointStruct(id=pid, vector=vector, payload=patch.to_actian_payload())],
        )
        return pid

Modèle de défaillance indexé par forme et enregistré dans la base de données VectorAI après avoir passé avec succès le test de relecture.

signature.to_embedding_text() génère le texte que Rewire intègre en vue de sa récupération. Le store() Cette méthode convertit la signature de défaillance en un vecteur à 384 dimensions, génère un identifiant déterministe à partir de l'identifiant du correctif, puis ajoute (ou met à jour) à la fois le vecteur et la charge utile du correctif dans la collection. La réutilisation du même identifiant de correctif permet de mettre à jour l'entrée existante au lieu de créer un doublon.

Pour la démonstration inter-domaines, Aayush a exécuté un agent spécialisé dans la santé avec un cas d’échec distinct. Celui-ci a inventé une quote-part d’assurance de 40 $ alors que le montant vérifié était de 47 $, puis a récupéré le correctif de « freinage des prix » dans la base de données de VectorAI. La signature de l’échec ne contenait aucun terme propre au domaine de la santé, mais le schéma commun était que l’agent avait affirmé une valeur spécifique sans utiliser d’outil de vérification disponible. Si Rewire Embarqué la question de l’appelant ou des mots-clés spécifiques au domaine, la récupération dépendrait du vocabulaire.

Le résultat inter-domaines et ce qu'il signifie pour votre agent

L'échec lié au secteur de la santé a fonctionné parce que Rewire a indexé la structure de l'échec plutôt que son domaine. La signature comprenait les propriétés communes aux deux échecs, ce qui a permis à VectorAI DB de récupérer la solution relative au prix des freins, même si l'échec lié au secteur de la santé ne contenait aucun terme propre au secteur automobile.

Aayush a qualifié ce résultat de conséquence inattendue du système : « Ensuite, il y a eu ce pour quoi nous n’avions pas prévu de solution : la règle qu’il avait apprise concernant la tarification des freins a été récupérée dans Actian par un agent du secteur de la santé, issu d’un domaine différent, sans aucun vocabulaire commun, sur la base d’une simple correspondance avec la nature de la défaillance, et a permis de régler dès le premier essai une quote-part d’assurance fictive. »

Si vous souhaitez mettre en place une recherche inter-domaines au sein de votre propre agent auto-évolutif, Embarquer uniquement la représentation de l’échec que vous souhaitez que le système réutilise. L’indexation de l’intégralité de la conversation introduit un langage spécifique au domaine dans le signal de recherche et peut limiter les échecs correspondants. Rewire conserve cette représentation au niveau de la signature de l’échec. La récupération fournit une solution candidate, mais Rewire valide cette solution avant de l’autoriser à modifier le graphe. Un correctif généré dans une « workflow » ne peut atteindre une autre qu’après avoir passé le même processus d’évaluation.

Le tableau ci-dessous présente trois modèles de conception de Rewire que vous pouvez intégrer dès aujourd'hui à l'architecture de vos agents.

Motif	Ce qu'a fait Rewire	Ce que vous mettez en œuvre
Index par forme	Nous avons encodé les signatures de défaillance à l'aide de propriétés structurelles et les avons stockées dans la base de données VectorAI sans contenu spécifique au domaine.	Définir un schéma de défaillance normalisé qui décrit la manière dont l'agent a connu une défaillance, puis « Embarquer r » cette représentation en vue de sa récupération
Éliminer par relecture	Les correctifs générés et récupérés ont été testés par rapport à la défaillance à l'origine du problème et à l'historique des appels ; Rewire n'a retenu que les correctifs qui résolvaient la défaillance sans introduire de régressions	Appliquer chaque correction proposée à l'workflow actuelle, reproduire des cas historiques représentatifs, et ne la valider qu'une fois qu'elle a passé le contrôle de régression.
Laissons l'agent rédiger les règles	A permis à l'agent de proposer des mises à jour du graphe dans le cadre d'un ensemble borné d'opérateurs de mutation, puis a validé le résultat workflow	Donner à l'agent le contrôle sur la règle comportementale qu'il propose, limiter les opérateurs de mutation disponibles et laisser la validation basée sur l'exécution déterminer quelles règles sont conservées

La réutilisation entre domaines dépend de la représentation de la défaillance stockée en mémoire et de la validation effectuée avant la réutilisation. VectorAI DB a fourni à Rewire un stockage persistant pour les modèles de défaillance validés ; ainsi, une solution apprise lors d’une session peut être mise à disposition lorsqu’un autre agent rencontre la même structure de défaillance.

Essayez VectorAI DB Community Edition sur votre ordinateur local à l'aide de la commande « Docker pull ».

Ce projet a été initialement présenté dans le cadre du hackathon « Self-Evolving Agents ». Consultez le projet Rewire sur GitHub.

À propos de l'auteur