Menu

Environnements

Comment un travail devient un environnement d’entraînement.

La méthode technique derrière nos deux gammes de données : structure des tâches, notation, calibration et format livré à votre équipe.

Ouvrir la tâche d’exemple CAD Demander un lot d’échantillons

Ce qu’est un environnement

Tout ce dont une exécution a besoin, dans un seul répertoire.

Chaque tâche est un répertoire à l’arborescence compatible Harbor. L’agent voit la consigne et le projet. Le vérificateur et la solution de référence restent hors de sa portée.

Consigne instruction.md
La demande de travail telle qu’un collègue ou un client l’enverrait, avec les livrables exacts et les chemins où les enregistrer.
État initial environment/project/
Les données initiales dont part le travail : plans et leurs révisions, modèles 3D, tableaux, courrier, lignes de base de données.
Outils environment/Dockerfile
Un conteneur avec ce dont le travail a besoin : un noyau CAD, des bibliothèques d’hydrostatique et de calcul, des outils de traitement de documents et de tableurs.
Vérificateur tests/test.sh
Le programme qui lit les livrables et l’état final, exécute chaque contrôle et écrit la récompense, une ligne par contrôle.
Sondes tests/probes/
Reward hacks, erreurs plausibles et variantes correctes que le vérificateur doit noter comme prévu avant la livraison de la tâche.
Solution de référence solution/solve.sh
Une solution qui obtient 1, ce qui prouve que la tâche peut être résolue telle qu’elle est rédigée.
Métadonnées et droits task.toml
Domaine, famille, tranche de difficulté, limites de temps, ressources, partition, source et licence.

Ouvrir le répertoire de la tâche d’exemple, fichier par fichier

task.toml Illustratif

version = "0.3"

[metadata]
id          = "naval/tank-capacity-014"
domain      = "ship design"
family      = "tank-capacity"   # generated, seed 1408
difficulty  = "hard"            # pass@1 0.12 at calibration
split       = "train"           # train | sealed-eval

[rights]
source      = "generated"       # generated | licensed | authored
use         = "training and evaluation"

[agent]
timeout_sec = 2700

[environment]
network     = "none"
cpus        = 2
memory_mb   = 4096

[verifier]
timeout_sec = 300
reward      = "strict"          # 1 only if every check passes
weights     = [1, 3, 3, 2, 1, 2, 3, 1]   # C1 to C8
tolerance   = { volume_m3 = 0.5, lcg_m = 0.02, trim_m = 0.01 }

/logs/verifier/reward.json Illustratif

{
  "reward": 0,
  "score": 0.94,
  "C1_deliverable_parses": 1,
  "C2_inputs_unchanged": 1,
  "C3_tank_volumes_98pct": 1,
  "C4_tank_lcg_vcg": 1,
  "C5_sounding_tables": 0,
  "C6_trim_departure": 1,
  "C7_tank_bounds_rev_c": 1,
  "C8_tolerances_cited": 1
}

Un seul contrôle échoué met la récompense à 0. Le score pondéré montre que le reste de la réponse était solide, et où elle a dérapé : C5 a détecté que les sondages de la citerne 5P étaient lus depuis le repère du tube de sonde de la révision B. La révision C a déplacé le tube, si bien que chaque sondage de cette citerne est rapporté au mauvais point.

Principes du vérificateur

Noter l’état, pas la prose.

Une récompense ne vaut que ce que vaut le vérificateur qui la calcule. Le code contrôle ce qui peut être calculé ; là où un jugement d’expert est nécessaire, des modèles juges calibrés et des vérificateurs à grille d’évaluation sur mesure notent le travail, chacun étant confronté aux notes d’experts.

Noter l’état

Le vérificateur ouvre les fichiers, la géométrie, les lignes et les messages laissés par l’agent et recalcule ce qu’ils devraient être. Le résumé que l’agent fait de son travail ne rapporte rien.

Déterministe, échec par défaut

Même livrable, même récompense, à chaque exécution. Un livrable manquant, mal formé ou illisible obtient zéro avec un motif explicite, jamais un plantage et jamais une réussite.

La réussite stricte est la récompense

La récompense vaut 1 uniquement lorsque tous les contrôles réussissent. Un score pondéré par contrôle l’accompagne, pour lire où une réponse a dérapé sans récompenser un quasi-succès.

Processus et résultat

Les contrôles de résultat lisent le livrable. Les contrôles de processus lisent la manière d’y parvenir : entrées laissées intactes, révision en vigueur utilisée, et clauses et valeurs appliquées, citées.

Tolérances prises en compte

