harness-engineering

Cette compétence doit être utilisée lors de la conception de harnais pour agents autonomes : boucles de recherche, échafaudages d'évaluation, surfaces verrouillées et modifiables, journaux durables, portes de nouveauté, élagage, rollback, préparation de PR et limites d'approbation humaine.

Qu'est-ce que harness-engineering ?

Le Harness Engineering consiste à concevoir le système de contrôle qui entoure un agent autonome : ce qu'il peut modifier, comment il reçoit des retours, où il écrit son état, comment les échecs sont gérés et qui peut approuver des actions irréversibles. Cette compétence est cruciale pour passer d'une session d'agent ponctuelle à une boucle autonome capable de fonctionner pendant des jours sans corrompre son objectif. Elle prend en charge la conception de boucles de recherche autonome, d'environnements avec des métriques verrouillées et des contenus modifiables, ainsi que la préparation de PR et l'évaluation de la sécurité des agents. Le fonctionnement s'appuie sur quatre classes de surface (verrouillée, modifiable, append-only, contrôlée par l'humain), des boucles de rétroaction serrées, une persistance d'état durable via des fichiers, une discipline de recherche avec élagage et vérification de nouveauté, et une gouvernance explicite séparant la préparation des PR de leur fusion.

Compatible avec✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/harness-engineering

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Harness Engineering

L'ingénierie des harnais conçoit le système de contrôle autour d'un agent : ce qu'il peut modifier, comment il reçoit des retours, où il écrit l'état, comment les échecs sont récupérés et qui peut approuver des actions irréversibles. Le harnais fait la différence entre une session d'agent utile et une boucle autonome qui peut fonctionner pendant des jours sans corrompre son objectif.

Quand activer

Activez cette compétence lorsque :

  • Vous créez des boucles autonomes de recherche ou d'expérimentation
  • Vous concevez un environnement d'agent avec des métriques verrouillées et du code ou contenu modifiable
  • Vous créez des agents producteurs de PR ou des agents d'arrière-plan
  • Vous évaluez si un agent peut fonctionner en toute sécurité sans invites humaines fréquentes
  • Vous ajoutez de la nouveauté, de l'ablation, de l'élagage, du rollback ou une journalisation durable à un flux de travail d'agent
  • Vous empêchez les agents de tricher sur les benchmarks, d'affaiblir les rubriques ou de perdre l'état lors de la compaction

N'activez pas cette compétence pour les travaux connexes gérés par d'autres compétences :

  • Portes de qualité générales, suites de régression ou mesures de résultats sans surfaces de contrôle autonomes : evaluation.
  • Schémas d'outils, formats de réponse et erreurs de récupération pour les outils de harnais : tool-design.
  • Adéquation modèle-tâche au niveau du projet, forme du pipeline et planification des coûts : project-development.
  • Infrastructure de bac à sable distant, de pool chaud et de session hébergée : hosted-agents.

Concepts clés

Limite du harnais

Séparez l'agent de l'environnement dans lequel il opère. L'agent propose des actions ; le harnais définit les surfaces autorisées, les retours, la persistance et les règles de promotion.

Utilisez quatre classes de surface :

SurfaceExemplesRègle
VerrouilléeMétrique d'évaluation, rubrique, script de validation, politique de fusionL'agent peut lire et proposer des modifications, mais ne peut pas s'évaluer lui-même avec des règles modifiées
ModifiableBrouillon de compétence, fichier d'expérience, invite, configuration en cours de testL'agent peut modifier pendant la boucle
Append-onlyJournal des résultats, fil de recherche, idées rejetéesL'agent peut ajouter, pas réécrire
Contrôle humainFusion, déploiement en production, identifiants, opérations destructricesNécessite une approbation humaine explicite

Boucles de rétroaction serrées

L'autonomie fonctionne lorsque les retours sont rapides, sans ambiguïté et difficiles à contourner. Le autoresearch de Karpathy est le modèle minimal : un fichier modifiable, un fichier d'évaluation verrouillé, un budget de temps fixe, une métrique scalaire, un rollback git et un journal des résultats durable. La leçon n'est pas que chaque harnais a besoin d'une métrique ; c'est que des retours ambigus créent une autonomie ambiguë.

Pour les travaux de recherche ouverts vers des compétences, remplacez la métrique scalaire par des rubriques verrouillées, des vérifications de structure déterministes, la traçabilité des sources et des seuils de révision humaine.

État durable

Les agents fonctionnant longtemps doivent externaliser leur état. Stockez les plans, les files d'attente de sources, les résultats, les échecs et les transferts dans des fichiers afin que les futurs agents puissent reprendre sans dépendre de l'historique de la conversation. Le travail autonome nanoGPT de Prime Intellect a montré la valeur des brouillons durables et des journaux de type THREAD.md pour la récupération, la surveillance et l'audit.

Utilisez des journaux append-only pour :

  • Ce qui a été essayé
  • Ce qui s'est amélioré ou a échoué
  • Pourquoi un candidat a été gardé, rejeté ou dirigé vers une révision
  • Quelles sources en amont ont été vérifiées
  • Ce que le prochain agent devrait faire

Discipline de recherche

Les agents ont tendance à exploiter la surface la plus proche, à empiler la complexité et à sous-utiliser l'élagage. Ajoutez des règles de recherche explicites :

  1. Actualisez les sources en amont selon un calendrier.
  2. Exigez des vérifications de nouveauté avant de dépenser de gros budgets.
  3. Conservez les tentatives rejetées pour éviter de les redécouvrir.
  4. Effectuez un élagage leave-one-out lorsqu'une pile comporte plusieurs ajouts.
  5. Récompensez la simplification lorsque la qualité est égale.
  6. Utilisez une vérification séparée avant la promotion.

Registre des mécanismes

Pour les systèmes de recherche vers compétence, suivez les mécanismes acceptés séparément de la prose. Un enregistrement de mécanisme doit inclure un mechanism_id stable, owning_skill, status, scénario d'activation, changement de comportement, preuve et modes de défaillance. Les portes de nouveauté doivent comparer avec ce registre avant d'utiliser un chevauchement de corpus plus large, car le chevauchement de mots-clés capture des formulations obsolètes tandis que la comparaison de mécanismes capture une duplication réelle.

Gouvernance

Les agents autonomes peuvent préparer des PR, mais la gouvernance doit être explicite. Ils peuvent rédiger des modifications, exécuter des vérifications et rédiger des résumés de PR. Ils ne doivent pas fusionner, déployer ou pousser sans approbation humaine, sauf si l'utilisateur a explicitement accordé cette autorisation pour l'action spécifique.

Sujets détaillés

Boucle de style Autoresearch

Utilisez ce modèle lors de l'optimisation d'un artefact par rapport à un évaluateur stable :

lire le contexte verrouillé -> choisir une hypothèse -> modifier la surface autorisée -> valider/checkpoint
-> exécuter l'évaluateur -> enregistrer le résultat -> garder si meilleur -> jeter ou rollback si pire
-> répéter

Propriétés requises :

  • L'évaluateur est en dehors de la surface modifiable.
  • La cadence de rétroaction est suffisamment fixe pour comparer les tentatives.
  • Les tentatives échouées laissent une piste d'audit.
  • Le rollback est peu coûteux.
  • L'agent a une politique pour les plantages et les dépassements de délai.

Boucle Recherche vers Compétence

Utilisez ce modèle lorsque les sources deviennent des modifications de compétence :

découvrir -> récupérer -> filtrer -> noter -> extraire le mécanisme
-> mapper à une compétence existante ou nouvelle -> rédiger une proposition -> valider la structure
-> préparer une PR -> révision humaine

L'évaluateur verrouillé est une combinaison de rubriques de source, de rubriques de modification de compétence, de vérifications de structure et d'approbation du relecteur. L'artefact modifiable est le delta proposé de la compétence.

Résistance à la triche métrique

Supposons qu'un agent optimisant apprendra le harnais. Protégez-vous contre :

  • La modification du code d'évaluation ou des rubriques, puis l'utilisation de la nouvelle version pour l'auto-approbation
  • L'ajout de contenu verbeux qui satisfait un juge mais nuit à l'activation de la compétence
  • La citation de sources non récupérées
  • L'optimisation des scores agrégés tout en échouant sur une dimension critique
  • L'omission des résultats échoués dans le journal

Atténuation : verrouillez les rubriques par exécution, rapportez les scores par dimension, exigez des preuves de récupération de source, conservez les tentatives rejetées et acheminez les modifications de gouvernance vers une révision humaine.

Agents de surveillance

Utilisez des agents de surveillance pour les longues exécutions, mais limitez-les à des rapports en lecture seule, sauf indication contraire explicite. La sortie de surveillance doit rapporter :

  • Le meilleur candidat actuel
  • Les travaux ou brouillons en cours
  • La dernière actualisation en amont
  • Les boucles échouées ou obsolètes
  • Les incohérences entre les journaux et l'état revendiqué
  • La prochaine action et le blocage

Guide pratique

Liste de contrôle de conception du harnais

  1. Définissez l'objectif en une phrase.
  2. Identifiez les surfaces verrouillées, modifiables, append-only et contrôlées par l'humain.
  3. Choisissez le mécanisme de rétroaction : métrique scalaire, rubrique, tests déterministes, révision humaine ou combinaison.
  4. Définissez les états de conservation, rejet, plantage, dépassement de délai et révision.
  5. Créez un journal de fil durable avant le démarrage de la boucle.
  6. Ajoutez des règles d'actualisation des sources, de nouveauté du registre de mécanismes et d'élagage pour les boucles longues.
  7. Définissez ce que l'agent peut faire sans demander et ce qui nécessite une approbation.
  8. Validez le harnais sur un artefact connu bon et un artefact connu mauvais.

Structure des fichiers

research-run/
  THREAD.md
  sources/
    queue.md
    evaluations/  
  proposals/
  logs/
    results.tsv
    rejected.md
  drafts/

Utilisez TSV ou JSONL pour les journaux append-only lisibles par machine. Utilisez Markdown pour les transferts et les résumés destinés aux relecteurs.

Exemples

Exemple 1 : Métrique verrouillée

Un agent optimise train.py, mais prepare.py possède le chargement des données et l'évaluation. L'agent peut modifier le modèle mais ne peut pas changer la métrique. Les expériences échouées sont journalisées et annulées.

Exemple 2 : Rubrique verrouillée

Un agent évalue un nouvel article technique d'Anthropic ou OpenAI, mais la rubrique de curation des sources est verrouillée pour l'exécution. Si la source réussit, l'agent rédige une proposition de compétence. Il ne peut pas abaisser le seuil de la rubrique pour admettre la source.

Exemple 3 : Auto-PR sans auto-fusion

Un agent prépare une branche et un corps de PR après avoir réussi les vérifications de source, de compétence et de structure. La PR indique les risques non résolus et attend l'approbation humaine pour la fusion.

Directives

  1. Verrouillez les évaluateurs avant de démarrer la boucle.
  2. Gardez les surfaces modifiables suffisamment étroites pour des diffs fiables.
  3. Écrivez des journaux durables avant que la compaction du contexte ne puisse effacer l'état.
  4. Rapportez les scores par dimension plutôt que uniquement les scores agrégés.
  5. Exigez la récupération de la source avant la citation.
  6. Ajoutez des portes de nouveauté pour les recherches larges et des portes d'élagage pour les piles complexes.
  7. Préférez la simplification lorsque la qualité est égale.
  8. Séparez la préparation des PR de l'autorité de fusion.
  9. Revalidez les modifications du harnais avec des évaluateurs anciens et nouveaux.
  10. Considérez les boucles autonomes arrêtées comme des échecs du harnais, pas comme des caprices de la personnalité de l'agent.

Pièges

  1. Évaluateur mutable : Si l'agent peut modifier la métrique, il peut optimiser le benchmark au lieu de la tâche. Gardez les rubriques et le code d'évaluation verrouillés pendant l'exécution.
  2. Mémoire uniquement par chat : Les longues exécutions échouent après compaction lorsque les plans ne vivent que dans l'historique de la conversation. Écrivez des journaux de fil et des fichiers de résultats dès le début.
  3. Aucun enregistrement des rejets : Sans journaux des tentatives rejetées, les agents répètent des idées échouées. Conservez les échecs avec suffisamment de détails pour éviter la redécouverte.
  4. Accumulation de complexité : Les agents empilent les modifications et les suppriment rarement. Exigez des cycles d'élagage et récompensez la simplification à qualité égale.
  5. Revendications prématurées de nouveauté : Les agents qualifient les recombinaisons de nouvelles. Comparez avec les compétences existantes du dépôt, la file d'attente des sources et les journaux rejetés avant de revendiquer la nouveauté.
  6. Rapports erronés du moniteur : Les agents de surveillance peuvent résumer un état obsolète ou incohérent. Exigez qu'ils citent les fichiers ou journaux derrière les affirmations.
  7. Ambiguïté de l'approbation humaine : "Préparer une PR" n'est pas "fusionner une PR". Rendez les limites d'approbation explicites dans le harnais.
  8. Dérive volatile des sources : Les affirmations des laboratoires à évolution rapide vieillissent vite. Mettez des preuves datées dans les références et planifiez une revalidation.

Intégration

Cette compétence se connecte à :

  • evaluation - Les rubriques et les portes de qualité fournissent la surface de rétroaction verrouillée
  • advanced-evaluation - La comparaison par paires et l'atténuation des biais améliorent la révision des propositions
  • filesystem-context - Les journaux durables, les brouillons et les fichiers de fil préservent l'état
  • multi-agent-patterns - Les agents chercheur, vérificateur, moniteur et rédacteur ont besoin de contextes isolés
  • tool-design - Les outils de harnais doivent exposer des contrats clairs et des erreurs de récupération
  • project-development - Les pipelines basés sur des fichiers et l'analyse de l'adéquation modèle-tâche maintiennent les boucles simples
  • hosted-agents - L'exécution en arrière-plan a besoin de bac à sable, d'instantané et de limites d'approbation

Références

Références internes :

  • researcher/README.md - À lire lors de l'implémentation du système d'exploitation natif du dépôt pour la recherche vers compétence
  • researcher/rubrics/harness-change.md - À lire lors de l'évaluation des modifications d'un harnais d'agent
  • researcher/runbooks/autonomous-research-loop.md - À lire lors de l'exécution d'une boucle source vers compétence

Ressources externes :

  • Karpathy autoresearch - Boucle d'expérimentation autonome contrainte avec évaluation verrouillée
  • Prime Intellect autonomous nanoGPT speedrun - Brouillons durables, transferts, surveillance et modes de défaillance d'autonomie
  • AlphaEvolve et FunSearch - Candidats générés par LLM associés à des évaluateurs systématiques
  • HELM et LM Evaluation Harness - Infrastructure d'évaluation transparente et reproductible

Métadonnées de la compétence

Créé : 2026-05-14 Dernière mise à jour : 2026-05-15 Auteur : Contributeurs Agent Skills for Context Engineering Version : 1.1.0

Individual skills in this repo

This repo contains 19 individual skills — each has its own dedicated page.

advanced-evaluation

This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.

bdi-mental-states

This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations, rational agency traces, cognitive agents, BDI ontologies, and neuro-symbolic AI integration.

book-sft-pipeline

This skill should be used for book-to-SFT pipelines: ePub extraction, literary segmentation, author-voice dataset construction, style-transfer training, LoRA workflows, and model evaluation for voice replication.

comprehensive-research-agent

Ensure thorough validation, error recovery, and transparent reasoning in research tasks with multiple tool calls

context-compression

This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.

context-degradation

This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.

context-fundamentals

This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.

context-optimization

This skill should be used for improving context efficiency: context budgeting, observation masking, prefix or KV-cache strategy, partitioning, token-cost reduction, retrieval scoping, and extending effective context capacity without lowering answer quality.

evaluation

This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.

filesystem-context

This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.

hosted-agents

This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.

latent-briefing

This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.

long-horizon-prompting

This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.

memory-systems

This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.

multi-agent-patterns

This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.

project-development

This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.

self-improvement-loops

This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.

self-managed-context

This skill should be used when a model gets read-write control over its own live context window instead of a harness-scheduled compaction policy: the context exposed as an editable file the model rewrites with code tools, model-driven eviction and in-place updates, the harness invariants that keep self-editing safe (pinned prefix, edit gate, edit receipts, budget readouts, rollback on overflow), the prefix-cache cost of mid-context edits, and steering or training the model's own context-editing strategy. Route note content and fixed-threshold summarization to context-compression, cache-stable layout under harness control to context-optimization, file offloading to filesystem-context, and loop governance to self-improvement-loops.

tool-design

This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.

Skills associés