Meilleures pratiques pour créer et évaluer des agents d'utilisation des ordinateurs

Un agent informatique fonctionne en boucle : il regarde l'écran, agit et regarde à nouveau. Les pratiques suivantes vous aident à créer des agents qui exécutent des tâches de manière fiable, en moins d'étapes et à moindre coût. Ils s'appliquent à tous les flux de travail et à toutes les familles de modèles. Les résultats varient en fonction de votre flux de travail, de votre modèle, de vos instructions et de votre environnement, alors mesurez chaque changement sur vos propres tâches.

Concevez la boucle d'action

La plupart des efforts d'un agent sont consacrés à la lecture de l'écran et à la saisie, et non à se déplacer entre les fenêtres. Réduisez les erreurs de lecture et le nombre d'étapes avant de régler la navigation.

• Donnez du texte à l'agent au lieu de pixels. La lecture de valeurs exactes, telles que les noms, les adresses e-mail et les numéros de compte, à partir d'une capture d'écran est une source fréquente d'erreurs. Lorsque les données ont une copie texte, fournissez-la via un outil. Pour les valeurs figurant dans des tableaux ou des colonnes, demandez également à l'agent de visualiser l'image, car une couche de texte peut mélanger les colonnes.

• Placez l'instruction avant la capture d'écran. Lorsque l'agent doit trouver quelque chose et cliquer dessus, placez l'instruction devant l'image dans la demande, afin que l'agent sache ce qu'il doit rechercher.

• Commencez à partir d'une mise en page connue. Optimisez chaque application à l'aide d'un raccourci clavier avant que l'agent n'y travaille. Une mise en page cohérente rend les flux répétés plus prévisibles et réduit le défilement.

• Préférez le clavier. Utilisez les raccourcis clavier pour faire défiler la page, agrandir les fenêtres et ouvrir les menus, en particulier pour les commandes de petite taille ou difficiles d'accès. Les raccourcis ne dépendent pas de la localisation d'un contrôle à l'écran.

• Confirmez chaque action. Une application qui est occupée peut ignorer une frappe. Attendez brièvement après chaque action, gardez quelques captures d'écran récentes en vue et demandez à l'agent de répéter une action qui n'a eu aucun effet.

• N'utilisez Tab que là où c'est sûr. La touche Tab fonctionne bien dans les champs de texte brut. Cliquez sur les champs dans lesquels l'application réagit lorsqu'un champ perd le focus, tels que les champs à remplissage automatique, les listes déroulantes ou les sélecteurs de dates.

• Switch, ne le relancez pas. Pour passer d'une application en cours d'exécution à une autre, utilisez la barre des tâches ou le sélecteur d'applications. La relance d'une application ajoute des étapes.

• Localisez les commandes sur l'écran actuel. Les coordonnées copiées depuis un écran précédent deviennent obsolètes lorsqu'une fenêtre se déplace. Utilisez des coordonnées fixes uniquement dans une mise en page fixe et maximisée.

• Détectez les actions qui ne changent rien. Lorsque deux actions consécutives laissent l'écran inchangé, demandez à l'agent de changer d'approche. Limitez le défilement répété, afin qu'une course ne dépense pas son budget par étapes pour une seule action.

• Actions par lots avec soin. Un lot affiche à l'agent uniquement l'écran après sa dernière action, donc terminez un lot sur le seul écran que l'agent doit lire. Déterminez si le traitement par lots permet de gagner du temps sur l'ensemble de votre flux de travail avant de vous y fier. Renvoie les erreurs de lot sous forme de texte uniquement, car certains modèles rejettent un résultat d'erreur incluant une image.

S'adapter à la famille de modèles

Les familles de modèles utilisent un ordinateur de bureau différemment. Construisez la boucle d'agents une seule fois et adaptez les compétences et les paramètres à chaque famille. Une compétence adaptée à une famille doit généralement être corrigée avant de fonctionner avec une autre.

• Envoyer une nouvelle capture d'écran après chaque modification. Certains modèles continuent à agir sur une ancienne capture d'écran sans signaler de problème. Joignez une nouvelle capture d'écran après chaque action qui change l'écran.

• Gérer les coordonnées de manière explicite. Certains modèles indiquent les coordonnées en pixels, tandis que d'autres indiquent les coordonnées sur une grille normalisée que vous devez convertir en pixels. Indiquez la taille de l'écran et la plage de coordonnées valide dans l'invite, puis vérifiez que chaque clic se trouve dans l'écran.

• Dimensionner les captures d'écran par rapport au modèle. Faites correspondre la résolution de la capture d'écran à la limite d'image du modèle. Si vous réduisez la taille d'une capture d'écran, redimensionnez les coordonnées du modèle avant de cliquer.

