Tao Artifacts

NVIDIAOfficialCreated by NVIDIA Corporation

Skill
Tool integration
Software development
Apache-2.0
Medium risk
Has scripts

From the author

The contract home for TAO's SDK-free execution pipeline — authoritative JSON Schemas for the four typed artifacts (spec-bundle, job-record, results_dir layout, best_rec) plus the fixed job-status vocabulary and the nested-not-dotted spec rule. Use when authoring or validating a spec-bundle before submit, writing or reading a .tao/jobs job-record, resolving where results land, or consuming AutoML's best_rec.json. Trigger phrases include "validate the spec bundle", "job record schema", "status vocabulary", "results_dir layout", "best_rec schema".

— the description by NVIDIA Corporation

AutoGineer summary

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

This skill provides the definitive source of truth for the four primary artifacts used in the TAO execution pipeline: spec-bundle, job-record, results_dir layout, and best_rec. It defines the structural requirements, validation schemas, and operational rules necessary for producers and consumers to interact reliably within the TAO ecosystem. By enforcing consistent data formats and state vocabularies, it ensures that model data, job records, and output directories remain interoperable across different execution environments.

What it does

Provides authoritative JSON schemas for validating TAO pipeline artifacts
Defines the fixed vocabulary for job status transitions
Enforces structural rules for spec-bundle configuration and nesting
Specifies the storage-agnostic layout contract for job output directories
Outlines the lifecycle and responsibilities for model-to-platform execution seams

When to use it

When authoring or validating a spec-bundle before job submission
When reading or writing a job-record in the .tao/jobs directory
When resolving the location of job output artifacts
When consuming AutoML best_rec.json files
When debugging pipeline state transitions or artifact inconsistencies

Advantages

Ensures structural consistency across heterogeneous execution platforms
Provides a single source of truth for pipeline data contracts
Simplifies integration between model producers and platform consumers
Standardizes job state reporting for reliable monitoring and polling

Usage examples

“Validate the spec bundle”: The agent uses the provided JSON schema to verify that the spec-bundle configuration adheres to the required nested structure and mode discrimination rules.
“What is the status vocabulary?”: The agent returns the fixed set of job states: PENDING, RUNNING, COMPLETE, ERROR, CANCELED, and UNKNOWN.
“Show me the results_dir layout”: The agent explains the storage-agnostic layout where artifacts are organized by job_id and output_key under the defined results root.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/tao-artifacts/download

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

mkdir -p .agents/skills && unzip tao-artifacts.zip -d .agents/skills

Documentation by NVIDIA Corporation

tao-artifacts

Four typed artifacts flow through every TAO job. Their schemas live here and nowhere else — producers (model/data skills) and consumers (platform skills) both validate against this skill's references/.

Artifact	Schema	Produced by → consumed by
spec-bundle	`references/spec_bundle.schema.json`	model/data skill → platform skill (at the submit seam)
job-record	`references/job_record.schema.json`	`scripts/tao_job_record.py` (the ONLY writer) → any re-attaching agent/poller
results_dir layout	`references/results_dir.contract.md`	platform skill at submit → whoever collects outputs
best_rec	`references/best_rec.schema.json`	tao-run-automl adapter → DEFT warm-start

Quick Start — validate an artifact

python - <<'PY'
import json, yaml, jsonschema, pathlib
ref = pathlib.Path("${TAO_SKILL_BANK_PATH:?}/skills/core/tao-artifacts/references")
schema = json.loads((ref / "spec_bundle.schema.json").read_text())
bundle = yaml.safe_load(open("/path/to/bundle.yaml"))   # or a dict built in-context
jsonschema.validate(bundle, schema)                      # raises on violation
print("bundle OK")
PY

Validate the bundle before the verify-before-launch gate; validate a job-record only when debugging (the writer script already enforces the schema).

The two rules the schemas enforce structurally

Nested, not dotted. A spec is a nested dict mirroring the container's config shape — {"train": {"num_epochs": 12}}. Any key containing . at any depth is rejected ({"train.num_epochs": 12} is the #1 authoring mistake). Note the distinction: declared_inputs[].spec_key and gpu_spec_key are dotted/indexed pointers into the spec (dataset.train_data_sources[0].image_dir) — dots are correct there.
Mode discrimination. mode: config requires spec + config_format and a command containing {config_path}, and forbids args. mode: args requires args and forbids spec. There is no other mode.

Optional action lifecycle

Use execution when an action needs more than its primary command. This is the shared model-to-platform seam; do not add a model-specific Docker, Kubernetes, or SLURM renderer merely to carry runtime environment, attestations, post-processing, or helper dependencies.

