AutoGineer
Generated banner for Tao Train Single Step
Generated logo for Tao Train Single Step

Tao Train Single Step

NVIDIAOfficialCreated by NVIDIA Corporation

  • Skill
  • Workflow
  • Software development
  • Apache-2.0
  • Medium risk
Download ZIP

From the author

Standard single-step train/eval/export workflow for any TAO model. Use when training a TAO model on a dataset without iterative data augmentation, AutoML, or DEFT loops. Trigger phrases include "single train run", "train then evaluate then export", "plain TAO training", "normal training", "no AutoML", "skip the loop". Routes through the per-model SKILL.md for action specifics and through `tao-launch-workflow` for platform/credentials/dataset intake.
— the description by NVIDIA Corporation

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The tao-train-single-step skill provides a structured, container-backed procedure for supervised fine-tuning of TAO models. It is designed for users who require a straightforward training run without iterative data augmentation or AutoML loops. The workflow manages the lifecycle from dataset intake and platform selection to model training, evaluation, and optional export, ensuring that the correct container images and credentials are used for the chosen execution environment.

What it does

  • Executes a single-pass supervised training run for a specified TAO model.
  • Performs model evaluation if a dataset URI is provided.
  • Handles optional model export upon user request.
  • Integrates with platform-specific skills for execution on Docker, Slurm, Kubernetes, or other supported environments.
  • Resolves and confirms the required container images before initiating training.
  • Manages credential intake based on the selected platform and model requirements.

When to use it

  • When you need a standard training run without AutoML or iterative loops.
  • When adapting a pretrained model to a new dataset.
  • When you have a specific dataset and want to perform a direct train-eval-export cycle.
  • When you need to override default training configurations or container images.

Advantages

  • Provides a consistent, repeatable process for model training.
  • Ensures compatibility by resolving model-specific container images.
  • Offers flexibility in platform selection for diverse infrastructure needs.
  • Simplifies the configuration process by guiding the user through necessary credentials and settings.

Usage examples

“Run a plain TAO training for my clip model on this dataset.”
The agent initiates the single-step workflow, resolves the required container image, asks for platform selection, and proceeds with training.
“I want to train then evaluate then export my nvdinov2 model, no AutoML.”
The agent sets the AutoML policy to off and executes the standard train, eval, and export sequence.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/tao-train-single-step/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip tao-train-single-step.zip -d .agents/skills

Documentation by NVIDIA Corporation

Normal Train

Standalone install? If this session was not initialized by the TAO skill bank plugin, run the tao-setup skill first (host preflight, credentials, cross-skill discovery).

Standard supervised fine-tuning: train a model on a labeled dataset, optionally evaluate, then optionally export. The most common TAO workflow for adapting a pretrained model to a new dataset.

Steps

  1. train — executed through AutoML when the selected model has automl_enabled: true and automl_policy is on; set automl_policy=off for a plain single training run

  2. eval — executed if eval_dataset_uri is resolved

  3. export — optional, on user request after training

Prerequisites

The selected model skill's resolved container_image is the default training runtime. Do not replace it with a host venv, uv environment, generic training image, or hand-written trainer unless the user explicitly requests that execution mode. SDK/controller Python environments are control-plane-only; the model action remains container-backed.

