Article

Créer un plugin sur DeepSeek Harness pour surveiller ses agents

Découvre comment construire un plugin d'observabilité en temps réel sur DeepSeek Harness pour monitorer la santé de tes agents autonomes et réduire les boucles d'erreurs.

Créer un plugin sur DeepSeek Harness permet d'ajouter des capacités de surveillance en temps réel à tes systèmes autonomes. En utilisant le mode Creator et un prompt structuré en six étapes, tu peux générer un outil d'observabilité complet, comme un enregistreur de vol pour agents. Ce type de plugin s'installe temporairement dans le runtime grâce à l'architecture Cordis, sans alourdir ton environnement global. Il va traquer les métriques essentielles : nombre d'appels d'outils, latence moyenne et surtout le risque de boucle d'erreur. Lors d'un test concret avec le modèle DeepSeek V4 Pro configuré sur un niveau de raisonnement élevé, la création de ce système a consommé 248 000 tokens, soit seulement 25 % de la fenêtre de contexte disponible, pour un coût total de 1,35 dollar. Cette approche remplace avantageusement les anciens workflows rigides en offrant une auto-réparation immédiate dès qu'un score de santé devient critique, garantissant ainsi des opérations fiables à grande échelle.

Cet article reprend et développe la vidéo Crée ton plugin DeepSeek Harness (Guide Complet). Regarder la vidéo sur YouTube, puis t'abonner à la chaîne pour les prochaines.

À retenir

Surveiller la santé du système avec un enregistreur de vol

L'objectif central de cette opération consiste à déployer un observateur en direct au sein de ton environnement de travail. Ce plugin, agissant comme une véritable boîte noire d'avion, repère les erreurs répétées que le modèle produit lui-même lors de ses cycles d'exécution. Il affiche ensuite un score de santé dynamique qui te permet de valider instantanément le bon fonctionnement de tes processus. Au lieu de subir les pannes silencieuses qui ruinent la rentabilité de tes automatisations, tu disposes d'un indicateur clair et immédiat sur la stabilité de tes agents.

Plutôt que de naviguer à l'aveugle dans des terminaux obscurs, tu obtiens un tableau de bord visuel directement intégré à ton interface. Ce panneau remonte les métriques cruciales telles que le volume d'appels d'outils, la latence moyenne et le pourcentage d'erreurs en temps réel. Dès qu'une anomalie se présente, comme une commande exécutée six fois de suite de manière infructueuse, le score bascule dans le rouge pour t'alerter. Le système identifie la faille de manière autonome, stoppe l'hémorragie technique et applique une correction immédiate pour ramener les indicateurs au vert, assurant ainsi une continuité de service irréprochable.

Remplacer les architectures rigides par des environnements modulaires

Maintenir des automatisations complexes avec des outils traditionnels devient rapidement un goulet d'étranglement insurmontable. Tenter de gérer des métriques avancées, d'anticiper les risques de boucles infinies ou de configurer des réparations automatiques sur des plateformes classiques demande des semaines de développement acharné. Tu te retrouves inévitablement à empiler des rustines techniques et à scruter des historiques d'exécution interminables pour comprendre pourquoi une tâche critique a soudainement échoué. Cette approche archaïque draine tes ressources et t'empêche de te concentrer sur la stratégie globale de ton activité.

L'absence d'observabilité native te condamne à subir les mêmes pannes jour après jour, sans aucune perspective d'amélioration continue. Si ton système rencontre dix bugs aujourd'hui, une architecture figée t'assure d'en affronter au moins autant demain, voire davantage si la charge augmente. En migrant vers des environnements dynamiques, tu confies l'analyse des journaux d'événements à un agent réparateur dédié. Ce dernier identifie la source exacte du problème et déploie un correctif de manière totalement autonome en quelques fractions de seconde, réduisant progressivement le taux d'échec jusqu'à atteindre une fiabilité absolue sur le long terme.

Exploiter les quatre couches de l'architecture agentique