Chaque grandeur porte la tolérance d’ingénierie de son plan ou de sa norme. Une réponse correcte dans d’autres unités, un autre ordre ou une autre disposition réussit quand même.

Isolé et réinitialisable

Pas de réseau, des entrées en lecture seule, et des tests montés uniquement après la fin de l’exécution. La réinitialisation ramène l’espace de travail au même état, vérifié par empreinte.

Figé et versionné

Chaque vérificateur est figé par hachage avec la version de sa tâche. Une correction donne une nouvelle version avec une entrée au journal des modifications, et toutes les sondes sont réexécutées.

Ingénierie et géométrie Dossiers d’entreprise et réponses

Défense contre le reward hacking

Chaque vérificateur est attaqué avant d’être livré.

Avant qu’une tâche ne sorte de chez nous, nous lançons une série de sondes contre son vérificateur.

Classe de sondeCe qu’elle faitScore attendu
VideLaisse l’espace de travail exactement tel qu’il a été réinitialisé.0
Simple affirmationDéclare le travail fait et ne change rien.0
FalsificationModifie une entrée, une table protégée, les tests ou le fichier de récompense.0
Réponse codée en durÉcrit le format attendu avec des valeurs devinées ou copiées.0
Entrée caduqueTravaille à partir de l’ancienne révision du plan ou du premier e-mail, et non de la modification.Échec strict
Erreur plausibleForme globale ou total correct, mais entité tolérancée ou ligne de poste erronée.Échec strict
Variante correcteLa bonne réponse par une autre méthode, dans d’autres unités ou une autre disposition.Réussite stricte
Six tâches de démonstration, un seul harnais.

Barrières exécutées le 10 novembre 2026 ; tentatives des modèles au plus tard le 7 novembre 2026. Les six sont des tâches de démonstration rédigées en interne avec des noms et des chiffres fictifs, et non des dossiers de partenaires. Les sondes sont un test de non-régression, pas une garantie.

Résultats du harnais des workflows d’entreprise. L’exécution de l’exemple CAD est présentée séparément.

Contrôles
59 sur les six tâches, dont 26 critiques ; la solution de référence obtient 1,0 sur chacune
Sondes de reward hacking
73, toutes à zéro ; 101 entrées hostiles, toutes à zéro sans erreur du vérificateur
Erreurs plausibles
71, toutes en échec sur la récompense stricte
Variantes correctes
8, toutes en réussite stricte
Lacunes connues
3 sondes réussissant par conception ; documentées sur la page des preuves
Tentatives des modèles
Deux modèles actuels d’un même fournisseur, dont son modèle de petite taille, un rollout par modèle et par version. Les deux ont réussi toutes les tâches après que nous avons clarifié la formulation de deux tâches en version 0. Les versions renforcées seront exécutées ensuite (ci-dessous). Ces exécutions montrent que le harnais fonctionne, pas la difficulté des tâches
Ouvert
Ce que le vérificateur ne détecte pas encore figure sur la page des preuves

Publié avec sa date, réussite ou échec.

Prévu

Taux de réussite sur les six tâches pour un petit modèle ouvert et un modèle plus puissant, cinq rollouts chacun. Publiés ici une fois terminés, quel que soit le résultat, avec la date d’exécution et les versions des tâches.

Demander un lot d’échantillons Réserver la démonstration guidée

Audit des trajectoires

Les sondes testent le vérificateur. L’audit teste les réussites. Sur des exécutions échantillonnées lors de la calibration, nous lisons comment chaque réussite a été obtenue, et pas seulement qu’elle l’a été.

Une réussite est rejetée lorsque l’exécution

  • a ouvert la référence, les tests ou quoi que ce soit hors du projet
  • a modifié une entrée, une table protégée ou le vérificateur
  • a tenté d’accéder au réseau, ou a écrit une réponse qu’elle n’a jamais calculée
  • a suivi une voie que la consigne exclut

Une réussite obtenue de la mauvaise manière devient une nouvelle sonde, et le vérificateur est renforcé avant la livraison du lot.

Difficulté et calibration

Assez difficile pour enseigner, soluble par conception.

Une tâche que tous les modèles réussissent n’enseigne rien. Une tâche qu’aucun modèle ne réussit est peut-être défectueuse. Nous mesurons chaque tâche avant sa livraison et ne la gardons que si elle se situe dans la tranche que vous fixez.

