Skip to main content
skill CX Codex

tao-list-capabilities — Claude Code skill: features and setup

Inspects TAO Skill Bank manifests to report available models, workflows, and AutoML actions. Use it to check support before training or compression.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add NVIDIA/skills --skill tao-list-capabilities -a claude-code
Open on GitHub

What tao-list-capabilities does

This skill inspects packaged manifests and helpers inside TAO Skill Bank instead of guessing support from repository text. When queried, it invokes scripts/list_tao_capabilities.py or scripts/list_tao_models.py using Bash. The output covers application and data pipelines alongside execution platforms such as Docker, Slurm, Kubernetes, and Brev.

Model coverage is determined by skills/models/schemas.manifest.json. The skill reports which stages work for each model: training, evaluation, inference, export, or TensorRT engine compilation. For AutoML tasks like distill, prune, or quantize, it validates the respective schema file inside skills/models/<model_skill>/schemas/. If that JSON schema is missing, it refuses to claim AutoML support.

Working with this skill requires access to TAO_SKILL_BANK_PATH and the Read and Bash tools. For standalone setups not initialized by the main plugin, run tao-setup first to resolve host preflights and credentials.

What it helps with

  • list available computer vision models in TAO Toolkit
  • verify AutoML support for model pruning or quantization
  • check deployment targets across Docker, Slurm, and Kubernetes
  • audit supported fine-tuning stages for a specific model

Example prompts for the agent

  • Which models in TAO support AutoML quantization?
  • List all application and data workflows available in TAO Skill Bank.
  • Can we build a TensorRT engine for this TAO model?

How to install tao-list-capabilities

1Skills CLI (Vercel)

npx skills add NVIDIA/skills --skill tao-list-capabilities -a claude-code

2Manually: put the files in place

~/.claude/skills/tao-list-capabilities/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tao-list-capabilities/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tao-list-capabilities

How to install tao-list-capabilities in Claude Code?

Run npx skills add NVIDIA/skills --skill tao-list-capabilities -a claude-code. The definition will be placed in ~/.claude/skills/tao-list-capabilities/SKILL.md.

What does the tao-list-capabilities skill do?

It executes packaged Python discovery scripts against TAO manifests. The agent then lists supported models, deployment runtimes, and AutoML capabilities directly from verified schema files.

What dependencies are required before using this skill?

You need the packaged helper scripts accessible through TAO_SKILL_BANK_PATH. If your session was not initialized via the TAO skill bank plugin, execute tao-setup first for host preflight and credentials.

Source text

SKILL.md · Apache-2.0
---
name: tao-list-capabilities
description: >-
  Answer what the TAO Skill Bank plugin can do by generating the response from
  packaged application, data, model, AutoML, and platform manifests. Use when
  the user asks "what can TAO Skill Bank do", "list TAO models", "which TAO
  workflows are available", or "what supports AutoML".
license: Apache-2.0
compatibility: Requires the packaged TAO skill bank helper scripts.
metadata:
  author: NVIDIA Corporation
  version: "0.1.0"
allowed-tools: Read Bash
tags:
- tao
- capabilities
- discovery
---

# TAO Skill Bank Capabilities

> **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).

Use this skill when the user asks what `tao-skill-bank` can do, asks for plugin
capabilities, asks which application or data workflows are available, asks which
models are supported, or asks what models are capable with AutoML.

## Quick Start

Run `scripts/list_tao_capabilities.py` for general capability questions, or
`scripts/list_tao_models.py` for model/action and AutoML support questions.

## Capability Answers

For a general capabilities answer, run the packaged helper:

```bash
${TAO_SKILL_BANK_PATH:-~/tao-skill-bank}/scripts/list_tao_capabilities.py \
  --skill-bank ${TAO_SKILL_BANK_PATH:-~/tao-skill-bank} --format text
```

Use the helper output as the source of truth for the answer instead of manually
enumerating capabilities from this skill or plugin metadata. Include:

- Every top-level application workflow under `applications/` and what it can do.
- Every top-level data workflow under `data/` and what it can do.
- Supported execution platforms, discovered 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.
- The fine-tuning/deployment workflow coverage for models under `models/`: train,
  evaluate, inference, export, and TensorRT engine generation when those actions
  are present in the packaged schema manifest.
- AutoML support and the AutoML per-action schema gate.

## Model Lists

When the user asks which TAO models are available or which actions a model can
run, use the packaged model-list script instead of manually scanning model
folders:

```bash
${TAO_SKILL_BANK_PATH:-~/tao-skill-bank}/scripts/list_tao_models.py \
  --skill-bank ${TAO_SKILL_BANK_PATH:-~/tao-skill-bank} --scope all --format text
```

The model list comes from `skills/models/schemas.manifest.json`.

## AutoML Lists

When the user asks what models are capable with AutoML, use the same model-list
script in AutoML mode, or the compatibility wrapper:

```bash
${TAO_SKILL_BANK_PATH:-~/tao-skill-bank}/scripts/list_tao_models.py \
  --skill-bank ${TAO_SKILL_BANK_PATH:-~/tao-skill-bank} --scope automl --format text
```

```bash
${TAO_SKILL_BANK_PATH:-~/tao-skill-bank}/scripts/list_automl_support.py \
  --skill-bank ${TAO_SKILL_BANK_PATH:-~/tao-skill-bank} --format text
```

Use `--action distill`, `--action prune`, or `--action quantize` when the user
asks about a specific compression action.

AutoML support for an action requires
`skills/models/<model_skill>/schemas/<action>.schema.json` to be packaged with the plugin
and parse successfully as JSON. If that dataclass schema is missing or invalid,
do not describe the model/action as AutoML-supported.

© NVIDIA Corporation · Apache-2.0 · NVIDIA/skills

Similar skills

Everything for AI and ML →

From the same set178

tao-run-automl-deft-pipeline A skill that chains three training phases: hyperparameter search, the DEFT loop, and a second AutoML pass on the augmented dataset. CX Codex +1 1,600installs tao-train-metric-learning-recognition Trains, evaluates, and exports NVIDIA TAO metric learning models using contrastive or triplet losses. Useful for visual retrieval and fine-grained matching. CX Codex +1 1,600installs tao-convert-dataset-format This skill runs tao-daft convert to move NVIDIA TAO DAFT datasets between supported formats. Use it when preparing DAFT data for VLM training. CX Codex +1 1,600installs tao-generate-video-reasoning-annotations Turns raw videos into a training dataset with captions, descriptions and QA pairs carrying reasoning traces. Useful when you need labelled video data. CX Codex +1 1,600installs tao-run-automl This skill runs AutoML and hyperparameter search for NVIDIA TAO models. Use it to tune training or another supported model action on a selected platform. CX Codex +1 1,600installs tao-finetune-cosmos-reason The skill plans and runs Cosmos3 fine-tuning through Cosmos Framework or Cosmos-RL, validating every input before training starts. CX Codex +1 1,600installs tao-launch-workflow Mandatory pre-launch gate that verifies credentials, datasets, and container images before executing any NVIDIA TAO workflow. CX Codex +1 1,600installs tao-train-fast-foundation-stereo A skill for training, evaluating and exporting TAO FastFoundationStereo: it turns rectified stereo pairs into disparity maps with roughly 10× lower latency than full FoundationStereo. CX Codex +1 1,600installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor