Schéma des métadonnées de séquence

Chaque séquence porte deux types de métadonnées distincts :

Validité technique. L’enregistrement est-il exploitable ? Avala la rapporte à partir des critères d’acceptation et des objectifs de qualité. Consultez la section Validité technique.
Résultat comportemental. Qu’a fait la personne ou le robot, et la tâche a-t-elle réussi ? Avala le stocke comme étiquette de résultat de la séquence.

Une séquence peut être techniquement valide et montrer quand même une défaillance. Une séquence en échec est souvent la plus utile. Les deux axes restent séparés : un filtre sur les données propres ne supprime jamais une défaillance utile, et un filtre sur la réussite ne masque jamais un capteur défectueux.

L’étiquette de résultat

Chaque séquence a au plus une étiquette de résultat courante. Chaque écriture enregistre une nouvelle version. Les versions précédentes restent lisibles dans l’historique de l’étiquette.

Exemple

Voici l’étiquette d’une démonstration humaine avec un glissement et une récupération, telle que GET .../sequences/<sequence-uid>/outcome/ la renvoie :

{
  "uid": "<outcome-uid>",
  "sequence_uid": "<sequence-uid>",
  "version": 2,
  "is_current": true,
  "outcome": "mistake_and_recovery",
  "progress": 1.0,
  "quality": 4,
  "speed": 3,
  "subtasks": [
    { "label": "Load the plate into the lower rack", "start_ts": 0.0, "end_ts": 19.8, "outcome": "mistake_and_recovery" },
    { "label": "Pull out the lower rack", "start_ts": 0.0, "end_ts": 6.2, "outcome": "expert_success" },
    { "label": "Place the wet plate in a free slot", "start_ts": 6.2, "end_ts": 19.8, "outcome": "mistake_and_recovery" }
  ],
  "hand_actions": {
    "left": [
      { "start_ts": 0.0, "end_ts": 6.2, "action": "pulling the lower rack out by its front edge", "object": "dishwasher rack", "verb": "pull", "contact": true },
      { "start_ts": 6.2, "end_ts": 19.8, "action": "holding the rack steady", "object": "dishwasher rack", "verb": "hold", "contact": true }
    ],
    "right": [
      { "start_ts": 6.2, "end_ts": 9.1, "action": "carrying the wet plate to the rack", "object": "plate", "verb": "carry", "contact": true },
      { "start_ts": 9.1, "end_ts": 10.4, "action": "the plate slips out of the grasp", "object": "plate", "verb": null, "contact": false },
      { "start_ts": 10.4, "end_ts": 14.7, "action": "regrasping the plate by its rim", "object": "plate", "verb": "grasp", "contact": true },
      { "start_ts": 14.7, "end_ts": 19.8, "action": "placing the plate in a free slot", "object": "plate", "verb": "place", "contact": true }
    ]
  },
  "mistake_type": "slip_during_place",
  "recovery_type": "regrasp",
  "failure_stage": "place",
  "autonomy_level": "human_demonstration",
  "model_version": "",
  "evaluation_membership": "train",
  "leakage_groups": {
    "location": "loc_8f2a",
    "object": "obj_set_31",
    "mechanism": "dishwasher_pull_rack_v2",
    "operator": "op_5c1e",
    "environment_family": "kitchen_galley"
  },
  "source": "human",
  "source_metadata": {},
  "labeled_by": "<user-uid>",
  "confidence": null,
  "created_at": "2026-09-30T17:42:11.204000Z",
  "updated_at": "2026-09-30T17:42:11.204000Z"
}

Les valeurs illustrent la forme de l’étiquette. Elles ne décrivent pas une livraison réelle.

Champs

Tous les horodatages sont exprimés en secondes depuis le début de la séquence.

Champ	Type	Signification
`uid`	chaîne	Identifiant de cette version de l’étiquette. Lecture seule.
`sequence_uid`	chaîne	La séquence à laquelle appartient l’étiquette. Lecture seule.
`version`	entier	Version de l’étiquette, à partir de 1. Chaque écriture l’augmente de un. Lecture seule.
`is_current`	booléen	`true` pour la version courante. Lecture seule.
`outcome`	chaîne	Le résultat comportemental. Obligatoire. Consultez la section Valeurs de résultat.
`progress`	nombre ou null	Progression de la tâche, de 0 à 1.
`quality`	entier ou null	Qualité d’exécution, de 1 à 5.
`speed`	entier ou null	Vitesse d’exécution, de 1 à 5.
`subtasks`	liste	Plages temporelles étiquetées. Consultez la section Sous-tâches.
`hand_actions`	objet	Flux d’actions par main, `left` et `right`. Consultez la section Actions des mains.
`mistake_type`	chaîne	Votre libellé pour le type d’erreur. Jusqu’à 128 caractères. Vide lorsqu’il n’est pas défini.
`recovery_type`	chaîne	Votre libellé pour le type de récupération. Jusqu’à 128 caractères. Vide lorsqu’il n’est pas défini.
`failure_stage`	chaîne	Votre libellé pour l’étape où la défaillance s’est produite. Jusqu’à 128 caractères. Vide lorsqu’il n’est pas défini.
`autonomy_level`	chaîne	Qui avait le contrôle. Consultez la section Niveau d’autonomie. Vide lorsqu’il n’est pas défini.
`model_version`	chaîne	La version de la politique ou du modèle qui a piloté le robot. Jusqu’à 255 caractères. Vide pour les démonstrations humaines.
`evaluation_membership`	chaîne	`train`, `held_out_eval` ou `none`. Vide lorsqu’il n’est pas défini. Consultez la section Appartenance à l’évaluation.
`leakage_groups`	objet	Identifiants de groupe pour garder des séparations propres. Consultez la section Groupes de fuite.
`source`	chaîne	Qui a écrit l’étiquette : `human`, `model` ou `imported`. Par défaut : `human`.
`source_metadata`	objet	Provenance de l’import. Consultez la section Métadonnées de source.
`labeled_by`	chaîne ou null	UID de l’utilisateur qui a écrit la version. Renvoyé uniquement aux appelants qui peuvent modifier le jeu de données. Lecture seule.
`confidence`	nombre ou null	Confiance du modèle, de 0 à 1. Acceptée uniquement lorsque `source` vaut `model`.
`created_at`, `updated_at`	chaîne	Horodatages de la version. Lecture seule.

mistake_type, recovery_type et failure_stage sont du texte libre. Utilisez les libellés de la taxonomie des défaillances de votre programme pour que les séquences se regroupent proprement.

Valeurs de résultat

Résultat	Signification
`expert_success`	La tâche est terminée. L’exécution est fluide et à un rythme d’expert.
`slow_success`	La tâche est terminée. L’exécution est correcte et nettement plus lente que le rythme d’expert.
`partial_success`	Une partie de la tâche est terminée. L’état final visé n’est pas atteint.
`mistake_and_recovery`	Une erreur survient, comme un glissement, un raté ou un mauvais placement. La personne ou le robot se rattrape sans aide extérieure et termine la tâche.
`intervention`	Un humain intervient pour corriger ou terminer la tâche.
`unsafe`	La séquence contient une action ou un état dangereux.
`aborted`	La tentative s’arrête avant la fin de la tâche, sans récupération.
`failure`	La tentative se termine sans que la tâche soit accomplie.
`novel_strategy`	La tâche est résolue de manière valide, différente de la stratégie habituelle.
`inefficient_strategy`	La tâche est résolue avec des mouvements superflus évitables, des tentatives répétées ou des détours.

Chaque sous-tâche peut porter son propre résultat, tiré de la même liste.

Niveau d’autonomie

Valeur	Signification
`human_demonstration`	Une personne réalise la tâche.
`teleoperation`	Une personne pilote le robot à distance.
`autonomous`	Le robot fonctionne avec sa politique.
`shared_autonomy`	La politique et une personne se partagent le contrôle.
`intervention`	Une personne prend le relais de la politique pendant la séquence.

Sous-tâches

Chaque sous-tâche a la forme {label, start_ts, end_ts, outcome}.

Champ	Règle
`label`	Description de la sous-tâche en langage naturel. Obligatoire. De 1 à 500 caractères.
`start_ts`, `end_ts`	Nombres finis, supérieurs ou égaux à 0. `end_ts` est au moins égal à `start_ts`.
`outcome`	Une valeur de résultat, ou `null`.

Une étiquette contient au plus 256 sous-tâches. La liste doit être triée par start_ts. Deux sous-tâches sont soit disjointes, soit l’une contient entièrement l’autre, comme une phase et ses étapes. Des extrémités qui se touchent comptent comme disjointes. Un chevauchement partiel est rejeté. Lorsque deux sous-tâches commencent au même instant, placez d’abord celle qui englobe l’autre.

