Tao Token Efficient Execution

NVIDIAOfficialCreated by NVIDIA Corporation

Skill
Workflow
Agent tooling
Apache-2.0
Medium risk
Has scripts

From the author

Token-efficient execution kit for repeated TAO agentic workflows. Compiles a skill into stage cards once (with a strong model), then executes them forever in fresh, small headless sessions coordinated by a bash driver — measured 67-91% token reduction and 3-5x lower peak context vs one long conversation. Use when a TAO workflow will be run repeatedly, when token cost matters, when the target model has a small context window, or on trigger phrases like "token efficient", "reduce token cost", "card pack", "stage cards", "run this workflow on a small model", "compile this skill into cards".

— the description by NVIDIA Corporation

AutoGineer summary

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

The TAO Token-Efficient Execution kit optimizes agentic workflows by replacing long, context-heavy conversations with a series of fresh, stateless headless sessions. By compiling a skill into discrete 'stage cards' using a strong model, the system enables smaller, more cost-effective models to execute complex tasks reliably. State is maintained on disk rather than in chat history, significantly reducing token consumption and context window pressure. The kit includes a bash-based driver for orchestration, harness adapters for tool interception, and a structured contract for state management.

What it does

Compiles complex agentic workflows into a series of discrete, stateless stage cards.
Executes workflows using fresh agent sessions to minimize context window usage.
Maintains persistent state on disk through a defined contract, avoiding reliance on chat history.
Uses a bash driver to manage stage routing, job waiting, and error handling.
Provides harness adapters to record executed commands and guard against known failure modes.
Enables the use of smaller, more efficient models for executing pre-compiled workflows.

When to use it

When a specific agentic workflow needs to be run repeatedly.
When reducing token costs and context window usage is a priority.
When the target model has a limited context window.
When you need to ensure deterministic execution of a multi-stage process.
When you want to avoid the performance degradation associated with long, single-session conversations.

Advantages

Significant reduction in token consumption (measured 67-91% reduction).
Lower peak context requirements (3-5x reduction).
Improved reliability by using pre-compiled, verified stage cards.
Stateless execution prevents model drift and context-related errors.
Clear separation between the one-time compilation cost and the efficient execution phase.

Usage examples

“Compile this skill into cards for token-efficient execution.”: The agent reads the skill and workspace, then generates a set of stage cards and a driver configuration to enable stateless, low-token execution.
“Run this workflow on a small model using the card pack.”: The bash driver initiates the workflow, executing one stage card per session and managing state via on-disk contracts.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/tao-token-efficient-execution/download

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

mkdir -p .agents/skills && unzip tao-token-efficient-execution.zip -d .agents/skills

Documentation by NVIDIA Corporation

TAO Token-Efficient Execution

Run a staged TAO workflow as a series of fresh headless agent sessions — one stage card per session — instead of one long conversation. State lives on disk, never in chat history, so no session ever rereads the run's past.

Measured on real workflows (same tasks, same outcomes, billed tokens):

Workflow	One long conversation	Card execution	Peak context
DEFT AOI loop	9.6M	2.5M (-74%)	242k → 59k
AutoML (VCN classify)	5.8M	0.5M (-91%)	198k → 42k
HuggingFace finetune	1.7M	0.5M (-67%)	119k → 42k

The mechanism: an agent API is stateless, so a long conversation resends its entire history with every message — by mid-run that is ~100k+ tokens of skill text, spec edits, and training logs reread on every tool call, of which the current step needs ~3k. Cards make each step's 3k explicit and drop the rest.

The three layers

Core (harness-agnostic) — stage cards (markdown, env-var contract), a bash driver (stage routing + job waiting), and on-disk state contracts (references/CONTRACTS.md).
Harness adapters (adapters/) — guard + recorder implemented per harness: hooks for Claude Code, extensions for Pi. Same logic, ~150 lines each. Guards block known dead ends before tokens are burned; the recorder appends executed commands to commands.log so later sessions reuse instead of re-derive.
Card packs (per application skill) — compiled cards living next to the skill they were authored from, e.g. skills/applications/tao-run-deft-aoi/cards/ and skills/applications/tao-run-automl/cards/. Each pack ships its own driver.sh and README.md (version pin, required env, how to run).

