I4h Workflow Finetune

NVIDIAOfficialCreated by Isaac for Healthcare TeamDistributed by NVIDIA

Skill
Workflow
Data and AI
Apache-2.0
Medium risk

From the author

Fine-tune a manifest-backed GR00T or openpi remote Task on compatible LeRobot data. Use for training; do not use for inference-only Tasks or checkpoint rollout.

— the description by Isaac for Healthcare Team

AutoGineer summary

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

This skill provides a structured procedure for fine-tuning robotic policy tasks within the Isaac for Healthcare framework. It guides the user through resolving workflow dependencies, verifying dataset compatibility, performing dry-run configuration checks, executing the training process, and validating the resulting checkpoint through a load-smoke test. The workflow ensures that training parameters are preserved exactly as requested and that the final artifacts are verified for usability.

What it does

Resolves base checkouts, policy modes, and remote task manifests.
Verifies LeRobot dataset compatibility with the target task.
Executes a dry-run to validate configuration settings before training.
Performs foreground training with specified hyperparameters.
Conducts a bounded load-smoke test to verify checkpoint integrity.
Reports detailed training outcomes, disk usage, and validation status.

When to use it

When you need to fine-tune a GR00T or openpi remote task.
When you have a compatible LeRobot dataset ready for training.
When you need to ensure training configurations are validated before execution.
When you must verify that a trained checkpoint is loadable by the inference backend.

Advantages

Ensures configuration consistency by requiring exact parameter preservation.
Prevents deployment of broken checkpoints via mandatory load-smoke testing.
Provides a clear, repeatable process for managing complex robotic training workflows.
Integrates validation steps to confirm artifact usability post-training.

Usage examples

“Fine-tune the current task for 200 steps with a batch size of 32 and turn off vision tuning.”: The agent will perform a dry-run with the specified parameters, apply the GR00T vision flag, execute the training, perform a load-smoke test, and report the final checkpoint path.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/i4h-workflow-finetune/download

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

mkdir -p .agents/skills && unzip i4h-workflow-finetune.zip -d .agents/skills

Documentation by Isaac for Healthcare Team

Fine-tune a Workflow Policy Task

Purpose

Resolve and run training from the selected workflow run mode and owning remote-task manifest.

Instructions

Resolve the base checkout, policy mode, and remote task.
Verify dataset compatibility and a train block.
Dry-run the exact configuration.
Train in the foreground and verify checkpoint artifacts.

Resolve the workflow, task, and data

export I4H_WORKFLOWS_REPO_URL="${I4H_WORKFLOWS_REPO_URL:-https://github.com/isaac-for-healthcare/i4h-workflows}"
I4H_REPO_DIR_NAME="${I4H_WORKFLOWS_REPO_URL%/}"
I4H_REPO_DIR_NAME="${I4H_REPO_DIR_NAME##*/}"
I4H_REPO_DIR_NAME="${I4H_REPO_DIR_NAME##*:}"
I4H_REPO_DIR_NAME="${I4H_REPO_DIR_NAME%.git}"
[ -n "$I4H_REPO_DIR_NAME" ] || { echo "Cannot derive a checkout name from I4H_WORKFLOWS_REPO_URL" >&2; exit 2; }
ROOT="${I4H_WORKFLOWS:-$(git rev-parse --show-toplevel 2>/dev/null)}"
if [ ! -d "$ROOT/workflows/i4h_workflows" ]; then
  ROOT="${I4H_WORKFLOWS:-$HOME/$I4H_REPO_DIR_NAME}"
  [ -d "$ROOT/workflows/i4h_workflows" ] || git clone "$I4H_WORKFLOWS_REPO_URL" "$ROOT"
fi
export I4H_WORKFLOWS="$ROOT"
cd "$ROOT"
./run.sh list
./run.sh show <workflow> --mode <policy-mode>
test -f /absolute/path/to/dataset/meta/info.json
nvidia-smi

Treat the resolver above as part of the skill contract: a hosted copy may run outside the base repository, so never assume the current checkout contains workflows/i4h_workflows. I4H_WORKFLOWS_REPO_URL selects the clone source. When I4H_WORKFLOWS is unset, derive the fallback directory from that URL; set I4H_WORKFLOWS only to reuse or choose a specific destination. Never replace an existing checkout.

Read the selected workflow run mode to identify its remote task id. Open tasks/<project>/i4h_tasks/<project>/manifest/<task>.yaml and require train:. Resolve the project, entry point, base model/config, output defaults, and modality contract from that manifest and the project's train.py.

Use the current-chain LeRobot dataset when the prompt omits a path. Verify its embodiment, cameras, task text, feature widths, and episode count are compatible with the remote task.

Resolve configuration before a long run

All policy train entry points support --dry-run:

uv run --project "tasks/<project>" "i4h-tasks-<project-with-hyphens>-train" \
  --task <project>/<task> \
  --dataset /absolute/path/to/dataset \
  --output-dir /absolute/path/to/checkpoints \
  --max-steps <N> \
  --batch-size <N> \
  --dry-run

Inspect the resolved config. Keep user-requested steps, batch size, model/config, and GPU count exact.

For GR00T, “turn off vision tuning” maps to --no-tune-visual. Do not pass that flag to openpi, whose CLI does not expose it. Use only flags present in the selected project's current train.py.