Actions des mains

hand_actions contient deux flux indépendants, left et right. Chaque élément décrit ce que fait une main sur une plage temporelle.

Champ	Règle
`start_ts`, `end_ts`	Nombres finis, supérieurs ou égaux à 0. `end_ts` est au moins égal à `start_ts`.
`action`	Description de l’action en langage naturel. Obligatoire. De 1 à 500 caractères.
`object`	L’objet sur lequel la main agit. Facultatif. Jusqu’à 255 caractères.
`verb`	Un verbe court pour l’action. Facultatif. Jusqu’à 64 caractères.
`contact`	`true` lorsque la main touche l’objet, `false` lorsqu’elle ne le touche pas, `null` lorsque c’est inconnu. Seuls les booléens JSON sont acceptés.

Pour une même main, les éléments sont triés par start_ts et ne doivent pas se chevaucher. Un élément commence à la fin du précédent ou après. Ils peuvent se toucher.
Les deux mains peuvent se chevaucher librement.
Chaque main contient au plus 3 600 éléments. Cela représente une heure à raison d’une étiquette par seconde.
left et right sont les seules clés. Vous pouvez omettre l’une ou l’autre. Une main omise est stockée comme une liste vide.
Un object ou un verb vide est stocké comme null. Chaque élément stocké possède les six champs.

Durée de la séquence

Lorsqu’Avala connaît la durée de la séquence, chaque end_ts de sous-tâche et chaque end_ts d’action de main doit être au plus égal à la durée plus 1 seconde. Cette seconde supplémentaire tient compte des étiquettes écrites à raison d’une par seconde. Avala connaît la durée lorsque la séquence a exactement un fichier MCAP extrait dont la durée est enregistrée. Pour les autres séquences, la vérification n’a pas lieu.

Appartenance à l’évaluation

evaluation_membership place la séquence dans une partition :

Valeur	Signification
`train`	La séquence peut servir à l’entraînement.
`held_out_eval`	La séquence appartient à un ensemble d’évaluation mis de côté. Tenez-la à l’écart de l’entraînement.
`none`	La séquence n’appartient à aucune des deux partitions.

Avala définit held_out_eval sur les séquences de chaque cohorte d’évaluation. Ces séquences n’apparaissent jamais dans une release d’entraînement. Consultez Évaluation.

Groupes de fuite

Les groupes de fuite empêchent des quasi-doublons de se retrouver des deux côtés d’une séparation entre entraînement et évaluation. leakage_groups accepte ces clés, chacune avec un identifiant de groupe de 255 caractères au plus :

Clé	Regroupe les séquences qui partagent
`location`	Le même logement, le même site ou la même pièce.
`object`	Le même ensemble d’objets physiques.
`mechanism`	Le même appareil ou la même unité de mécanisme.
`operator`	Le même collecteur ou téléopérateur.
`environment_family`	Le même type d’environnement et d’agencement, comme une cuisine en couloir.

Toute autre clé est rejetée. Chaque clé est facultative. Avala construit les cohortes d’évaluation de sorte qu’aucune valeur de groupe d’une cohorte n’apparaisse dans une release d’entraînement. Vous pouvez séparer vos propres données de la même façon : mettez de côté par groupe, jamais par séquence aléatoire. Les identifiants de groupe d’Avala sont pseudonymes : vous pouvez regrouper et séparer les séquences sans savoir qui ni où.

Métadonnées de source

source_metadata indique d’où vient une étiquette importée, par exemple {"importer": "...", "run_id": "...", "task": "...", "log_path": "..."}.

C’est un objet plat d’au plus 20 clés.
Chaque clé compte de 1 à 64 caractères.
Chaque valeur est une chaîne de 512 caractères au plus, un nombre fini ou un booléen.
Les objets imbriqués, les listes et les valeurs null sont rejetés.

Fonctionnement des écritures

Une écriture remplace l’étiquette courante dans son ensemble et enregistre une nouvelle version. Tout champ facultatif que vous omettez est stocké comme non défini. Il n’est pas repris de la version précédente.
L’écriture nécessite un accès en modification au jeu de données. La lecture nécessite le même accès que la lecture de la séquence, y compris pour les jeux de données publics.
confidence est rejeté sauf si source vaut model.
La lecture d’une séquence sans étiquette renvoie 404.