Le fonctionnement de cet écosystème repose sur une structure rigoureusement divisée en quatre strates distinctes. Tu retrouves d'abord les skills, qui regroupent tes méthodes réutilisables à travers différents projets pour standardiser tes opérations. Viennent ensuite les hooks, spécifiquement conçus pour déclencher des contrôles précis à des moments clés du cycle agentique. La troisième couche intègre les MCPs, qui connectent ton environnement à des outils externes pour déployer du code, manipuler des bases de données ou générer des médias. Enfin, les plugins rassemblent des capacités complètes et prêtes à l'emploi que tu peux greffer selon tes besoins.

Au cœur de cette mécanique de précision se trouve une pièce maîtresse nommée Cordis. Ce composant fondamental relie l'ensemble de ces couches avec l'interface utilisateur, la boucle des agents et les modèles d'intelligence artificielle sous-jacents. C'est grâce à lui que tu peux installer un outil de surveillance dans un emplacement purement temporaire. Le plugin s'active uniquement lorsque le système est en cours d'exécution et se retire proprement à la fin de la session. Cette gestion éphémère préserve toute la puissance de calcul de ta machine, évitant l'accumulation de paquets inutiles qui finiraient par saturer ta mémoire.

Structurer le déploiement avec une validation humaine

La construction d'un outil sur mesure exige une approche méthodique pour éviter les dérives et garantir un résultat exploitable. Le processus démarre par l'envoi d'une instruction détaillée, structurée en six étapes distinctes, au sein du mode créateur. Le modèle commence par cartographier minutieusement l'existant : il inspecte les services disponibles, les événements réels du système et les limites strictes de l'environnement de test. Cette phase d'état des lieux garantit que l'architecture proposée s'intègre parfaitement aux contraintes techniques de ta machine avant même d'écrire la moindre ligne de configuration.

Une fois la préparation architecturale achevée, la sécurité reprend immédiatement ses droits. Le système suspend son exécution de lui-même et attend une autorisation explicite de ta part avant d'aller plus loin. Cette barrière humaine empêche la machine d'obtenir des permissions globales et de modifier des fichiers sensibles sans ton accord formel. Dès que tu valides le lancement via une commande de confirmation, le composant s'active en toute sécurité, collecte les premières données d'exécution et génère un rapport final confirmant la réussite de l'intégration dans ton espace de travail.

Analyser les coûts et la consommation de contexte

Le passage à la pratique révèle l'efficacité redoutable de cette méthode d'orchestration. Lors de la génération complète du plugin avec le modèle DeepSeek V4 Pro, l'interface de trajectoire a mis en évidence une majorité d'actions réalisées de manière totalement autonome, limitant ton intervention à la simple validation des étapes clés. Cette traçabilité visuelle permet de suivre précisément chaque appel d'outil, de comprendre le cheminement logique de l'agent et d'identifier les axes d'optimisation sans jamais avoir à plonger dans des lignes de code complexes. Tu gardes ainsi une vision claire sur les opérations en cours.

Sur le plan des ressources matérielles et financières, l'opération s'avère particulièrement économe. L'ensemble du processus de création et de test n'a consommé que 248 000 tokens, exploitant à peine un quart de la fenêtre de contexte totale fixée à un million de tokens. D'autres solutions concurrentes sur le marché auraient facilement saturé plus de la moitié de cette capacité pour un résultat similaire, augmentant mécaniquement les risques d'hallucination. Côté facturation, ce déploiement complet, incluant les phases de raisonnement intense et les multiples itérations de correction autonome, a représenté un investissement dérisoire de seulement 1,35 dollar.