• Effacer les champs avant de taper. Sur certains modèles, la saisie ajoute à un champ au lieu de remplacer sa valeur. Concentrez le champ, sélectionnez tout, supprimez, tapez une fois et relisez la valeur.

• Contrôlez les appels d'outils parallèles. Si un modèle envoie plusieurs actions dans un seul message, quelle que soit l'invite, désactivez les appels d'outils parallèles dans le client. Exécutez les actions par lots dans l'ordre et arrêtez-vous au premier échec.

• Limiter l'effort de raisonnement par défaut. Les tâches simples sont souvent couronnées de succès avec peu d'effort, et un effort plus élevé entraîne des coûts sans améliorer la précision. Augmentez l'effort pour les tâches comportant des branches ou comportant plusieurs étapes.

• Faites correspondre la longueur de l'invite au modèle. Des modèles plus robustes peuvent fonctionner à partir d'un objectif à court terme. Ajoutez des règles uniquement là où un modèle en a besoin et raccourcissez l'invite à mesure que les modèles s'améliorent.

• Continuez à raisonner entre les tours. Si vous appelez un modèle de raisonnement via un framework ou une API de compatibilité, vérifiez que le raisonnement du modèle est transmis d'un tour à l'autre. Une boucle qui le fait tomber peut caler.

• Comparez le coût par tâche terminée. Les modèles diffèrent quant au nombre de jetons qu'ils utilisent par étape, de sorte que le prix par jeton à lui seul ne permet pas de prédire le coût. Comparez les modèles avec la surface de l'outil que vous comptez utiliser.

Compétences en matière de rédaction et instructions

La compétence, les instructions que vous donnez à l'agent pour un flux de travail, ont un effet important sur la précision et les coûts. Une invite générique mal conçue peut donner de moins bons résultats que pas d'invite du tout.

• Incluez quelques règles de travail. Par exemple : mémorisez ce que vous avez lu, vérifiez avant de poursuivre, changez d'approche après deux tentatives infructueuses et attendez que l'application réponde.

• Donnez des faits, pas des procédures. Les modèles actuels nécessitent moins de conseils étape par étape. Faites preuve de brièveté et incluez les informations que l'agent ne peut pas découvrir, telles que les chemins de fichiers, les formats de champs et les particularités des applications.

• Définissez des champs à valeur élevée. Indiquez le format exact des champs tels que les identifiants et les numéros de compte, et demandez à l'agent de vérifier chaque valeur par rapport à ce format avant de la saisir.

• Rendez la vérification requise et ciblée. Les agents peuvent saisir des valeurs erronées en toute confiance. Ne laissez donc pas l'agent décider de la vérification. Vérifiez chaque valeur une fois, juste après l'avoir saisie, et relisez les quelques champs à valeur élevée avant de l'enregistrer. Une nouvelle vérification complète de chaque champ permet d'ajouter des étapes sans améliorer la précision.

• Corrigez les erreurs sur place. Lorsqu'une valeur est erronée, demandez à l'agent de corriger ce champ au lieu d'effacer et de saisir à nouveau l'intégralité du formulaire.

• Transmettre proprement aux sous-agents. Donnez des instructions complètes à un sous-agent et demandez-lui un rapport à la fin, au lieu de vérifier son travail au fur et à mesure.

• Améliorez vos compétences grâce à vos propres courses. Passez en revue les captures d'écran, les actions et le raisonnement de chaque exécution, modifiez une règle à la fois et ne conservez une modification que si chaque exécution réussit toujours. Divisez le flux de travail en étapes, afin de voir où s'arrêtent les échecs.

Gérez le contexte et les coûts

Le coût dépend principalement du contexte du modèle et du nombre d'étapes d'une exécution. Chaque appel renvoie l'historique, de sorte que chaque étape supplémentaire coûte plus cher que la précédente. Le moyen le plus efficace de réduire les coûts est de choisir le modèle et la compétence qui permettent de terminer la tâche en un minimum d'étapes.

• Réinitialiser le contexte entre les tâches. Démarrez chaque tâche indépendante à partir d'un contexte propre et d'un état d'écran connu.

• Ne conservez que les captures d'écran récentes. Conservez quelques captures d'écran récentes, comme les trois dernières, et remplacez les anciennes images par une courte note textuelle. Le fait de ne conserver qu'une seule capture d'écran peut augmenter les coûts, car l'agent fait défiler la page pour voir ce qu'il a perdu.

• Indiquez à l'agent ce que vous supprimez. Expliquez que les anciennes captures d'écran sont supprimées à dessein et demandez à l'agent d'enregistrer chaque valeur dans sa réponse pendant que la valeur est affichée à l'écran.

La mise en cache rapide peut réduire considérablement les coûts, mais uniquement si vous créez la charge utile avec soin :