Validité technique

La validité technique ne fait pas partie de l’étiquette de résultat. Avala la rapporte à partir du moteur d’acceptation et des objectifs de qualité. Elle n’a pas de schéma JSON propre. Critères d’acceptation. Chaque capture d’une campagne de capture reçoit un verdict automatique : accept, quarantine ou reject. Le verdict découle de ces critères :

Critère	Ce qu’il vérifie
`capture_health`	Le fichier MCAP est valide et les canaux exigés par la campagne sont présents.
`frame_rate`	La fréquence d’images de la caméra se maintient sur tout le clip, sans effondrement prolongé.
`completeness`	La durée est proche de celle demandée par la campagne.
`framing`	Les mains sont visibles pendant une part suffisante du temps observé par le détecteur.
`shake`	La caméra ne tremble pas pendant la majeure partie du clip.

Chaque critère rapporte pass, fail, insufficient_evidence ou skipped. Un critère en échec enregistre un code de motif, comme acceptance_frame_rate_drop ou hands_not_visible. Un réviseur confirme ensuite le verdict ou le remplace. Les codes de motif sont listés dans Heure acceptée. Lisez l’acceptation avec les outils MCP get_result_acceptance pour une capture et get_campaign_acceptance_summary pour une campagne. list_capture_submissions inclut la synthèse d’acceptation automatique de chaque capture. Objectifs de qualité. Un projet peut fixer des seuils sur des métriques de qualité, comme le taux d’acceptation, le taux de rejet et le taux de problèmes. Avala émet une alerte lorsqu’une métrique franchit son seuil. Lisez-les avec l’outil MCP list_quality_targets. Les vérifications du programme qui ne sont pas des critères automatiques, comme la calibration, le consentement et la synchronisation des horodatages, sont rapportées comme motifs de rejet dans le rapport de couverture. Consultez Heure acceptée.

Lire et écrire les étiquettes de résultat

Les endpoints REST se trouvent sous https://api.avala.ai/api/v1 :

Méthode et chemin	Rôle
`GET /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/`	Étiquette courante d’une séquence. `404` si la séquence n’a pas d’étiquette.
`PUT /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/`	Enregistre une nouvelle étiquette courante.
`GET /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/history/`	Toutes les versions de l’étiquette, de la plus récente à la plus ancienne.
`GET /datasets/{owner}/{slug}/sequence-outcomes/`	Étiquettes courantes d’un jeu de données, paginées.

La liste du jeu de données accepte les filtres outcome, evaluation_membership, source et autonomy_level. Chacun prend une valeur ou une liste séparée par des virgules, et une séquence correspond si elle a l’une des valeurs de la liste. model_version correspond à une seule version exacte. Une valeur de filtre inconnue renvoie 400. La liste des séquences, GET /datasets/{owner}/{slug}/sequences/, accepte outcome et evaluation_membership sous la même forme. Elle renvoie les séquences dont l’étiquette courante correspond.

Écrire une étiquette

curl -X PUT \
  "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences/<sequence-uid>/outcome/" \
  -H "X-Avala-Api-Key: $AVALA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "outcome": "failure",
    "progress": 0.4,
    "subtasks": [
      { "label": "Place the plate in the lower rack", "start_ts": 0.0, "end_ts": 21.5, "outcome": "failure" }
    ],
    "mistake_type": "slip_during_place",
    "failure_stage": "place",
    "autonomy_level": "autonomous",
    "model_version": "your-policy@2026-09-20",
    "evaluation_membership": "held_out_eval",
    "source": "imported",
    "source_metadata": { "importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher" }
  }'

from avala import Client

client = Client()  # reads AVALA_API_KEY

label = client.sequence_outcomes.set(
    "your-org",
    "kitchen-rollouts",
    "<sequence-uid>",
    outcome="failure",
    progress=0.4,
    subtasks=[
        {"label": "Place the plate in the lower rack", "start_ts": 0.0, "end_ts": 21.5, "outcome": "failure"},
    ],
    mistake_type="slip_during_place",
    failure_stage="place",
    autonomy_level="autonomous",
    model_version="your-policy@2026-09-20",
    evaluation_membership="held_out_eval",
    source="imported",
    source_metadata={"importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher"},
)
print(label.version, label.outcome)

import Avala from "@avala-ai/sdk";

const avala = new Avala(); // reads AVALA_API_KEY