Train

Remove --dry-run and keep the command in the foreground:

uv run --project "tasks/<project>" "i4h-tasks-<project-with-hyphens>-train" \
  --task <project>/<task> \
  --dataset /absolute/path/to/dataset \
  --output-dir /absolute/path/to/checkpoints \
  --max-steps <N> \
  --save-steps <N> \
  --batch-size <N> \
  --num-gpus <N>

Add backend-specific flags only after resolving them. Do not silently lower requested steps or batch size to make training fit.

Verify

Require exit status 0, completed requested steps, saved training logs, and at least one loadable checkpoint artifact. Resolve the exact checkpoint path rather than calling an incomplete output directory a checkpoint.

Run a bounded backend load smoke before reporting the checkpoint usable:

uv run --project "tasks/<project>" python -m "<project>.server" \
  --namespace "checkpoint-smoke-$$" \
  --preload <project>/<task> \
  --checkpoint /absolute/path/to/checkpoint \
  --preload-only

Use the selected project's actual module path. --preload-only loads the manifest and checkpoint through the inference backend, then exits without starting a rollout. A training exit alone proves that files were written, not that inference can load them.

Report du -sh for the task output and the selected checkpoint. Some trainers save both a final model at the output root and numbered checkpoints; identify that duplication, but do not delete either copy unless the user explicitly asks for cleanup.

Hand the exact load-smoked checkpoint path to i4h-workflow-validate; do not evaluate unless the user requested it.

Troubleshooting

Report the first dataset, manifest, model-access, GPU-memory, or backend error. Preserve logs and never silently change requested hyperparameters.

Prerequisites

Require a compatible LeRobot dataset, synced policy environment, model access, GPU capacity, and a remote-task manifest with train:.

Limitations

Inference-only Tasks cannot be fine-tuned, and this skill does not claim rollout success from training alone.

Examples

Fine-tune for 200 steps with a batch size of 32. Turn off vision tuning. → preserve exact values, apply GR00T's supported vision flag, dry-run, train, and report the checkpoint.

Completion gate

Report workflow/mode, task id and manifest, dataset compatibility, resolved config, requested/completed steps, batch/GPU/vision settings, checkpoint path, bounded load-smoke result, output/checkpoint disk sizes, exact validation handoff, exit summary, and any inference-only or resource blocker.

Files

ATTRIBUTION.mdAdded by AutoGineer940 B
BENCHMARK.md6.7 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md5.7 KiB
evals/evals.json1.7 KiB
skill-card.md3.9 KiB
skill.oms.sig4.5 KiB

BENCHMARK.md

Skill Benchmark: i4h-workflow-finetune

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

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

Evaluation Metadata

Skill: i4h-workflow-finetune
Evaluation date: 2026-09-21
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:b170a81b7e415375da232ea323fc52b67bb8b05c5682e964f08a4882fc8d6964 (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

Measure	Claude Code (Baseline → Skill Uplift)	Codex (Baseline → Skill Uplift)
Overall	75.2% — baseline ran, but no comparable score was available; uplift unavailable	60.9% — baseline ran, but no comparable score was available; uplift unavailable
Security	100.0% → 100.0% (±0.0 points)	100.0% → 25.0% (-75.0 points)
Correctness	10.0% → 70.0% (+60.0 points)	3.3% → 100.0% (+96.7 points)
Discoverability	95.0% — baseline ran, but no comparable score was available; uplift unavailable	81.3% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness	5.0% → 35.0% (+30.0 points)	5.0% → 28.8% (+23.8 points)
Efficiency	76.1% — baseline ran, but no comparable score was available; uplift unavailable	69.5% — baseline ran, but no comparable score was available; uplift unavailable

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.

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	845,074	1,471,217	N/A	N/A	skill 2/2; base 6/6
claude-code	i4h-workflow-finetune-readme-quick-steps-batch	465,058	613,913	N/A	N/A	skill 1/1; base 3/3
claude-code	i4h-workflow-finetune-table-short-smoke	380,016	857,304	N/A	N/A	skill 1/1; base 3/3
codex	All cases	2,055,132	754,442	N/A	N/A	skill 4/4; base 6/6
codex	i4h-workflow-finetune-readme-quick-steps-batch	806,550	307,407	N/A	N/A	skill 2/2; base 3/3
codex	i4h-workflow-finetune-table-short-smoke	1,248,582	447,035	N/A	N/A	skill 2/2; base 3/3
ALL AGENTS	Dataset aggregate	2,900,206	2,225,659	N/A	N/A	skill 6/6; base 12/12

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); 2 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>

LOW QUALITY/quality_reliability: Inputs are used but no dedicated Inputs section is documented (team-skills/holoscan/i4h-workflows/i4h-workflow-finetune/SKILL.md)
LOW SECURITY/Unknown (SQP-2): The skill automatically clones an external GitHub repository into the user's home directory (~/$I4H_REPO_DIR_NAME) witho (SKILL.md:39)

</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: Needs Python

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

Isaac for Healthcare Team

Publisher

NVIDIA (Official)

Distributed by

NVIDIA

Source

NVIDIA/skills · skills/i4h-workflow-finetune · 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 Isaac for Healthcare Team or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download i4h-workflow-finetune.zip