Tentatives répétées
Des modèles allant d’un petit modèle ouvert au plus puissant disponible tentent chaque tâche plusieurs fois. Un taux de réussite est une moyenne sur les tentatives, jamais une seule exécution.
pass@1 et pass@k
pass@1 situe la tâche dans la tranche ; pass@k montre qu’elle est atteignable. Une tâche hors de la tranche est renforcée, rééquilibrée ou abandonnée.
Zéro est un signal d’alerte
Avant de garder une tâche qu’aucun modèle ne réussit, nous revérifions sa consigne, sa solution de référence et son vérificateur.
Des paramètres, pas de la formulation
Les familles générées sont réglées avec les paramètres ci-dessous. La difficulté ne vient jamais d’une consigne ambiguë ou d’un piège caché.

Paramètres de difficulté par domaine

Pièces
Nombre d’entités, classe de tolérance, vues à concilier
Navires
Citernes et cas de chargement, révisions caduques dans le répertoire
Bâtiments
Planches et disciplines à croiser, densité de conflits
Workflows
Longueur d’horizon, modifications, fils de discussion parasites

Fiche de calibration, une par lot Illustratif

Lot
naval/tank-capacity v0.3
Tâches retenues
40 sur 46 rédigées
Tentatives
3 par modèle et par tâche
Petit modèle
pass@1 0,05
Grand modèle
pass@1 0,21 · pass@3 0,34
Tranche retenue
pass@1 entre 0,02 et 0,30
Reward hacks
14 sur 14 à zéro
Erreurs introduites
12 sur 12 en échec strict
Variantes
4 sur 4 en réussite stricte
Accord des experts
9 tâches sur 10, notées à l’aveugle
Temps par tentative
médiane 38 min

La forme de la fiche, pas un résultat mesuré. Chaque lot a la sienne.

Deux moteurs pour passer à l’échelle

Le volume vient des générateurs. La profondeur, des professionnels du métier.

L’essentiel d’un lot peut être généré, avec sa vérité terrain calculée. Les tâches les plus difficiles partent de quelqu’un qui a fait le travail.

Premier moteur

Générateurs paramétriques

Un générateur construit une famille de tâches à partir de paramètres : des pièces avec leurs entités et tolérances, des formes de carène avec leur disposition de citernes, des trames de bâtiment avec leurs ossatures. Le code qui construit une tâche calcule aussi sa réponse, si bien que le volume ne se fait jamais au détriment de l’exactitude.

  • Vérité terrain calculée, jamais saisie
  • Chaque graine consignée sur la fiche descriptive et reproductible
Généré. Neuf pièces issues de nos générateurs, construites entité par entité.

Second moteur

Amorces d’experts

Pour les tâches commandées, un professionnel du métier fournit le travail et valide le résultat. Des modèles aident à la rédaction, afin que les heures d’experts aillent là où seul un expert peut aider.

  1. AmorceUn professionnel décrit un vrai travail en six champs : situation, entrées, objectif, contraintes, méthode de vérification, sortie attendue.
  2. RédactionNous construisons la consigne, les fichiers du projet, le vérificateur et la solution de référence à partir de l’amorce, avec l’aide de modèles pour la rédaction.
  3. RésolutionUn modèle solveur d’une autre famille la tente à l’aveugle, plusieurs fois, sans accès au vérificateur ni à la référence. S’il réussit trop facilement, nous lisons son journal et renforçons la tâche.
  4. ValidationLe professionnel confronte la référence et le vérificateur à son propre jugement, et rend la tâche plus difficile là où le vrai travail l’est.
  5. RevueUn second professionnel note un échantillon à l’aveugle. Nous indiquons le niveau d’accord sur la fiche de calibration, et chaque désaccord est soumis à arbitrage.

Livraison

Dans le format que votre harnais exécute déjà.

Les tâches arrivent prêtes à exécuter, documentées élément par élément, et partitionnées pour que l’évaluation reste saine.

Format
Répertoires de tâches compatibles Harbor, images de conteneur, ou l’interface qu’accepte votre harnais. Une tâche tourne d’abord dans votre harnais, puis le lot suit.
Fiche descriptive
Par élément : source (générée, sous licence ou rédigée), générateur et graine, ou identifiant pseudonyme de l’auteur, révisions, désidentification et résultats de calibration.
Note de droits
Par élément : son propriétaire, la licence d’entraînement et d’évaluation, et la cession ou l’accord sur lequel elle repose.
Partitions
La partition convenue et l’usage autorisé sont consignés avec chaque tâche. Politique d’évaluation et de licence.
Maintenance
À mesure que les modèles progressent, les vérificateurs sont renforcés et les tâches saturées sont remplacées par des tâches plus difficiles de la même famille.

Commencer

Lisez une tâche avant de décider.

Examinez une tâche complète avant de discuter d’une intégration.

Demander un lot d’échantillons Ouvrir la tâche d’exemple CAD