const label = await avala.sequenceOutcomes.set("your-org", "kitchen-rollouts", "<sequence-uid>", {
  outcome: "failure",
  progress: 0.4,
  subtasks: [{ label: "Place the plate in the lower rack", startTs: 0.0, endTs: 21.5, outcome: "failure" }],
  mistakeType: "slip_during_place",
  failureStage: "place",
  autonomyLevel: "autonomous",
  modelVersion: "your-policy@2026-09-20",
  evaluationMembership: "held_out_eval",
  source: "imported",
  sourceMetadata: { importer: "your-eval-harness", run_id: "r42", task: "load_dishwasher" },
});
console.log(label.version, label.outcome);

avala sequence-outcomes set your-org kitchen-rollouts <sequence-uid> \
  --outcome failure \
  --progress 0.4 \
  --subtasks-file subtasks.json \
  --mistake-type slip_during_place \
  --failure-stage place \
  --autonomy-level autonomous \
  --model-version your-policy@2026-09-20 \
  --evaluation-membership held_out_eval \
  --source imported \
  --source-metadata '{"importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher"}'

Le SDK TypeScript prend des noms d’options en camelCase et envoie les champs en snake_case de l’API. Les clés à l’intérieur de sourceMetadata sont envoyées telles quelles. Dans la CLI, --hand-actions-file prend un fichier JSON de la forme {"left": [...], "right": [...]}, et --leakage-group KEY=ID peut être répété.

Lire les étiquettes

# Current label of one sequence
curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences/<sequence-uid>/outcome/" \
  -H "X-Avala-Api-Key: $AVALA_API_KEY"

# Every version, newest first
curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences/<sequence-uid>/outcome/history/" \
  -H "X-Avala-Api-Key: $AVALA_API_KEY"

# Failed or aborted held-out sequences
curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequence-outcomes/?outcome=failure,aborted&evaluation_membership=held_out_eval" \
  -H "X-Avala-Api-Key: $AVALA_API_KEY"

# The sequences themselves, filtered by their current label
curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences/?outcome=mistake_and_recovery,intervention" \
  -H "X-Avala-Api-Key: $AVALA_API_KEY"

from avala import Client

client = Client()

label = client.sequence_outcomes.get("your-org", "kitchen-rollouts", "<sequence-uid>")
versions = client.sequence_outcomes.history("your-org", "kitchen-rollouts", "<sequence-uid>")

page = client.sequence_outcomes.list(
    "your-org",
    "kitchen-rollouts",
    outcome=["failure", "aborted"],
    evaluation_membership="held_out_eval",
    model_version="your-policy@2026-09-20",
)
for item in page:
    print(item.sequence_uid, item.outcome, item.progress)

import Avala from "@avala-ai/sdk";

const avala = new Avala();

const label = await avala.sequenceOutcomes.get("your-org", "kitchen-rollouts", "<sequence-uid>");
const versions = await avala.sequenceOutcomes.history("your-org", "kitchen-rollouts", "<sequence-uid>");

const page = await avala.sequenceOutcomes.list("your-org", "kitchen-rollouts", {
  outcome: ["failure", "aborted"],
  evaluationMembership: "held_out_eval",
  modelVersion: "your-policy@2026-09-20",
});
for (const item of page.items) {
  console.log(item.sequenceUid, item.outcome, item.progress);
}

avala sequence-outcomes get your-org kitchen-rollouts <sequence-uid>
avala sequence-outcomes history your-org kitchen-rollouts <sequence-uid>
avala sequence-outcomes list your-org kitchen-rollouts \
  --outcome failure,aborted \
  --evaluation-membership held_out_eval

La liste du jeu de données renvoie jusqu’à 100 étiquettes par page. Passez le cursor de la page précédente pour continuer.

Lire les étiquettes avec le serveur MCP

Le serveur MCP lit les étiquettes de résultat. Il ne les écrit pas.

get_sequence_outcome prend owner, slug et sequenceUid. Il renvoie l’étiquette courante.
list_sequence_outcomes prend owner et slug, plus les filtres outcome, evaluationMembership, source, autonomyLevel et modelVersion, ainsi que limit et cursor.

Les deux outils renvoient une forme courte par défaut. Passez detail: "full" pour inclure les sous-tâches, les actions des mains, les libellés d’erreur et de récupération, les groupes de fuite, les métadonnées de source et l’auteur de l’étiquette. Consultez Utiliser Avala avec l’IA pour vous connecter.

