Reference Design Contract
nexu-io/open-design
Turn vague taste, screenshots, URLs, product notes, or "make it feel like this" references into a grounded DESIGN.md plus an implementation handoff.
Four-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified…
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install NVIDIA/skills tao-generate-referring-expressions --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/tao-generate-referring-expressions .claude/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .claude/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressionsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install NVIDIA/skills tao-generate-referring-expressions --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/tao-generate-referring-expressions .agents/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .agents/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install NVIDIA/skills tao-generate-referring-expressions --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/tao-generate-referring-expressions .cursor/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .cursor/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/NVIDIA/skills.git --path skills/tao-generate-referring-expressions--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install NVIDIA/skills tao-generate-referring-expressions --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/tao-generate-referring-expressions .gemini/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .gemini/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install NVIDIA/skills tao-generate-referring-expressionsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/tao-generate-referring-expressions .github/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .github/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install NVIDIA/skills tao-generate-referring-expressions --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/tao-generate-referring-expressions .opencode/skills/tao-generate-referring-expressions && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "tao-generate-referring-expressions" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/tao-generate-referring-expressions into .opencode/skills/tao-generate-referring-expressions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tao-generate-referring-expressions", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
tao-generate-referring-expressionsFour-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified…
Tao Generate Referring Expressions is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Four-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified expressions via VLM distillation. Use when the user wants to generate referring-expression annotations from images with KITTI labels, build region descriptions, produce grouped grounding phrases tied to bboxes, run a double-check verification pass on grounding expressions, auto-label traffic / scene images for referring…
Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 11 other files, including reference files (for example `BENCHMARK.md`, `config/skillspector-baseline.yaml` and `evals/evals.json`). Compatibility notes: Requires docker + nvidia-container-toolkit + at least one VLM endpoint (Gemini API key or OpenAI-compatible).
The repository describes itself as: Agent Skills for NVIDIA products — install into Claude Code, Codex, and other coding agents to run Physical AI, robotics, simulation, CUDA, and RAG workflows end to end. The licence is Apache-2.0.
6 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 14a98ae. It shows what the files ask for, not the result of running them.
Pre-approves these tools, so the agent can use them without asking each time:
ReadBashWriteFrom allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are bash).
From the folder's file list and the shell code blocks in SKILL.md.
Hosts in commands or code, which the agent is likely to contact:
inference-api.nvidia.comFrom URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
GOOGLE_API_KEYFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Requires docker + nvidia-container-toolkit + at least one VLM endpoint (Gemini API key or OpenAI-compatible).
From compatibility in the SKILL.md frontmatter.
Tao Generate Referring Expressions loads about 2.6k tokens when it runs, and up to ~7.9k if it reads all its reference files. Until then it costs about 198 tokens; SKILL.md has 990 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check noted patterns worth knowing about, such as sudo or a known installer.
allowed-tools: Read, Bash, WriteAutomated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from NVIDIA/skills at commit 14a98ae, republished under its Apache-2.0 licence (© NVIDIA). 990 words, ~2,586 tokens.
.claude/skills/tao-generate-referring-expressions/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.Standalone install? If this session was not initialized by the TAO skill bank plugin, run the
tao-setupskill first (host preflight, credentials, cross-skill discovery).
Generate referring-expression and grounding annotations from images with KITTI-format bounding box labels. A single VLM (Gemini or any OpenAI-compatible endpoint) runs four steps: per-object region descriptions, holistic image captions, grouped grounding expressions tied to bboxes, and an optional double-check verification pass.
Transform (image, KITTI labels) pairs into a unified annotations.jsonl containing rich, grounded referring expressions. The VLM acts as a "teacher" annotator: Steps 0-1 see the image; Step 2 groups Step 0 outputs into grouping phrases with bbox lists; Step 3 (optional) re-examines those bboxes against the image and corrects mismatches.
Step 0: Region expression ──┐
├──▶ Step 2: Grounding expression ──▶ [Step 3: Double check]
Step 1: Image caption ──────┘ (optional)bbox_2d, type, color, description).Steps 0 and 1 run in parallel within a single thread pool (they only depend on the seed records). Each step writes its own step_<N>_*/annotations.jsonl and skips already-processed images on re-run unless workflow.force_reprocess: true.
When a user wants to run this pipeline, walk through these steps:
Images: Ask for data.image_dir, the directory containing .jpg, .jpeg, or .png images.
KITTI labels: Ask for data.kitti_label_dir, the directory containing one .txt label file per image. Each label line must use KITTI format: <type> <truncated> <occluded> <alpha> <bbox_left> <bbox_top> <bbox_right> <bbox_bottom> .... Lines with fewer than 8 fields are silently skipped. Set this even for Step 1-only runs because Steps 0 and 2 require it.
Resume from existing annotations: If the user already has a unified annotations.jsonl from a previous run, set data.input_annotations_jsonl to that file instead of seeding from data.image_dir and data.kitti_label_dir.
API access: Ask the user which VLM endpoint they want to use. Present these five options and act on the choice:
vlm.backend: "gemini"; require GOOGLE_API_KEY (env var or vlm.gemini.api_key).https://inference-api.nvidia.com/v1) — set vlm.backend: "openai"; collect base_url, model_name, and api_key.base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".skills/applications/tao-run-inference-service skill, which stands up a local TAO inference microservice with an OpenAI-compatible API. Before promising a specific model, check skills/applications/tao-run-inference-service/references/service.yaml for valid_network_arch_config_basenames. Once the server is up, collect base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".base_url, model_name, and (optionally) api_key; set vlm.backend: "openai".vlm.backend: "openai"; collect base_url, model_name, and (optionally) api_key.If the user has no endpoint and does not want to set one up, stop and help resolve API access first.
Workflow steps: Choose one of:
["0", "1", "2", "3"]["0", "2", "3"], where Step 2 falls back to image-only context["0", "1", "2"]Output format: Choose one of:
jsonl: unified schema onlylegacy: byte-compatible .txt.stepN files onlyboth: writes both formats and is the default for downstream toolingThe pipeline runs inside the TAO Toolkit container via the auto_label CLI:
auto_label generate -e /path/to/spec.yaml \
results_dir=/results \
image_referring_expression.data.image_dir=/data/images \
image_referring_expression.data.kitti_label_dir=/data/labels \
image_referring_expression.vlm.gemini.api_key=$GOOGLE_API_KEYGenerate a default spec: auto_label default_specs results_dir=/results module_name=auto_label, then set autolabel_type: "image_referring_expression". All fields support Hydra dot-notation overrides on the command line.
See references/configuration.md for the full YAML structure, all parameters, model/endpoint setup, and error patterns.
step_0_region_expr/annotations.jsonl — are object types, colors, and discriminating phrases accurate?step_2_grounding_expr/annotations.jsonl — are objects grouped sensibly, and do bbox coordinates match the described groups?step_3_double_check/annotations.jsonl — were mismatched bboxes removed or tightened? Are any new errors introduced (rare)?gemini-2.5-pro or a larger Qwen3-VL endpoint), raise media_resolution / max_output_tokens, then re-run with workflow.force_reprocess=true.Key configuration fields (full reference in references/configuration.md):
| Field | Default | Description |
|---|---|---|
workflow.steps | ["0","1","2","3"] | Which steps to execute (0=region_expr, 1=image_caption, 2=grounding_expr, 3=double_check) |
workflow.max_workers | 4 | Parallel threads per step (watch API rate limits) |
workflow.force_reprocess | false | Ignore cached per-step outputs and reprocess from scratch |
workflow.output_format | "jsonl" (set to "both" in the default spec) | "jsonl", "legacy", or "both" |
vlm.backend | "gemini" | "gemini" or "openai" (OpenAI-compatible endpoint) |
data.image_dir | required | Directory of input images (.jpg / .jpeg / .png) |
data.kitti_label_dir | required (unless resuming) | Directory of KITTI-format .txt label files |
data.input_annotations_jsonl | "" | Optional pre-seeded annotations.jsonl (skips KITTI seeding) |
Two ways to seed the pipeline:
data.image_dir and data.kitti_label_dir. The orchestrator walks the image directory, reads the matching <stem>.txt KITTI file, parses bboxes (fields 0 + 4-7), reads each image's width/height via PIL, and writes a seed_annotations.jsonl to results_dir/.data.input_annotations_jsonl to a file with one {"image_id", "image_path", "width", "height", "kitti_bboxes": [...]} object per line.All outputs go to results_dir/:
seed_annotations.jsonl — initial per-image records (unless input_annotations_jsonl was supplied).step_0_region_expr/annotations.jsonl — adds regions[] (each with bbox/bbox_2d, type, color, description).step_1_image_caption/annotations.jsonl — adds caption (string).step_2_grounding_expr/annotations.jsonl — adds expressions[] (each {text, instances: [{bbox: [x1,y1,x2,y2]}]}).step_3_double_check/annotations.jsonl — same shape as Step 2, with bboxes removed/updated.results_dir/annotations.jsonl — copy of the last completed step's output.workflow.output_format is "legacy" or "both", each step also writes byte-compatible step_<N>_*/labels/<stem>.txt.stepN files for the original 2d-data-engine tooling.nvcr.io/nvidia/tao/tao-toolkit:7.2.0-pyt <!-- versions-key: images.tao_toolkit.pyt -->© NVIDIA, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 8 other files (references) in skills/tao-generate-referring-expressions of NVIDIA/skills.
Open the folder on GitHubat commit 14a98ae
Tao Generate Referring Expressions next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Tao Generate Referring Expressions this skillNVIDIA/skills | 3.6k | — | ~2.6k | Automated safety check: Notes | Apache-2.0 | |
| Reference Design Contractnexu-io/open-design | 100k | — | ~1.3k | Automated safety check: Pass | Apache-2.0 | |
| Makepad Referencesickn33/agentic-awesome-skills | 47k | 2 repos | ~573 | Automated safety check: Pass | MIT | |
| Matematico Taosickn33/agentic-awesome-skills | 47k | 2 repos | ~459 | Automated safety check: Pass | MIT | |
| Turn This Into A Threadsickn33/agentic-awesome-skills | 47k | 1 repos | ~1.4k | Automated safety check: Pass | MIT | |
| Write API Referencevercel/next.js | 143k | — | ~2.2k | Automated safety check: Pass | MIT |
nexu-io/open-design
Turn vague taste, screenshots, URLs, product notes, or "make it feel like this" references into a grounded DESIGN.md plus an implementation handoff.
sickn33/agentic-awesome-skills
This category provides reference materials for debugging, code quality, and advanced layout patterns.
sickn33/agentic-awesome-skills
Matemático ultra-avançado inspirado em Terence Tao. An agent skill from sickn33/agentic-awesome-skills.
sickn33/agentic-awesome-skills
Turn a long idea, transcript, article or draft into a Twitter/X thread where every tweet stands alone.
vercel/next.js
Produces API reference documentation for Next.js APIs: functions, components, file conventions, directives, and config options.
davila7/claude-code-templates
Format professional references properly and prepare reference materials.
NVIDIA/skills
A skill your agent uses when the user wants to deploy, run, debug, tear down, or call the REST API of the RTVI-CV 2D detection / tracking microservice.
NVIDIA/skills
Generates, validates, compares and explains HOLOLINK_def.svh macro files for the HSB IP, using bundled Python scripts and asking before it writes anything.
NVIDIA/skills
Runs and validates an end-to-end Mission Control demo in a locally installed Isaac Sim, with a Nova Carter robot driven through a Python server.
NVIDIA/skills
Orchestrates defect image generation for PCBA, metal surface and glass inspection with NVIDIA Cosmos AnomalyGen on OSMO, from cold-start Day 0 to real-photo Day 1 labeling.
NVIDIA/skills
Orchestrates video data augmentation and auto-labeling workflows on OSMO, from flow selection and preflight checks to submission, monitoring and output download.
NVIDIA/skills
Runs NVIDIA TAO Data Services KPI analysis on object detection results, comparing predictions to ground truth and writing per-class precision, recall and AP to a CSV.
Four-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified…. Tao Generate Referring Expressions is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Four-step image referring-expression pipeline: turns images plus KITTI bounding-box labels into region descriptions, scene captions, grounded referring expressions, and (optionally) verified expressions via VLM distillation.
Tao Generate Referring Expressions fits situations like: the user wants to generate referring-expression annotations from images with KITTI labels; build region descriptions; produce grouped grounding phrases tied to bboxes; run a double-check verification pass on grounding expressions.
Run `npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a claude-code`. Or copy the skill folder (skills/tao-generate-referring-expressions in NVIDIA/skills) into .claude/skills/tao-generate-referring-expressions in your project. Claude Code loads it when a task matches its description.
Run `npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a codex`. Or copy the skill folder (skills/tao-generate-referring-expressions in NVIDIA/skills) into .agents/skills/tao-generate-referring-expressions in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NVIDIA/skills --skill tao-generate-referring-expressions -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tao-generate-referring-expressions, .gemini/skills/tao-generate-referring-expressions, .github/skills/tao-generate-referring-expressions and .opencode/skills/tao-generate-referring-expressions in your project.
Going by SKILL.md and its folder, Tao Generate Referring Expressions needs credentials named GOOGLE_API_KEY. Our summary lists: Docker; A credential in GOOGLE_API_KEY. Its frontmatter pre-approves these tools: Read, Bash, Write. Compatibility (from SKILL.md): Requires docker + nvidia-container-toolkit + at least one VLM endpoint (Gemini API key or OpenAI-compatible)..
SKILL.md names 1 domain. In commands or code: inference-api.nvidia.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.
Tao Generate Referring Expressions is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.
About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.4k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Tao Generate Referring Expressions: Reference Design Contract (nexu-io/open-design, 100k stars), Makepad Reference (sickn33/agentic-awesome-skills, 47k stars), Matematico Tao (sickn33/agentic-awesome-skills, 47k stars) and Turn This Into A Thread (sickn33/agentic-awesome-skills, 47k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
NVIDIA (a GitHub organization, an official publisher) maintains it in NVIDIA/skills, which has 3,555 GitHub stars. The repository holds 390 skills in this directory. The repository was last updated on October 9, 2026.
Source: NVIDIA/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.