Cards shrink the model's job; they don't remove it. The driver owns routing and waiting (deterministic), helper scripts own state commits (deterministic), and the model executes one pre-planned stage: run verbatim commands, read a gate table, decide pass/fail from real output, fill in the one dynamic value. If a stage ever becomes 100% deterministic, graduate it out of the card into the driver or a helper script.

Quick start — run a shipped card pack

# plugin installs export TAO_SKILL_BANK_PATH automatically; standalone users set it first:
export TAO_SKILL_BANK_PATH=/path/to/tao-skill-bank

# one-time: scaffold ~/.tao-kit/kit.env and check harness prerequisites
bash "$TAO_SKILL_BANK_PATH/skills/core/tao-token-efficient-execution/scripts/install.sh"

# edit ~/.tao-kit/kit.env: set WS (and VENV for the AutoML pack) and MODEL;
# export your provider's API key in your shell — never put it in kit.env.
# then launch a pack driver detached (leave stderr attached: config errors print immediately):
nohup bash "$TAO_SKILL_BANK_PATH/skills/applications/tao-run-automl/cards/driver.sh" > /dev/null &

# monitor
tail -f ~/.tao-kit/automl/driver.log

The driver waits while jobs run (activity-based, not process-based), fires one fresh session per stage, halts on committed errors (no auto-retry — an operator decides), and exits 0 only after verified completion. DEFT prepares its inference handoff and passes the completion audit; AutoML requires its DONE marker with no trailing failure. Round-cap exhaustion exits nonzero.

Starting a pack driver is side-effecting work: complete the tao-launch-workflow gate (platform, credentials, image, datasets, launch review) before launching it, exactly as for in-conversation execution. Pi guards are not an OS sandbox: use an isolated trusted worker, not a workstation containing unrelated credentials (see adapters/pi/README.md).

Quick start — author a pack for another workflow

One authoring session with a strong model compiles the skill into cards (measured: ~10 minutes, one-time cost; every later run executes them):

Read references/authoring_prompt.md (the round-0 contract) and references/authoring_prompt_v2.md (rules distilled from measured small-model failures: one command per step, mechanical state gates, exact artifact paths, explicit termination, bounded self-repair).
Fill in run parameters — everything concrete for the target machine. Whatever you leave out, execution sessions will burn tokens rediscovering.
The authoring session reads the skill + inspects the workspace + writes cards into skills/applications/<skill>/cards/. It must NOT run the workflow.
Copy a shipped pack's driver.sh and edit its three config points: the stage→card routing table, the working() predicate, and the paths block. (templates/driver.template.sh is the harness-portable skeleton.)

references/CARD_AUTHORING.md reconstructs a real authoring session play by play.

Model floor (measured, execute-side)

Authoring always needs a strong model. Execution was measured across sizes:

Model class	Card execution	Notes
Frontier (e.g. Claude)	flawless	reference bar: 0 guard fires, clean labels
~400B MoE	near-flawless	correct results; a few guard saves
~35B MoE	workflow-dependent	AutoML clean end-to-end; DEFT completed but with sloppy stage labels
~30B dense w/o tool discipline	below floor	fabricated results, loops; guards catch but cannot fix

Raw-skill execution (no cards) did not complete honestly on ANY of the small models measured — aborts, protocol violations, or falsely declared success. Cards are what make small-model execution possible, not a minor optimization.

Report, don't patch: when an execution model fails a card, report it and stop (the driver's no-auto-retry halt enforces this). Never edit cards or state to cover a model's mistakes; only genuine card-authoring defects get fixed, explicitly.

Files

Path	What
`references/CONTRACTS.md`	progress log, STAGE_DONE, commands.log, env contract
`references/authoring_prompt.md` / `_v2.md`	card compilation prompts
`references/CARD_AUTHORING.md`	a real authoring session, annotated
`templates/driver.template.sh`	driver skeleton (three config points)
`templates/kit.env.template`	per-host config (`~/.tao-kit/kit.env`)
`adapters/pi/`, `adapters/claude-code/`	guard + recorder per harness
`scripts/install.sh`	prerequisite check + kit.env scaffold
`scripts/analyze_usage.py`	per-session token accounting from session JSONL
`scripts/smoke_test.sh`	no-GPU adapter test (guard, recorder, accounting)

Files