Exporter les étiquettes de résultat avec LeRobot

L’exportateur LeRobot peut écrire l’étiquette de résultat courante de chaque séquence à côté du jeu de données. Une séquence Avala devient un épisode LeRobot.

avala lerobot export your-org/kitchen-rollouts \
  --repo-id your-hf-user/kitchen-rollouts \
  --output ./lerobot-out \
  --include-outcomes

from avala import Client
from avala.lerobot import export_dataset

export_dataset(
    Client(),
    "your-org",
    "kitchen-rollouts",
    repo_id="your-hf-user/kitchen-rollouts",
    output_dir="./lerobot-out",
    include_outcomes=True,
)

Les étiquettes sont écrites dans meta/avala_sequence_outcomes.jsonl, avec un objet JSON par ligne et une ligne par épisode LeRobot enregistré. La table des épisodes de LeRobot n’a pas de place pour ces métadonnées, d’où ce fichier séparé. Chaque ligne contient ces clés :

Clé	Valeur
`episode_index`	L’indice de l’épisode LeRobot.
`avala_sequence_uid`	La séquence Avala dont provient l’épisode.
`outcome`	La valeur de résultat, ou `null` lorsque la séquence n’a pas d’étiquette.
`outcome_version`	La version de l’étiquette qui a été exportée.
`progress`, `quality`, `speed`	Comme dans l’étiquette.
`subtasks`, `hand_actions`	Comme dans l’étiquette. Les horodatages sont exprimés en secondes depuis le début de l’épisode.
`mistake_type`, `recovery_type`, `failure_stage`, `autonomy_level`, `model_version`, `evaluation_membership`	Comme dans l’étiquette, avec `null` à la place d’une valeur vide.
`leakage_groups`	Comme dans l’étiquette.
`outcome_source`, `outcome_source_metadata`, `outcome_confidence`	Les champs `source`, `source_metadata` et `confidence` de l’étiquette.

Une séquence sans étiquette reçoit une ligne avec seulement episode_index, avala_sequence_uid et "outcome": null.

La voie défaillance et récupération

Les défaillances récupérables sont livrées dans leur propre voie : les séquences dont le résultat est mistake_and_recovery ou intervention. Les sous-tâches et les actions des mains de chaque séquence indiquent où se produisent la défaillance et la récupération. La voie est livrée comme une slice distincte dans la release. Vous pouvez l’utiliser pour l’entraînement, la pondérer ou l’exclure. Vous pouvez aussi construire vous-même le même ensemble avec ?outcome=mistake_and_recovery,intervention. Les séquences dangereuses ne font pas partie de la voie.

Démarrage

Apprentissage de flotte

Plateforme

Cas d'utilisation

Schéma des métadonnées de séquence

L’étiquette de résultat

Exemple

Champs

Valeurs de résultat

Niveau d’autonomie

Sous-tâches

Actions des mains

Durée de la séquence

Appartenance à l’évaluation

Groupes de fuite

Métadonnées de source

Fonctionnement des écritures

Validité technique

Lire et écrire les étiquettes de résultat

Écrire une étiquette

Lire les étiquettes

Lire les étiquettes avec le serveur MCP

Exporter les étiquettes de résultat avec LeRobot

La voie défaillance et récupération

​L’étiquette de résultat

​Exemple

​Champs

​Valeurs de résultat

​Niveau d’autonomie

​Sous-tâches

​Actions des mains

​Durée de la séquence

​Appartenance à l’évaluation

​Groupes de fuite

​Métadonnées de source

​Fonctionnement des écritures

​Validité technique

​Lire et écrire les étiquettes de résultat

​Écrire une étiquette

​Lire les étiquettes

​Lire les étiquettes avec le serveur MCP

​Exporter les étiquettes de résultat avec LeRobot

​La voie défaillance et récupération

L’étiquette de résultat

Exemple

Champs

Valeurs de résultat

Niveau d’autonomie

Sous-tâches

Actions des mains

Durée de la séquence

Appartenance à l’évaluation

Groupes de fuite

Métadonnées de source

Fonctionnement des écritures

Validité technique

Lire et écrire les étiquettes de résultat

Écrire une étiquette

Lire les étiquettes

Lire les étiquettes avec le serveur MCP

Exporter les étiquettes de résultat avec LeRobot

La voie défaillance et récupération