PenguinHarness construit et améliore un agent IA pour seulement 0,2 yuan
LlamaFactory rend le réglage fin des grands modèles plus accessible à une plus large communauté de développeurs. Aujourd'hui, ses créateurs, Zheng Yaowei et l'équipe PrismShadow, appliquent cette même philosophie de simplicité à...
PenguinHarness permet de construire et d'améliorer automatiquement des agents IA pour seulement 0,2 yuan
Introduction
LlamaFactory a rendu le fine-tuning de modèles à grande échelle plus accessible à un large éventail de développeurs. Aujourd'hui, son créateur Zheng Yaowei et l'équipe PrismShadow appliquent la même approche « la simplicité d'abord » aux agents IA.
Leur nouveau projet open source, PenguinHarness, vise à automatiser les trois étapes du cycle de vie d'un agent :
- Construire l'application d'agent
- Évaluer ses performances
- Améliorer en continu ses prompts, ses compétences et sa configuration
Les utilisateurs n'ont plus besoin de sélectionner manuellement un framework, de connecter des outils, de rédiger des prompts, de créer une interface et de tester les résultats à plusieurs reprises. Il leur suffit de décrire leurs besoins pour laisser PenguinHarness assembler une application d'agent fonctionnelle.
PenguinHarness est un outil open source de construction automatique d'agents destiné au déploiement sur poste de travail et serveur.
Le projet est léger, publié sous licence Apache 2.0, et prend en charge Linux, macOS et Windows. Il peut être exécuté localement ou utilisé sur un serveur distant via une interface navigateur.
PenguinHarness prend également en charge les modèles en ligne et locaux grâce à des préréglages intégrés et une interface compatible OpenAI. Le dépôt officiel répertorie actuellement les derniers modèles de fournisseurs tels que DeepSeek, Kimi, GLM, Qwen, OpenAI, Google, Anthropic, etc.
Le rapport original décrit une application RAG générée pour un coût de seulement 0,2 yuan en frais de tokens de modèle. La page officielle du projet indique le même exemple pour environ 0,02 $US (avec DeepSeek V4 Pro).
Ce chiffre est une donnée de démonstration du projet, et non un prix fixe garanti. Le coût réel dépend du modèle choisi, du fournisseur, de la complexité des prompts, du nombre de tentatives, de la portée de l'application et de la tarification des tokens.
Faire construire un agent par un autre agent
PenguinHarness repose sur une idée simple : un agent devrait pouvoir construire une autre application d'agent à partir d'une exigence exprimée en langage naturel.
Cela s'inscrit dans les discussions plus larges sur « l'IA au service de l'IA » et l'amélioration récursive de soi-même — des systèmes d'IA qui aident à créer, tester ou améliorer d'autres systèmes d'IA.
Le premier cas d'utilisation présenté dans l'article source demandait au système de construire une application RAG capable de :
- Récupérer des informations par segmentation
- Générer des réponses claires en flux continu
- Inclure des sources citées
- Fournir une interface front-end utilisable
- Fonctionner comme une application complète
Le test comparatif plaçait PenguinHarness face à un agent de codage, les deux systèmes devant accomplir des tâches similaires.
Selon la démonstration du projet, PenguinHarness a réalisé l'application plus rapidement et avec un coût en tokens inférieur. Ses résultats incluaient des réponses fluides, une sortie en continu et des sources liées.
La sortie du concurrent présentée dans le rapport présentait des problèmes de mélange linguistique et ne disposait pas du même comportement de flux continu.
Ces exemples sont des démonstrations utiles, mais ils ne prouvent pas de manière générale que PenguinHarness surpasse tous les agents de codage dans tous les scénarios.
Les résultats dépendent dans une large mesure du modèle, de la configuration de l'agent, de la conception de la tâche et de la méthode d'évaluation.
Du besoin à l'application fonctionnelle
Le développement traditionnel d'agents implique généralement plusieurs étapes manuelles :
- Choisir un framework d'agent.
- Sélectionner et configurer le modèle.
- Connecter les outils et services externes.
- Rédiger les prompts système.
- Définir la logique de mémoire et de workflow.
- Construire les cas d'évaluation.
- Tester et modifier l'agent.
- Créer l'interface front-end ou de livraison.
- Empaqueter l'application pour le déploiement.
PenguinHarness tente de transformer ces étapes en un flux de travail unique piloté par l'agent.
Lorsque l'exigence est claire, le système peut générer :
- Le squelette de l'application
- Les prompts de l'agent
- Les définitions de compétences et d'outils
- Les fichiers de configuration
- Le code auxiliaire
- Le front-end
- Les instructions d'installation
- Les instructions d'exécution
- Les corrections et optimisations itératives
L'exemple officiel du projet utilise la requête suivante :
Collectez la documentation de https://github.com/ericbuess/claude-code-docs et construisez une application RAG qui répond aux questions sur Claude Code en tant qu'expert de la configuration, en citant ses sources.
Le projet indique que l'application RAG générée a consommé environ 0,02 $US (soit 0,2 yuan) en tokens de modèle lors de sa construction avec DeepSeek V4 Pro.
Le système de fichiers comme source de vérité
PenguinHarness utilise les fichiers comme principale couche de collaboration entre l'humain et l'agent.
Dans cette conception :
- L'agent est représenté par des fichiers.
- Les prompts sont des fichiers.
- Les compétences sont des fichiers.
- La configuration est stockée dans des fichiers.
- Les conversations et les exécutions peuvent être suivies via des journaux enregistrés.
- De nouveaux agents peuvent être créés en assemblant ou en copiant la structure de fichiers requise.
Cette approche rend l'agent plus facile à inspecter et à modifier.
Plutôt que de cacher les comportements importants dans un vaste framework applicatif, PenguinHarness utilise des fichiers modifiables comme interface principale. Les humains peuvent lire et modifier ces fichiers, tandis que les agents peuvent les améliorer dans le cadre de processus d'optimisation approuvés.
L'outil se charge d'assembler ces fichiers dans un objet agent exécutable.
PenguinMessage fournit un protocole unifié
Au moment de l'exécution, PenguinMessage sert de format de message universel reliant le modèle, l'environnement, les outils et l'utilisateur.
L'article source le compare à un paquet réseau : différents composants peuvent échanger des informations via la même interface légère, sans nécessiter d'intégrations uniques pour chaque modèle ou environnement.
Ainsi, PenguinHarness est à la fois :
- Un framework pour exécuter des agents
- Un agent capable de comprendre et d'étendre sa propre structure
PenguinHarness associe PenguinMessage, Penguin SDK et Penguin Skills dans une architecture légère.
Les trois domaines clés présentés dans l'architecture du projet sont :
| Composant | Rôle |
|---|---|
| PenguinMessage | Protocole de messages minimal entre l'utilisateur, le modèle, les outils et l'environnement |
| Penguin SDK | Couche de développement pour la construction d'applications d'agents |
| Penguin Skills | Capacités réutilisables pour construire, évaluer et améliorer les agents |
Boucle d'auto-évolution locale et reproductible
Construire un agent n'est que la première étape.
L'objectif à long terme de PenguinHarness est de permettre aux utilisateurs de manipuler des agents qui peuvent être évalués et optimisés localement, sans avoir à reconstruire manuellement l'ensemble du système.
Le projet distingue deux phases :
- Construire l'agent : de zéro à un
- Optimiser l'agent : de un à cent
Modifier un agent est relativement facile, car les invites, le code, les compétences et la configuration peuvent être édités. Mais déterminer si une modification rend réellement l'agent meilleur est beaucoup plus difficile.
Les modèles de langage sont probabilistes, et les systèmes d'agents introduisent davantage d'incertitude via les outils, l'environnement, la mémoire et les décisions multi-étapes.
Par conséquent, une boucle d'amélioration fiable nécessite un système de mesure fiable.
Pourquoi l'évaluation est fondamentale
Un agent peut être meilleur sur un exemple unique, mais globalement moins bon.
Sans benchmark structuré, l'optimiseur risque de :
- Surapprendre sur quelques échantillons de démonstration
- Mémoriser les réponses
- Exploiter les faiblesses de l'évaluateur
- Augmenter les coûts sans améliorer la qualité
- Améliorer une tâche au détriment d'une autre
- Obtenir des scores plus élevés par des techniques de contournement des récompenses
L'équipe PrismShadow a passé plus de six mois à explorer comment évaluer des agents auto-évolutifs.
Le défi central réside dans l'absence de benchmarks capables de distinguer clairement l'expérience d'entraînement des tests de validation réservés.
Si un agent s'améliore sur les mêmes problèmes utilisés pour l'évaluation, il est difficile de savoir s'il a appris une stratégie réutilisable ou s'il a simplement mémorisé les réponses.
GDPevo distingue les tâches d'entraînement des tâches de test
L'équipe a créé GDPevo, un benchmark natif d'évolution basé sur des processus métier réels.
L'article source décrit sa couverture dans des domaines tels que la santé, la finance et le travail juridique. Le dépôt de code V2 actuellement public contient 240 tâches réparties dans 24 groupes de tâches, couvrant des domaines tels que :
- CRM
- ERP
- Finance
- Santé
- Flux de travail juridiques
- Analyse de données
- Ingénierie et exploitation
Chaque groupe de tâches comprend :
- Un environnement métier partagé
- Cinq tâches d'entraînement
- Cinq tâches de test réservées
GDPevo utilise une méthode appelée mélange de règles. Les processus métier sont décomposés en règles plus petites, réparties entre les tâches d'entraînement, puis recombinées dans les tâches de test réservées.
Cette structure aide à déterminer si un agent a appris des flux de travail réutilisables, plutôt que d'avoir simplement vu les réponses de test à l'avance.
GDPevo évalue dans quelle mesure les agents s'améliorent sur des tâches métier réservées après différentes formes d'évolution.
Rapport de l'article GDPevo
L'auto-évolution dans ses expériences a amélioré la précision réservée de jusqu'à 16,44 points de pourcentage. Il indique également que le meilleur agent évolué reste encore bien en dessous de la limite idéale de 91,6 % avec information complète.
Cet écart est crucial. Les agents actuels peuvent s'améliorer, mais une auto-évolution fiable est loin d'être résolue.
PenguinHarness empaquette l'évaluation comme compétence
PenguinHarness transforme les idées centrales derrière GDPevo en compétences réutilisables pour :
- La création d'agents
- La conception de benchmarks
- L'évaluation d'agents
- L'optimisation d'agents
Après avoir invoqué les compétences associées, plusieurs agents peuvent collaborer au processus d'amélioration.
L'article source donne l'exemple d'un agent conçu pour des tâches telles que les prédictions sportives, la génération de stratégies d'investissement ou le support e-commerce.
L'utilisateur n'a pas besoin de modifier manuellement les invites et les flux de travail : il suffit de laisser PenguinHarness créer les ensembles d'évaluation, exécuter des tests répétés, analyser les causes d'échec et proposer de meilleures versions.
Le rapport de démonstration du projet montre qu'après plusieurs itérations, le score est passé de 53 à 95, avec un coût en jetons d'environ 0,5 yuan en utilisant le modèle DeepSeek V4 Flash.
Il s'agit d'un résultat de démonstration de l'équipe du projet, et non d'une garantie de benchmark universel. Les résultats réels peuvent varier selon la tâche, les critères de notation, le modèle, la taille de l'échantillon et le budget d'optimisation.
Processus d'optimisation en quatre étapes
Le flux de travail d'auto-évolution utilise plusieurs agents aux rôles distincts.
1. Organisation de l'évaluation
L'agent optimiseur détermine le nombre de questions et de répétitions nécessaires, puis lance en parallèle plusieurs agents évaluateurs.
L'évaluation parallèle réduit le temps nécessaire pour tester plusieurs tâches ou répéter des exécutions.
2. Notation indépendante
Chaque agent évaluateur lance une copie indépendante de l'agent cible et lui demande de résoudre une tâche.
L'agent évaluateur a accès à la grille de notation, tandis que l'agent cible n'y a pas accès.
Cet isolement vise à empêcher l'agent cible d'optimiser directement par rapport aux instructions de notation cachées.
3. Analyse et amélioration
L'agent optimiseur collecte les résultats et examine les trajectoires d'exécution.
Il identifie les causes des pertes de points, puis modifie les parties approuvées de l'agent cible, par exemple :
- Les invites
- Les compétences
- La configuration
- Les fichiers de flux de travail
L'agent optimiseur génère une version candidate suivante.
4. Validation et itération
Les agents évaluateurs testent à nouveau la version candidate.
L'agent optimiseur ne l'accepte que si la version candidate obtient un score strictement supérieur. Si le score est égal ou inférieur, le cadre revient à la version précédente.
L'agent optimiseur coordonne les agents évaluateurs parallèles et n'accepte que les agents candidats au score supérieur.
Ce processus peut être résumé ainsi :
Agent cible vN
↓
Agents évaluateurs parallèles
↓
Scores, grilles de notation et trajectoires d'exécution
↓
Agent optimiseur
↓
Mise à jour des invites, compétences ou configuration
↓
Agent candidat vN+1
↓
Accepté uniquement si le score est strictement supérieur
Cette combinaison de grilles de notation cachées, de tests réservés, de versions instantanées et d'améliorations strictes de score est conçue pour rendre l'optimisation plus reproductible.
Contrat entre le cadre de test et l'agent auto-évolutif
L'auto-évolution soulève une question de sécurité évidente : qu'est-ce que l'agent est autorisé à modifier ?
PenguinHarness définit ces limites dans un fichier portable nommé CONTRACT.md.
Ce contrat stipule que les capacités peuvent être améliorées dans les zones approuvées, tandis que le noyau du cadre de test et ses limites de sécurité restent fixes.
CONTRACT.md définit les limites de l’évolution des agents, de l’audit, du contrôle de version et de l’isolation des identifiants.
L’article source met en avant quatre règles fondamentales.
1. L’évolution ne peut pas modifier le noyau du framework de test
Les zones modifiables se limitent à l’espace de travail, aux prompts, aux compétences et aux configurations approuvées.
L’agent ne peut pas réécrire le framework de test principal ni ses mécanismes de sécurité.
Cela réduit le risque que le processus d’optimisation affaiblisse les éléments suivants :
- Approbation des outils
- Contrôle des permissions
- Journaux d’audit
- Isolation des identifiants
- Restauration de versions
- Autres contrôles de sécurité au niveau système
2. Chaque optimisation nécessite un instantané
Avant chaque cycle d’optimisation, le framework stocke un instantané de version de l’état de l’agent.
Si l’agent candidat obtient de moins bons résultats ou provoque des effets indésirables, le système peut revenir à une version antérieure.
Un système auto-améliorant sans capacité de rollback peut accumuler des dommages. Le contrôle de version rend les améliorations réversibles.
3. L’agent cible ne peut pas voir les critères d’évaluation
L’agent cible reçoit les tâches, mais pas les critères d’évaluation cachés.
Seul l’évaluateur a accès aux critères de notation.
Cela vise à réduire les comportements de raccourci, la mémorisation des réponses et le piratage des récompenses.
Cela n’élimine pas complètement ces risques, mais crée une séparation plus nette entre la résolution des problèmes et le jugement des résultats.
4. Chaque optimisation doit être auditable
Les requêtes de modèle, les appels d’outils, l’utilisation des jetons, le temps, les échecs, les approbations et les changements d’optimisation sont consignés dans des fichiers de suivi.
L’utilisateur peut examiner ce qui a changé et pourquoi.
Le contrat de projet élargi comprend également :
- Approbation avant exécution des outils
- Enregistrement d’audit des décisions d’approbation
- Isolation des identifiants
- Découplage modèle-agent
- Traces d’exécution récupérables
- Chargement à la demande des fichiers pertinents
- Règles claires de gestion des erreurs
Le résultat est un framework dans lequel les agents peuvent évoluer, mais où le processus d’évolution reste visible et réversible.
Autres fonctionnalités utiles de PenguinHarness
PenguinHarness comprend plusieurs capacités en plus de la création et de l’optimisation automatisées d’agents.
Compétences intégrées pour l’entraînement de modèles
et le déploiement
Le projet intègre des compétences liées au développement d’applications d’IA, notamment :
penguin-sdkpenguin-cliagenthub-modelsvllmollamallamafactory
PenguinHarness comprend des compétences pour construire des agents et travailler avec des outils comme vLLM, Ollama et LlamaFactory.
Ces compétences permettent aux utilisateurs de décrire en langage naturel des tâches d’entraînement ou de déploiement, et l’agent prépare les fichiers ou commandes nécessaires.
Le référentiel officiel classe les compétences intégrées en quatre grandes catégories :
| Groupe de compétences | Exemples |
|---|---|
| Efficacité bureautique | Analyse de données et collecte de données web |
| Développement logiciel | Conception web et ingénierie logicielle |
| Développement d’applications d’IA | SDK Penguin, passerelle de modèles, vLLM, Ollama et LlamaFactory |
| Optimisation des agents | Création d’agents, conception de benchmarks, évaluation et optimisation |
Les utilisateurs et les agents peuvent également créer ou améliorer des compétences supplémentaires.
Passerelle de modèles unifiée
PenguinHarness intègre des préréglages de modèles et prend en charge des interfaces personnalisées compatibles avec OpenAI.
Le projet indique qu’à travers les fournisseurs et passerelles pris en charge, les utilisateurs peuvent accéder à plus de 1000 modèles en ligne et locaux.
La passerelle de modèles permet aux utilisateurs de configurer différents fournisseurs de modèles en ligne et locaux.
Le référentiel actuel répertorie les familles de modèles suivantes :
- DeepSeek
- Kimi
- GLM
- Hunyuan
- Qwen
- GPT
- Gemini
- Claude
La disponibilité des modèles et les noms des fournisseurs changent fréquemment ; la page « Modèles » de l’application et la documentation officielle actuelle doivent donc être considérées comme les sources d’informations les plus récentes.
Agent visuel pour modèles textuels
L’article source décrit un schéma de développement dans lequel un modèle principalement textuel comme DeepSeek sert d’agent principal, tandis qu’un modèle doté de capacités visuelles sert d’assistant visuel.
L’agent visuel peut examiner :
- Captures d’écran web
- Diapositives
- Mises en page d’interfaces
- Rendu de jeux
- Graphiques
- Erreurs visuelles
Le modèle principal peut ensuite corriger sa sortie en fonction des descriptions visuelles.
Un agent doté de capacités visuelles
peut examiner des captures d’écran, tandis que DeepSeek reste le modèle de travail principal.*
Cela s’avère utile lorsque le modèle principal excelle en codage ou en raisonnement mais ne traite pas nativement les images.
Cette technique ne confère pas directement de capacités visuelles au modèle principal. Elle crée un flux de travail multi-modèles dans lequel le modèle visuel convertit les captures d’écran en informations exploitables par l’agent principal.
Analyse de traces fine
PenguinHarness enregistre les appels de modèles, l’exécution des outils, les temps, l’utilisation des jetons, les approbations et les activités des sous-agents.
L’interface Trace présente la séquence d’exécution sous forme de chronologie.
En haut se trouve la zone de statistiques globales, qui liste clairement les valeurs numériques telles que les lots, les appels d'outils, les connexions, ainsi que les données clés comme les tokens d'entrée, les tokens de sortie, les coûts, les frais, la durée et les TPS unitaires. Le corps principal de l'interface affiche la chronologie d'exécution du « 1er tour », avec des blocs de temps distincts par catégorie : réflexion du modèle, appels d'outils, attente d'approbation et exécution des appels d'outils, correspondant à l'axe temporel des durées d'exécution. En bas sont également affichés les enregistrements détaillés des messages d'exécution, y compris les instructions utilisateur, les processus de réflexion du système et les détails des appels d'outils, présentant ainsi l'ensemble des détails chronologiques de l'exécution de l'agent. La vue Trace, en lien avec la description contextuelle, permet de visualiser les sous-agents parallèles, les appels de modèles, l'utilisation des outils, etc.](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/08/29548888-b6dd-4d98-a216-beef965d0417-f038b908-4c76-409a-af91-fe7f4f3c580a.png)
La vue Trace aide les utilisateurs à vérifier les sous-agents parallèles, les appels de modèles, l'utilisation des outils, la latence et les coûts en tokens.
Cela permet d'identifier :
- Les appels de modèles lents
- Les utilisations d'outils inutiles
- Les boucles de raisonnement coûteuses
- Les nouvelles tentatives échouées
- Les sous-agents qui bloquent le flux de travail
- Les délais d'approbation trop longs
- Les invites à forte densité de tokens
- Les opportunités d'exécution parallèle
Les données de trace sont également au cœur de l'auto-évolution, car l'optimiseur a besoin de preuves expliquant pourquoi la version précédente a perdu des points.
Modèle d'agent minimaliste vide
PenguinHarness peut également être utilisé comme un agent générique minimaliste, et pas seulement comme un constructeur d'automatisation.
Ce projet considère le Shell comme une interface générique de bas niveau et choisit délibérément de maintenir un ensemble d'outils par défaut réduit et épuré.
Il considère l'exécution des sous-agents comme une caractéristique de performance essentielle.
Le code source indique que l'invite système par défaut est d'environ 1 300 tokens, tandis que la valeur comparative de Claude Code dans le projet est d'environ 15 000 tokens.
Ce chiffre est rapporté par le projet lui-même et peut évoluer avec les évolutions de l'un ou l'autre produit.
Le principe de conception sous-jacent est stable : des invites plus courtes et un ensemble d'outils plus réduit permettent de réduire la consommation de tokens et de rendre les modèles ouverts plus faciles à utiliser.
Coûts et résultats de référence
Le projet a publié des résultats comparatifs sur une suite d'analyse de données complexes.
Le projet rapporte une précision supérieure dans sa comparaison sur l'analyse de données complexes, pour une fraction du coût des modèles.
Le tableau de données publié indique :
| Framework | Modèle | Précision | Consommation de tokens | Coût estimé |
|---|---|---|---|---|
| PenguinHarness | DeepSeek V4 Pro | 66,67 % | 18,04 M | $0,55 |
| Claude Code | Claude Opus 4.8 | 53,33 % | 22,20 M | $38,48 |
| OpenAI Codex | GPT-5.5 | 53,33 % | 13,72 M | $19,41 |
Le projet résume ainsi :
- 1/35 du coût rapporté de Codex
- Environ 1/70 du coût rapporté de Claude Code
Cette comparaison associe chaque chaîne d'outils aux modèles avec lesquels elle est généralement utilisée. Elle ne distingue pas la contribution de la chaîne d'outils de celle du modèle choisi et de la tarification du fournisseur.
Pour une évaluation interne équitable, les équipes doivent exécuter la même tâche avec les conditions suivantes :
- Utiliser le même modèle dans la mesure du possible
- La même tarification fournisseur
- La même stratégie de nouvelles tentatives
- Les mêmes accès aux outils
- Les mêmes limites de temps
- Les mêmes critères d'évaluation
- Plusieurs exécutions répétées
Les données publiques peuvent servir de référence pour le projet, mais ne doivent pas être interprétées comme un ratio de coût universel applicable à toutes les tâches.
Cas de déploiement en production rapportés
L'article source indique que l'équipe a utilisé PenguinHarness dans deux scénarios de production.
Révision de rapports médicaux
Un centre d'examens médicaux aurait utilisé PenguinHarness pour créer un agent de révision de rapports, dont les performances sont décrites comme comparables à celles d'experts médicaux.
Selon l'équipe du projet, un travail de révision qui prenait environ 30 minutes peut désormais être effectué en quelques dizaines de secondes.
Inspection en environnement manufacturier
Une entreprise manufacturière aurait déployé plusieurs agents basés sur PenguinHarness pour surveiller en continu les équipements de la chaîne de production et tenter de les restaurer automatiquement.
L'équipe rapporte :
- Une réduction de 65 % des temps d'arrêt
- Une augmentation de la production jusqu'à presque le double
Ces données proviennent d'études de cas fournies par le fournisseur. Le rapport d'origine ne fournit pas les noms des clients, la conception de l'étude, la taille des échantillons, les définitions de référence ou les audits indépendants.
Ces éléments doivent être considérés comme des exemples de cas d'utilisation rapportés, et non comme des résultats opérationnels garantis.
Installation et déploiement
PenguinHarness prend en charge Linux, macOS et Windows 10 ou versions ultérieures, avec prise en charge des architectures x64 et Arm64 lorsque disponible.
Le script d'installation en une ligne inclut son propre runtime Node.js. L'installation via npm nécessite Node.js 24 ou version ultérieure.
Linux ou macOS
curl -fsSL https://penguin.ooo/install.sh | sh
penguin web
L'interface Web est accessible à l'adresse :
http://127.0.0.1:7364
Windows PowerShell
irm https://penguin.ooo/install.ps1 | iex
penguin web
npm
npm install -g @prismshadow/penguin-cli
penguin web
Lors de l'installation CLI, la première connexion Web utilise le nom d'utilisateur admin. Le mot de passe initial est affiché au premier démarrage du serveur et doit être modifié immédiatement.
Configurer le modèle et exécuter des tâches
Le dépôt officiel fournit un exemple CLI de ce type :
penguin config model add \
--provider deepseek \
--model-id deepseek-v4-flash \
--api-key sk-... \
--set-default
Exécuter une tâche ponctuelle :
penguin run -m "Créer hello.txt contenant Hello, Penguin"
Démarrer une session interactive :
penguin chat
Démarrer un serveur sans interface :
penguin server
Les clés API ne doivent jamais être soumises à un système de gestion de code source, ni être collées dans des journaux publics.
PenguinHarness peut être exécuté sur une machine locale ou un serveur. Son interface navigateur prend en charge plusieurs sessions, la gestion des agents et des compétences, la configuration des modèles, les statistiques d'utilisation, l'observabilité des traces et les flux d'évaluation.
Le projet indique actuellement que certaines
Les builds de bureau ne sont pas signées et peuvent déclencher un avertissement du système d'exploitation au premier démarrage. Les utilisateurs doivent télécharger uniquement depuis le site officiel ou le dépôt
Téléchargez le programme d'installation depuis les versions GitHub et vérifiez la description du projet avant de contourner tout avertissement.
L'équipe derrière PenguinHarness
PenguinHarness est un projet open source créé par PrismShadow, une équipe fondée en 2025 dont l'objectif est de construire une infrastructure d'agents capable d'apprendre des connaissances métier, des flux de travail et des retours d'expérience.
L'équipe fondatrice initiale, telle que listée dans le rapport d'origine, est la suivante :
| Membre de l'équipe | Parcours |
|---|---|
| Zheng Yaowei | Créateur de LlamaFactory ; spécialisé dans les modèles accessibles et l'infrastructure d'agents |
| Qian Buyue | Doctorat de l'Université de Californie à Davis ; ancien chercheur chez IBM T. J. Watson, ancien professeur à l'Université de Fudan |
| Wu Xuejun | Ancien membre fondateur du NLP chez Baidu ; a occupé des postes de direction chez Alibaba et JD Digits |
| Hu Junhao | Doctorant à l'Université de Pékin ; participe à des recherches sur les modèles et l'efficacité du cache |
| Chen Xi | Professeur à la Stern School of Business de l'Université de New York ; doctorat de l'Université Carnegie Mellon, ancien scientifique principal chez Amazon |
Les biographies fournies dans la source sont communiquées par l'éditeur et l'équipe du projet. Lorsque ces informations ont un impact substantiel sur l'emploi ou la validation académique, les lecteurs sont invités à les vérifier auprès des pages officielles des institutions.
De LlamaFactory à PenguinHarness, l'objectif déclaré de l'équipe reste inchangé : transformer une infrastructure d'IA complexe en outils plus accessibles, plus fiables et plus efficaces pour un plus grand nombre d'utilisateurs.
Questions fréquentes
Qu'est-ce que PenguinHarness ?
PenguinHarness est un framework d'agents open source qui permet de construire, exécuter, évaluer et optimiser des agents d'IA. Il offre une interface Web, une CLI, un SDK, des compétences intégrées, la configuration des modèles, le traçage ainsi que des flux de travail d'évaluation multi-agents.
PenguinHarness est-il gratuit et open source ?
Oui. Le code source principal est publié sous licence Apache 2.0. Les utilisateurs restent responsables des coûts liés aux API de modèles, à l'infrastructure ou aux services tiers générés par leurs charges de travail.
PenguinHarness peut-il fonctionner en local ?
Oui. Il fonctionne sous Linux, macOS et Windows, en tant qu'application de bureau ou via une interface CLI et navigateur. Il peut également être installé sur un serveur pour un accès à distance.
PenguinHarness prend-il en charge les modèles locaux ?
Oui. Il inclut des compétences et des intégrations liées à des outils tels qu'Ollama et vLLM, et prend en charge des points de terminaison personnalisés compatibles OpenAI. La compatibilité réelle dépend du comportement API du modèle et des capacités requises.
Que signifie l'auto-évolution dans PenguinHarness ?
L'auto-évolution signifie que le système évalue les agents, analyse les scores et les traces, modifie les prompts, les compétences ou les configurations approuvés, puis teste le candidat de la version suivante. Le candidat n'est accepté que s'il obtient de meilleures performances lors de l'évaluation configurée.
Un agent auto-évolutif peut-il modifier le noyau de PenguinHarness ?
Le contrat du projet stipule que non. L'évolution se limite à l'espace de travail, aux prompts, aux compétences et aux configurations approuvées, tandis que le noyau du framework et les mécanismes de sécurité restent inchangés.
Le coût de construction d'un agent à ¥0,2 est-il garanti ?
Non. Le chiffre de ¥0,2 provient d'une démonstration du projet qui a généré une application RAG avec DeepSeek V4 Pro. Le coût réel dépend de la tarification du modèle, de l'utilisation de jetons, du nombre de tentatives, du fournisseur et de la complexité de la tâche.
Qu'est-ce que GDPevo ?
GDPevo est un benchmark ouvert qui mesure la capacité d'auto-évolution des agents sur des tâches commerciales réelles mises de côté. Sa version publique V2 comprend 240 tâches réparties en 24 groupes et distingue les tâches d'entraînement des tâches de test.
Outils associés
- PenguinHarness : site officiel proposant téléchargements, documentation, exemples de produits et instructions d'installation.
- Dépôt GitHub PenguinHarness : code source Apache 2.0, README, versions publiées, exemples de commandes et guide de contribution.
- GDPevo : données du benchmark, processus de construction, espaces de travail d'évaluation et résultats expérimentaux publiés.
- LlamaFactory : framework open source de Yaowei Zheng pour le fine-tuning efficace de modèles de langage et de modèles vision-langage.
- vLLM : moteur open source pour l'inférence de modèles à haut débit, en local et côté serveur.
- Ollama : environnement d'exécution de modèles locaux utilisable dans les flux de développement d'agents.
- OpenRouter : passerelle API unifiée pour accéder à plusieurs fournisseurs de modèles hébergés.
Liens connexes
- Présentation de PenguinHarness : article de lancement officiel de l'équipe du projet, expliquant le concept « les agents construisent des agents ».
- Documentation PenguinHarness : documentation officielle d'installation, des modèles, des compétences et de l'utilisation.
- Dépôt GitHub PenguinHarness : code source, liste des modèles actuellement pris en charge, commandes et licence Apache 2.0.
- Versions de PenguinHarness : packages d'installation officiels pour poste de travail et ligne de commande sur les plateformes prises en charge.
- Article de recherche GDPevo : article décrivant la conception du benchmark, le mélange de règles et les résultats d'évaluation.
- Dépôt GitHub GDPevo : benchmark officiel, données de tâches, résultats d'évaluation et espaces de travail reproductibles.
- Dépôt GitHub LlamaFactory : dépôt officiel du framework de fine-tuning mentionné dans l'article.
Résumé
PenguinHarness est une plateforme open source qui permet aux agents de construire une autre application d'agent à partir d'un besoin exprimé en langage naturel. Elle peut générer du code de base, des prompts, des compétences, des configurations, du code, des interfaces frontales et des instructions d'exécution, tout en prenant en charge les modèles hébergés et locaux.
Son axe stratégique à long terme est l'auto-évolution. Plusieurs agents d'évaluation notent l'agent cible, l'optimiseur analyse les résultats et les traces d'exécution, et un candidat n'est accepté que s'il obtient des scores supérieurs. Le fichier CONTRACT.md limite ce qui peut être modifié et impose des instantanés, des rollbacks, des critères de notation masqués, des approbations, l'isolation des identifiants et des journaux d'audit.
Le projet rapporte des réductions de coûts significatives et des gains de productivité précoces, mais ces chiffres proviennent de démonstrations et d'études de cas fournies par l'équipe, et ne constituent pas des conclusions généralisables.
Garantie. Le dépôt Apache 2.0, les commandes publiées et le benchmark GDPevo offrent aux développeurs suffisamment de matière pour tester cette approche sur leurs propres charges de travail.
L'idée centrale de PenguinHarness est simple : la construction d'agents doit pouvoir être automatisée, mais son amélioration en toute sécurité exige une évaluation mesurable, des limites strictes et des changements réversibles.