The producing model/data skill owns environment, ordered pre_commands, ordered post_commands, distributed-launch intent, and completion evidence.
The platform owns container mounts, scheduler/container syntax, task/rank binding, timeouts, log paths, and preservation of the real child exit code.
environment is non-secret. Credential values continue to use the selected platform's secret/sidecar contract and never enter a spec-bundle.
Commands, environment values, and string values in spec may use {config_path}, {job_id}, and {results_dir}. The platform binds them only after the job record has been opened; the job record's results_dir is authoritative over any pre-review display path. Persist hashes of both the producer bundle and the bound runtime config.
supporting_files names checked-in orchestration helpers relative to the producing skill root. The platform stages the closed set, verifies every declared SHA256, and rejects traversal, undeclared siblings, or overwrite of a different bundle. Supporting files orchestrate an action; they must never shadow or patch code inside the selected image.
A torchrun declaration expresses process topology, not SLURM/Kubernetes syntax. Each platform maps it to its native distributed launcher.

Fixed status vocabulary

Every job state anywhere in the pipeline is exactly one of:

PENDING · RUNNING · COMPLETE · ERROR · CANCELED · UNKNOWN

Platform-native sub-states (ImagePullBackOff, PENDING-because-resources, Insufficient-GPU, slurm COMPLETING…) are never new states — they ride in the transition's message field. Terminal = COMPLETE | ERROR | CANCELED. This is what lets the in-turn poll loop and the detached poller share one code path across docker/slurm/kubernetes/brev.

Ordering invariants (enforced at the seam, stated here)

The verify-before-launch gate runs on the spec-bundle, before any job id exists.
tao_job_record.py open writes PENDING + the resolved results_dir first and returns the id — the only handle a launch can use. A submit that skipped the gate has no id, so it cannot launch.
transitions is append-only; .tao/ lives outside every synced results tree.

Files

ATTRIBUTION.mdAdded by AutoGineer909 B
BENCHMARK.md6.9 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md5.3 KiB
config/skillspector-baseline.yaml834 B
evals/evals.json903 B
references/best_rec.schema.json2.3 KiB
references/job_record.schema.json3.9 KiB
references/results_dir.contract.md1.6 KiB
references/spec_bundle.schema.json8.0 KiB
references/tests/test_artifact_schemas.pyScript12.9 KiB
skill-card.md4.3 KiB
skill.oms.sig5.9 KiB

BENCHMARK.md

Skill Benchmark: tao-artifacts

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

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

Evaluation Metadata

Skill: tao-artifacts
Evaluation date: 2026-10-16
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:615d7cbfd18bece2985875429c1ee5e8d6c108e1dab4c4a54a048980eb6a637c (skill-evaluator-dataset-snapshot/1)
Attempts per task: 1
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

Measure	Claude Code (Baseline → Skill Uplift)	Codex (Baseline → Skill Uplift)
Overall	98.6% — baseline ran, but no comparable score was available; uplift unavailable	75.7% — baseline ran, but no comparable score was available; uplift unavailable
Security	100.0% → 100.0% (±0.0 points)	100.0% → 100.0% (±0.0 points)
Correctness	0.0% → 100.0% (+100.0 points)	0.0% → 100.0% (+100.0 points)
Discoverability	100.0% — baseline ran, but no comparable score was available; uplift unavailable	0.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness	16.7% → 95.0% (+78.3 points)	16.7% → 80.0% (+63.3 points)
Efficiency	97.8% — baseline ran, but no comparable score was available; uplift unavailable	99.7% → 98.5% (-1.2 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.

Agent	Dataset case	With skill	Without skill	Delta	Change	Coverage
claude-code	All cases	98,246	30,050	+68,196	+226.94%	skill 1/1; base 1/1
claude-code	tao-artifacts-schemas	98,246	30,050	+68,196	+226.94%	skill 1/1; base 1/1
codex	All cases	13,854	13,504	+350	+2.59%	skill 1/1; base 1/1
codex	tao-artifacts-schemas	13,854	13,504	+350	+2.59%	skill 1/1; base 1/1
ALL AGENTS	Dataset aggregate	112,100	43,554	+68,546	+157.38%	skill 2/2; base 2/2

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

Tier	Purpose	Status	Evidence
Tier 1	Static validation	PASSED WITH OBSERVATIONS	11 validator(s); 13 finding(s)
Tier 2	Semantic deduplication	PASSED	2 validator(s); 0 finding(s)
Tier 3	Live agent evaluation	PASS	2 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/core/tao-artifacts/SKILL.md)
MEDIUM SCHEMA/frontmatter_field_placement: Root field 'tags' is ignored; use 'metadata.tags' (skills/core/tao-artifacts/SKILL.md)
MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/core/tao-artifacts)
MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Instructions' (skills/core/tao-artifacts/SKILL.md)
MEDIUM SCHEMA/body_recommended_section: Missing recommended section: '## Examples' (skills/core/tao-artifacts/SKILL.md)
8 additional finding(s) are available in the full evaluation artifacts.

</details>

Scoring Methodology

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

Dimension	Question	Scored signals
Security	Is it safe to use?	`security` (100%)
Correctness	Is the answer correct?	`accuracy` (100%)
Discoverability	Was the right skill loaded when needed?	`skill_execution` (100%)
Effectiveness	Did the skill help complete the task?	`goal_accuracy` (50%) + `behavior_check` (50%)
Efficiency	Did 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, Needs Python

The author says: Python 3.10+ with jsonschema for validation. No nvidia-tao-sdk.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

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-artifacts · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

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-artifacts.zip