ATTRIBUTION.mdAdded by AutoGineer957 B
BENCHMARK.md7.3 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md7.4 KiB
adapters/claude-code/README.md1.3 KiB
adapters/claude-code/hooks/guard.template.shScript1.1 KiB
adapters/claude-code/hooks/record.template.shScript860 B
adapters/claude-code/settings.template.json905 B
adapters/pi/README.md3.7 KiB
adapters/pi/guard.tsScript10.5 KiB
adapters/pi/nvidia-provider.tsScript4.9 KiB
adapters/pi/recorder.tsScript3.8 KiB
config/skillspector-baseline.yaml2.0 KiB
evals/evals.json2.8 KiB
references/CARD_AUTHORING.md4.4 KiB
references/CONTRACTS.md4.4 KiB
references/authoring_prompt.md2.2 KiB
references/authoring_prompt_v2.md3.0 KiB
scripts/analyze_usage.pyScript6.0 KiB
scripts/install.shScript2.8 KiB
scripts/smoke_test.shScript4.6 KiB
skill-card.md5.5 KiB
skill.oms.sig8.8 KiB
templates/driver.template.shScript5.2 KiB
templates/kit.env.template1.8 KiB

BENCHMARK.md

Skill Benchmark: tao-token-efficient-execution

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

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

Evaluation Metadata

Skill: tao-token-efficient-execution
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: 2 evaluation tasks (2 positive)
Dataset digest: sha256:ebb8fd6d9ad84d574915ae829c70455cf26bfbbdbb47e37741290fe1974316e3 (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	92.1% — baseline ran, but no comparable score was available; uplift unavailable	59.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)	20.0% → 60.0% (+40.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	0.0% → 82.5% (+82.5 points)	10.0% → 40.0% (+30.0 points)
Efficiency	77.9% — baseline ran, but no comparable score was available; uplift unavailable	99.5% → 98.5% (-1.0 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	318,141	623,838	-305,697	-49.00%	skill 2/2; base 2/2
claude-code	tao-token-efficient-execution-routing	65,602	290,079	-224,477	-77.38%	skill 1/1; base 1/1
claude-code	tao-token-efficient-execution-run-pack	252,539	333,759	-81,220	-24.33%	skill 1/1; base 1/1
codex	All cases	27,996	28,012	-16	-0.06%	skill 2/2; base 2/2
codex	tao-token-efficient-execution-routing	13,936	14,136	-200	-1.41%	skill 1/1; base 1/1
codex	tao-token-efficient-execution-run-pack	14,060	13,876	+184	+1.33%	skill 1/1; base 1/1
ALL AGENTS	Dataset aggregate	346,137	651,850	-305,713	-46.90%	skill 4/4; base 4/4

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); 28 finding(s)
Tier 2	Semantic deduplication	PASSED	2 validator(s); 0 finding(s)
Tier 3	Live agent evaluation	PASS	2 agent(s); 2 task(s)

Findings and Observations

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

MEDIUM QUALITY/quality_correctness: No documented scripts in table format (skills/core/tao-token-efficient-execution/SKILL.md)
MEDIUM QUALITY/quality_correctness: Instructions don't mention 'run_script' (skills/core/tao-token-efficient-execution/SKILL.md)
MEDIUM QUALITY/quality_correctness: SKILL_SPEC recommended field missing: 'metadata.tags' (skills/core/tao-token-efficient-execution/SKILL.md)
MEDIUM SCHEMA/frontmatter_field_placement: Root field 'tags' is ignored; use 'metadata.tags' (skills/core/tao-token-efficient-execution/SKILL.md)
MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/core/tao-token-efficient-execution)
23 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 an API key, Needs Python, Needs Node.js

The author says: Requires bash, jq, Python 3.10+, and a headless agent harness with tool interception (see adapters/ for supported versions). The shipped card packs additionally need docker and the prerequisites of their application skill.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
References to credential files
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-token-efficient-execution · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

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

Synced

2026-11-08

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-token-efficient-execution.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by NVIDIA Corporation

TAO Token-Efficient Execution

The three layers

Quick start — run a shipped card pack

Quick start — author a pack for another workflow

Model floor (measured, execute-side)

Files

Files

BENCHMARK.md

Skill Benchmark: tao-token-efficient-execution

Publication Recommendation

Evaluation Metadata

What This Report Answers

Results at a Glance

Token Usage

Tier Status

Findings and Observations

Scoring Methodology

Freshness

Requirements and compatibility

Security

Attribution and licence

Related skills

Handoff

Chief Of Staff

Ask Matt

Claude Handoff

Executing Plans

Using Superpowers

Download ZIP