Les moments clés de la vidéo

  1. Ce qu'on va construire

    Présentation de l'objectif de la session : créer un enregistreur de vol pour observer les erreurs en temps réel.

  2. Les 4 couches qui font tout

    Explication des quatre couches fondamentales qui composent l'architecture des environnements agentiques.

  3. Cordis, la pièce maîtresse

    Analyse du rôle central de Cordis pour connecter et déconnecter des composants sans impacter les performances.

  4. Méga prompt en 6 étapes

    Déploiement d'une instruction structurée en six étapes pour générer le plugin d'observabilité.

  5. Les trajectoires

    Utilisation de l'interface visuelle pour suivre les appels d'outils et comprendre le raisonnement du modèle.

  6. Pourquoi n8n ne suffit plus

    Comparaison entre les limites des anciens workflows rigides et la flexibilité des nouveaux environnements.

  7. Le go humain avant le run

    Mise en place d'une barrière de sécurité exigeant une validation manuelle avant l'exécution des tâches critiques.

  8. Runtime Health en direct

    Activation du plugin et première collecte des métriques de santé directement dans l'interface utilisateur.

  9. Le score qui vire au rouge

    Détection d'une anomalie critique et démonstration de la capacité du système à s'auto-réparer instantanément.

  10. Rapport final et l'option A

    Génération du rapport d'exécution et exploration des options d'amélioration pour approfondir l'observabilité.

  11. Mon verdict et le vrai coût

    Bilan de l'opération, analyse de la consommation de la fenêtre de contexte et détail de la facturation finale.

Ce qu'il faut en faire

L'intégration d'un système d'observabilité transforme radicalement la gestion de tes agents autonomes. Au lieu de subir les pannes et de passer des heures à déchiffrer des historiques d'exécution complexes, tu disposes désormais d'un tableau de bord clair qui identifie et corrige les défaillances en temps réel. La prochaine étape consiste à déployer ce plugin d'enregistrement de vol sur tes propres workflows critiques. Commence par l'installer sur une tâche de rédaction ou d'extraction de données à faible enjeu pour observer son comportement face aux boucles d'erreurs. Une fois que tu auras validé sa capacité d'auto-réparation sur ton infrastructure, tu pourras l'étendre à l'ensemble de tes opérations commerciales pour garantir une stabilité absolue.

Construis un système IA qui reste maîtrisable

Le LABO IA t'aide à choisir les modèles, connecter les outils et vérifier les workflows sur des cas réels, sans dépendre d'un seul fournisseur.

Découvrir le programme

Questions fréquentes

Quelle est la différence entre un skill et un plugin ?

Un skill correspond à une méthode ou un workflow réutilisable que tu peux appliquer sur plusieurs projets distincts pour standardiser tes processus. Un plugin, en revanche, regroupe un ensemble de capacités complètes et installables directement dans ton environnement de travail. Le plugin agit comme une application autonome qui s'intègre temporairement ou de façon permanente à ton système global, offrant des fonctionnalités avancées prêtes à l'emploi.

Comment fonctionne l'architecture Cordis au sein du système ?

Cordis agit comme le véritable chef d'orchestre de ton environnement agentique. Il relie les différentes couches techniques, l'interface utilisateur, les modèles d'intelligence artificielle et la boucle d'exécution. Sa force principale réside dans sa capacité à connecter et déconnecter des composants en temps réel. Tu peux ainsi charger un outil complexe pendant une session spécifique et le retirer immédiatement après, sans laisser de résidus qui ralentiraient ta machine.

Pourquoi exiger une validation humaine avant l'exécution ?

L'intégration d'un nouveau composant dans un environnement agentique implique de manipuler des permissions globales et d'exécuter des commandes système. Laisser une intelligence artificielle agir de manière totalement autonome à cette étape présente un risque de sécurité majeur. La validation explicite agit comme un pare-feu indispensable : elle te permet de vérifier la cartographie et l'architecture proposées avant d'autoriser le modèle à modifier concrètement ton espace de travail.

Quel est le coût réel pour générer ce type de plugin ?

La création complète d'un outil d'observabilité sur mesure s'avère extrêmement économique. Lors d'un test en conditions réelles avec le modèle DeepSeek V4 Pro configuré sur un niveau de raisonnement élevé, l'ensemble du processus a coûté exactement 1,35 dollar. Ce tarif inclut la phase d'inspection initiale, la conception de l'architecture, les multiples itérations de correction autonome et la génération du rapport final, le tout en consommant seulement 248 000 tokens de contexte.

Meydeey, architecte IA et automatisation
Meydeey, architecte IA et automatisation.

Tests terrain, architecture multi-modèles et systèmes d'automatisation conçus pour rester vérifiables.

Toutes les vidéos du sujet Dev IA & agents