Required

  • model: A compatible TAO model (e.g., clip, nvdinov2, grounding_dino)

  • train_dataset_uri: URI of the training dataset (e.g., s3://bucket/train/)

  • platform: Discover the execution platforms from the installed platform skills (tao-run-on-docker / -slurm / -kubernetes / -brev, plus any external one); on a runtime that surfaces only the core router skills, read skills/platform/tao-run-on-*/SKILL.md frontmatter.

  • container image confirmation: resolve the default image from the selected model/action config, show it to the user, and require confirmation or image=<override> before creating runner files or submitting training.

Optional

  • eval_dataset_uri: Some model skills mark this as required — check the resolved model skill before treating it as optional.

  • base_checkpoint: If not provided, defaults to the NGC pretrained checkpoint listed in the model skill, or trains from scratch if no NGC checkpoint exists.

  • automl_policy: on by default; set off to bypass model-level AutoML for this run while leaving model metadata unchanged. Use only on / off in new launch settings.

  • image override: Use image=<override> to pin a specific TAO toolkit build after reviewing the resolved default.

Launch Intake

After the user confirms they want this standard train/eval/export workflow, ask which supported platform they intend to run on. Discover the execution platforms from the installed platform skills (tao-run-on-docker / -slurm / -kubernetes / -brev, plus any external one); on a runtime that surfaces only the core router skills, read skills/platform/tao-run-on-*/SKILL.md frontmatter.

Before creating a plain train runner, inspect the selected model's metadata with scripts/list_tao_models.py --scope automl --format json or read skills/models/<network>/references/skill_info.yaml. If automl_enabled is true and the helper reports a valid train schema for that model, route the train stage through skills/applications/tao-run-automl by default. Only stay on the plain train path when automl_policy=off, the user explicitly asks for no HPO/AutoML, or AutoML is enabled but not runnable because the model's train schema is not packaged yet.

Also ask whether long-running monitoring should stay enabled and how many minutes between status updates. Defaults: enabled, 5 minutes.

After the model/action are known, run scripts/resolve_tao_image.py --model <network> --action train --format text and ask whether to use the resolved image or an image=<override>. Do not create the tao-train-single-step runner until the image is confirmed.

After platform selection, read the chosen platform skill's ## Credentials section and references/skill_info.yaml (required_credentials / credential_groups) and ask only for credentials relevant to that platform, plus any selected-model credentials. Do not ask for unrelated platform credentials.

Files

BENCHMARK.md

Skill Benchmark: tao-train-single-step

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

Recommended for publication based on the completed evaluation evidence in this report.

Evaluation Metadata

  • Skill: tao-train-single-step

  • Evaluation date: 2026-09-17

  • Evaluator version: 1.5.6

  • Agents: Claude Code (aws/anthropic/bedrock-claude-opus-4-8), Codex (openai/openai/gpt-5.5)

  • Tasks: 1 evaluation tasks (1 positive)

  • Dataset digest: sha256:48f484a83577a304c6518b28cbd7630e71af86b9a0f1655d980ea51b650d034d (skill-evaluator-dataset-snapshot/1)

  • Attempts per task: 3

  • Environment: k8s-sandbox

  • Tier 2 evidence: required for publication

  • Tier 3 evidence: required for publication

Each task attempt ran in its own isolated sandbox pod.

What This Report Answers

The three-tier evaluation checks whether the skill:

  • is safe to use;

  • produces correct answers;

  • is discovered and activated when needed;

  • helps the agent complete the user's goal and expected workflow; and

  • avoids wasted skill and tool usage.

Results at a Glance

MeasureClaude Code (Baseline → Skill Uplift)Codex (Baseline → Skill Uplift)
Overall94.6% — baseline ran, but no comparable score was available; uplift unavailable71.4% — baseline ran, but no comparable score was available; uplift unavailable
Security100.0% → 100.0% (±0.0 points)100.0% → 100.0% (±0.0 points)
Correctness0.0% → 100.0% (+100.0 points)0.0% → 100.0% (+100.0 points)
Discoverability100.0% — baseline ran, but no comparable score was available; uplift unavailable0.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness5.6% → 100.0% (+94.4 points)16.7% → 58.3% (+41.6 points)
Efficiency73.2% — baseline ran, but no comparable score was available; uplift unavailable99.7% → 98.6% (-1.1 points)

How to read this table: baseline is the same task attempted without the target skill. Scores are rounded to one decimal; threshold-adjacent values use additional precision so their displayed band matches the verdict. Uplift is derived from those displayed scores and shown in percentage points.

Example: 47.0% → 92.0% (+45.0 points) means the skill-assisted run scored 92.0%, 45.0 percentage points above its 47.0% no-skill baseline.

A partial dimension was calculated from only the available configured signals; review the detailed report before relying on it.

Token Usage

Actual Tier 3 execution usage is reported for every observed agent/case pair and both conditions.

AgentDataset caseWith skillWithout skillDeltaChangeCoverage
claude-codeAll cases96,114513,826N/AN/Askill 1/1; base 3/3
claude-codetao-train-single-step-basic96,114513,826N/AN/Askill 1/1; base 3/3
codexAll cases13,73740,890N/AN/Askill 1/1; base 3/3
codextao-train-single-step-basic13,73740,890N/AN/Askill 1/1; base 3/3
ALL AGENTSDataset aggregate109,851554,716N/AN/Askill 2/2; base 6/6

Prompt tokens include cached reads, so total tokens are prompt + completion (cached is not added twice). The Efficiency score uses (prompt - cached) + completion. N/A means the relevant trajectory counters were not available; coverage is never estimated.

Tier Status

TierPurposeStatusEvidence
Tier 1Static validationPASSED WITH OBSERVATIONS11 validator(s); 16 finding(s)
Tier 2Semantic deduplicationPASSED2 validator(s); 0 finding(s)
Tier 3Live agent evaluationPASS2 agent(s); 1 task(s)

Findings and Observations

<details> <summary>Show detailed findings and successful checks</summary>

  • MEDIUM QUALITY/quality_correctness: SKILL_SPEC recommended field missing: 'metadata.tags' (skills/applications/tao-train-single-step/SKILL.md)

  • MEDIUM SCHEMA/frontmatter_field_placement: Root field 'tags' is ignored; use 'metadata.tags' (skills/applications/tao-train-single-step/SKILL.md)

  • MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/applications/tao-train-single-step)

  • MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Instructions' (skills/applications/tao-train-single-step/SKILL.md)

  • MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Examples' (skills/applications/tao-train-single-step/SKILL.md)

  • 11 additional finding(s) are available in the full evaluation artifacts.