• Ajoutez uniquement à la fin de la conversation. La mise en cache correspond à la charge utile dès le départ, donc une modification apportée à un tour antérieur invalide le cache.

• Supprimez les anciennes captures d'écran par lots, et non à chaque tour, afin que le préfixe mis en cache reste le même entre les suppressions.

• Ne reprenez pas la conversation à chaque tour. Une charge utile qui change à chaque tour peut coûter plus cher avec la mise en cache que sans elle.

• Vérifiez que la mise en cache est activée. Les modèles ont une taille de préfixe minimale pour la mise en cache, et un préfixe plus petit n'est pas mis en cache et ne renvoie pas d'erreur.

Mesurer les résultats

• Effectuez suffisamment d'essais. Les résultats varient d'un essai identique à l'autre. Effectuez de nombreux essais, signalez la propagation et utilisez un test statistique, tel qu'un test par paires, avant de conclure qu'une version est meilleure.

• Calculez le coût de chaque type de jeton. Incluez les nouvelles entrées, les sorties, les écritures dans le cache et les lectures dans le cache. Les fournisseurs signalent les jetons de cache différemment, alors vérifiez comment chacun les compte. Déclarez les jetons en plus du coût.

• Déclarer le coût avec le score. Un changement peut conserver le même taux de réussite tout en augmentant les coûts. Indiquez le taux de réussite, le coût et les étapes ensemble, et séparez le coût des essais réussis et des échecs.

• Définissez la limite de pas avec soin. Définissez la limite au-dessus des besoins du flux de travail et indiquez le nombre d'exécutions qui l'ont atteinte. Une course qui n'a plus d'étapes nécessite une correction différente de celle d'une course qui a produit un résultat erroné. Définissez également des limites de temps et de coûts, et prenez en charge l'annulation.

• Changez une chose à la fois. Maintenez tout le reste fixe afin de pouvoir voir l'effet de chaque modification.

• Triez les échecs par cause. Séparez les échecs de lecture de l'écran des échecs d'action. Une compétence peut améliorer la façon dont l'agent agit, mais pas la qualité de lecture du modèle. Avant d'attribuer une amélioration à une règle, vérifiez que l'agent l'a respectée.

• Notez le résultat, pas le rapport de l'agent. Vérifiez l'enregistrement enregistré et l'écran final à l'aide d'un évaluateur automatique qui exige que chaque champ corresponde et inclut un contrôle négatif. Un agent peut signaler qu'une tâche est terminée alors qu'elle ne l'est pas.

• Vérifiez votre configuration de test. Les erreurs dans l'évaluateur ou dans l'environnement peuvent ressembler à des défaillances de l'agent. Enregistrez chaque invite, capture d'écran et action afin de pouvoir suivre les échecs des exécutions. Ne publiez pas de résultats que vous ne pouvez pas reproduire.

Supervision et sécurité

• Tenez une personne au courant. Exigez une confirmation avant d'effectuer des actions consécutives ou difficiles à annuler, telles que les paiements, les suppressions ou les soumissions. Traitez la saisie de données sensibles dans un formulaire comme si vous l'envoyiez. Vérifiez la confirmation requise avant chaque action d'un lot et relocalisez la cible une fois qu'une personne l'a approuvée, car l'écran a peut-être changé.

• Transmettre les questions de l'agent à une personne. Certains modèles s'arrêtent et demandent eux-mêmes une confirmation, par exemple lorsque l'écran suggère un système de production. Assurez-vous que votre boucle peut montrer la question à une personne.

• Limiter ce que l'agent peut atteindre. Exécutez l'agent dans un environnement isolé avec un minimum d'autorisations. Dans la mesure du possible, gardez les informations de connexion hors de portée de l'agent et limitez l'accès à Internet à une liste de domaines autorisés.

• Traitez le contenu affiché à l'écran comme non fiable. Le texte d'une page ou d'un document ne peut pas accorder d'autorisations ni modifier la tâche. Ne laissez pas les instructions à l'écran rediriger l'agent.

• Éloignez l'agent du Web ouvert. Intégrez les informations dont l'agent a besoin dans la compétence, au lieu de lui demander de faire des recherches sur le Web, où il peut trouver des CAPTCHA et du contenu non fiable.

Ressources connexes

Les fournisseurs de modèles publient des conseils d'utilisation de l'ordinateur pour leurs modèles. Leur documentation actuelle décrit les détails spécifiques au modèle, tels que les tailles d'écran, les systèmes de coordonnées et les outils pris en charge.

• Outil d'utilisation de l'ordinateur dans la documentation anthropique

• Utilisation de l'ordinateur dans la documentation OpenAI

• Utilisation de l'ordinateur dans la documentation de l'API Gemini