</details>

Scoring Methodology

<details> <summary>Show dimension definitions, source signals, and thresholds</summary>

DimensionQuestionScored signals
SecurityIs it safe to use?security (100%)
CorrectnessIs the answer correct?accuracy (100%)
DiscoverabilityWas the right skill loaded when needed?skill_execution (100%)
EffectivenessDid the skill help complete the task?goal_accuracy (50%) + behavior_check (50%)
EfficiencyDid it avoid wasted tool calls and token usage?skill_efficiency (50%) + token_efficiency (50%)

  • Dimension bands: PASS at 50% or above; NEUTRAL from 40% to below 50%; FAIL below 40%.

  • Overall Tier 3 lift: PASS at +5 points or more; FAIL at -10 points or less; values between those bands are NEUTRAL.

  • Overall verdict: PASS only when every configured dimension passes for at least one supported agent. Lift is reported as diagnostic evidence and does not override this gate.

  • The 50% attempt pass threshold is a separate per-task gate; it is not the dimension pass threshold.

  • Effectiveness is the equal-weight mean of goal completion (goal_accuracy) and expected workflow adherence (behavior_check).

  • Efficiency is 50% tool-call productivity (the backward-compatible skill_efficiency wire id) and 50% token_efficiency. Positive-case skill routing is scored under Discoverability, not Efficiency; a negative case without a routing target is N/A. N/A sources are omitted, remaining weights are renormalized, and the dimension is marked partial.

Signals present in this run:

  • security (Security): unsafe operations, secret leakage, and unauthorized access.

  • skill_execution (Skill Execution): whether the expected skill was selected, decoys were avoided, and the workflow executed.

  • skill_efficiency (Tool Productivity): tool-call productivity (legacy wire id; routing is scored under Discoverability).

  • accuracy (Accuracy): final-answer correctness against the reference answer.

  • goal_accuracy (Goal Accuracy): whether the user's goal was achieved.

  • behavior_check (Behavior Check): whether the expected workflow behavior was followed.

  • token_efficiency (Token Efficiency): actual uncached prompt plus completion usage (50% of Efficiency).

</details>

Freshness

Regenerate this benchmark when the skill, evaluation dataset, target agent/model, evaluator version, environment, or scoring policy changes.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Declares allowed tools

The author says: Requires docker + nvidia-container-toolkit. Workflows declare additional requirements.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA Corporation
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/tao-train-single-step · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA Corporation or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download tao-train-single-step.zip