Official agent skill

Jetson Generate Kb

by NVIDIA in NVIDIA/skills

Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree.

OfficialApache-2.0Auto-check passedKnowledge Management

Install Jetson Generate Kb

skills CLI
$ npx skills add NVIDIA/skills --skill jetson-generate-kb -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install NVIDIA/skills jetson-generate-kb --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/jetson-generate-kb .claude/skills/jetson-generate-kb && rm -rf skills-src

Use ~/.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/

Facts

Skill name
jetson-generate-kb
GitHub stars
3.5k
Token cost
~3.8k tokens
SKILL.md length
1,261 words
Files
5
Skills in repo
380
Repo updated
First seen
Licence
Apache-2.0

At a glance

Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree.

  • Works in 3 steps: BSP image layout — top-level directories… → Source tree layout — top-level subtrees… → Documents — the documents.* references…
  • Tasks that involve GPU and accelerator computing
  • SKILL.md covers Overview, When to invoke, Procedure and Gotchas, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Jetson Generate Kb is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree. Use after init-image / init-source; not for editing profile fields.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files (for example `BENCHMARK.md`, `evals/evals.json` and `skill-card.md`).

It sits in Knowledge Management, covering GPU and accelerator computing and Knowledge bases. It works with NVIDIA AI Platform. 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.

When your agent uses it

  • Tasks that involve GPU and accelerator computing
  • Tasks that involve Knowledge bases

Example prompts

  • “/jetson-generate-kb”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. BSP image layout — top-level directories under
  2. Source tree layout — top-level subtrees under
  3. Documents — the documents.* references recorded in the

What it can do on your machine

Read from SKILL.md and the folder at commit 67a13c0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Jetson Generate Kb loads about 3.8k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 1,261 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~49
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k

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.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated 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.

SKILL.md

The full file from NVIDIA/skills at commit 67a13c0, republished under its Apache-2.0 licence (© NVIDIA). 1,261 words, ~3,775 tokens.

Download SKILL.mdSave it as .claude/skills/jetson-generate-kb/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
jetson-generate-kb
description
Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree. Use after init-image / init-source; not for editing profile fields.
version
0.0.1
license
Apache-2.0
metadata.data-classification
public
metadata.author
Jetson Team
metadata.tags
target-platform, knowledge-base, documentation, meta
metadata.domain
meta

Generate Target Knowledge Base

Overview

This skill produces a per-profile markdown reference at target-platform/<profile-stem>.md (sibling to the profile YAML). It bundles three things into one file so a future Claude session — or the user — can see the shape of the active target without re-walking the filesystem:

  1. BSP image layout — top-level directories under bsp_image.root_path, presence of canonical subtrees (rootfs/, bootloader/, source/, …), and the nvpmodel variants matching the active module SKU.
  2. Source tree layout — top-level subtrees under source.root_path (kernel-jammy-src/, hardware/nvidia/, nvidia-oot/, etc.) and devicetree files matching the chip family.
  3. Documents — the documents.* references recorded in the profile, with local-path existence checks and one-line descriptions.

The KB is a snapshot, dated in its header. Re-run this skill whenever the underlying data changes — it is intentionally re-runnable and overwrites the previous KB on each run.

When to invoke

  • After jetson-init-image prepares the BSP for a freshly authored profile.
  • After re-extracting a BSP archive or applying patches under bsp_image.root_path.
  • After updating the source tree at source.root_path.
  • After editing bsp_image.* or documents.* in the profile YAML.
  • When a downstream skill asks "where is X in this BSP?" and you'd rather check the KB than re-walk the tree.

Procedure

Resolve the active target

Resolve the active profile per the contract in ../../context/target-platform-contract.md; cache it in memory — the rest of the skill consumes only this profile. Record <profile-stem> (the bare filename minus .yaml) as the KB output filename stem.

Validate inputs
FieldRequired for KB?If missing
bsp_image.root_pathyesRefuse. A KB with no BSP root to scan is just a YAML restatement; tell the user to run jetson-init-image or hand-edit the profile.
source.root_pathnoSkip the source-tree section; note "source_root not recorded" in the KB.
documents.*noRender an empty Documents table with a "no documents recorded" note.

If bsp_image.root_path is set but the directory does not exist on disk, refuse with a clear message — do not fabricate a layout for a path that isn't there.

BSP discovery (under bsp_image.root_path)

Run only the following cheap operations — no recursive scans, no file content reads beyond directory listings:

  1. ls -1 of bsp_image.root_path (one level deep). Record which directories are present.
  2. For each canonical subtree below, mark present/absent: rootfs/, bootloader/, kernel/, source/, tools/, nv_tegra/.
  3. Verify the active flash_config file exists at <bsp_image.root_path>/<flash_config>. Record its path or (missing).
  4. List rootfs/etc/nvpmodel/ and filter to filenames matching nvpmodel_<module.id>_<module.sku>*.conf. Record each match. Use the lower-case module id (e.g. p3767) and the YAML-quoted sku string (e.g. 0001).
Source tree discovery (under source.root_path)

Skip this step entirely if source.root_path is NA or missing. Otherwise, run only:

  1. ls -1 of source.root_path (one level deep).
  2. For each canonical subtree below, mark present/absent: kernel-jammy-src/, hardware/nvidia/, nvidia-oot/, nvgpu/, nvethernetrm/, nvdisplay/, hwpm/, kernel-devicetree/.
  3. If kernel-devicetree/generic-dts/dts/ exists, list filenames matching tegra<chip>* where <chip> is the chip-family numeric prefix (see chip-family map below). Record up to 30 hits; if more, record the count and a "showing first 30" note.
Chip-family map (used in the "BSP discovery" and "Source tree discovery" steps)

Derive <chip> from module.id:

module.idChip family<chip> prefix
p3701, p3767T234 — Orin234
p3834T264 — Thor264

If module.id is not in this table, record the chip as unknown (module.id=<value>) and skip the chip-prefixed devicetree filter.

Documents pass

For each field in documents.* from the loaded profile:

  1. Classify the value as URL (starts with http://, https://, or ftp://) or local path (anything else).
  2. For URLs: record verbatim. Do not fetch the URL — KB generation must remain offline. (A future skill can promote to deep indexing.)
  3. For local paths: check os.path.exists. Record the path; if missing on disk, append (missing).

The one-line description for each field comes from the marker in ../../references/platform_template.yaml — strip the <OPTIONAL: …> wrapper and use the inner text.

If the profile has no documents: block, render the section with a single line: _No documents recorded — run jetson-link-docs or hand-edit the profile to add references._

Render and write the KB

Render the markdown using the structure below. Use today's date (YYYY-MM-DD) in the header. Always overwrite any existing KB file at the destination — do not prompt before overwriting; re-runs are the intended use.

Destination: target-platform/<profile-stem>.md.

Rendered structure
markdown
# Target knowledge base — <profile-stem>

> Generated <YYYY-MM-DD> from `<bsp_image.root_path>` (BSP version `<bsp_image.version>`).
> Re-run `jetson-generate-kb` after extracting a new BSP, applying
> patches, or editing profile fields. This file is a regenerated
> snapshot — do not hand-edit.

## Profile facts

- **Reference devkit:** `<reference_devkit.name>`
- **Module:** `<module.id>-<module.sku>` (`<chip family label>`)
- **Reference carrier:** `<carrier.id>-<carrier.sku>`
- **Custom carrier:** `<custom_carrier.name>` (`<custom_carrier.id>-<custom_carrier.sku>`)  _← omit this row if Case 1_
- **Active flash conf:** `<flash_config>`
- **BSP path:** `<bsp_image.root_path>`
- **BSP version:** `<bsp_image.version>`
- **Source root:** `<source.root_path>`  _← or "_not recorded_" if NA_

## BSP image layout

Top-level directories under `<bsp_image.root_path>`:

| Directory | Present | Purpose |
|---|---|---|
| `rootfs/`     | ✓ / ✗ | userspace rootfs (nvpmodel, nvfan, systemd units, etc.) |
| `bootloader/` | ✓ / ✗ | firmware blobs, BCT, MB1/MB2 dts |
| `kernel/`     | ✓ / ✗ | prebuilt kernel + modules |
| `source/`     | ✓ / ✗ | BSP source tree (kernel, OOT drivers, DT) |
| `tools/`      | ✓ / ✗ | flashing helpers, jetson-io, kernel_flash |
| `nv_tegra/`   | ✓ / ✗ | nvidia firmware tarballs, kernel-supplements |

Active flash conf `<flash_config>`: present at
`<bsp_image.root_path>/<flash_config>` _or_ `(missing — verify before flashing)`.

### nvpmodel files matching the active SKU

Filtered from `rootfs/etc/nvpmodel/` by `nvpmodel_<module.id>_<module.sku>*.conf`:

- `<each match, one per line>`

The active variant at boot is selected by `nvpower.sh` from
`/proc/device-tree/compatible` plus super / safety state — see
`jetson-customize-nvpmodel` for the resolution rules.

## Source tree layout

(omit this whole section if `source.root_path` is `NA`/missing)

Top-level subtrees under `<source.root_path>`:

| Subtree | Present | Purpose |
|---|---|---|
| `kernel-jammy-src/`   | ✓ / ✗ | mainline 5.x kernel sources |
| `hardware/nvidia/`    | ✓ / ✗ | NVIDIA platform DTs (per chip family) |
| `nvidia-oot/`         | ✓ / ✗ | NVIDIA out-of-tree kernel modules |
| `nvgpu/`              | ✓ / ✗ | GPU driver |
| `nvethernetrm/`       | ✓ / ✗ | ethernet driver |
| `nvdisplay/`          | ✓ / ✗ | display driver |
| `hwpm/`               | ✓ / ✗ | hardware performance monitor |
| `kernel-devicetree/`  | ✓ / ✗ | devicetree sources |

### Devicetree files for chip family `<chip>`

(omit if `kernel-devicetree/generic-dts/dts/` is absent)

Files matching `tegra<chip>*` under `kernel-devicetree/generic-dts/dts/`:

- `<each match, one per line — cap at 30, then a "first 30 of N" note>`

## Documents

| Field | Reference |
|---|---|
| Documents root folder                    | `<doc_root>`                    _or_ _not recorded_ |
| BSP / Jetson Linux developer guide       | `<bsp_developer_guide>`         _or_ _not recorded_ |
| Tegra SoC Technical Reference Manual     | `<soc_tech_ref_manual>`         _or_ _not recorded_ |
| Jetson module data sheet                 | `<module_data_sheet>`           _or_ _not recorded_ |
| Jetson module design guide (PDG)         | `<module_design_guide>`         _or_ _not recorded_ |
| Jetson module thermal design guide (TDG) | `<module_thermal_design_guide>` _or_ _not recorded_ |
| Jetson module schematic                  | `<module_schematic>`            _or_ _not recorded_ |
| Reference carrier board specification    | `<carrier_board_spec>`          _or_ _not recorded_ |
| Reference carrier schematic              | `<carrier_schematic>`           _or_ _not recorded_ |
| Custom carrier schematic                 | `<custom_carrier_schematic>`    _or_ _not recorded / N/A (no custom carrier)_ |
| Reference-devkit pinmux spreadsheet      | `<ref_devkit_pinmux_xls>`       _or_ _not recorded_ |
| Custom-carrier pinmux spreadsheet        | `<custom_carrier_pinmux_xls>`   _or_ _not recorded / N/A (no custom carrier)_ |

(Local paths are tagged ` (missing)` if absent on disk. URLs are
recorded verbatim and not fetched. If `doc_root` is set, also tag
` (missing)` on it if the directory itself is gone — that signals
auto-mapping in `jetson-link-docs` won't work on a re-run.)

## How to refresh this file

Re-run `jetson-generate-kb` whenever any of the following changes:

- the BSP at `<bsp_image.root_path>` is re-extracted, patched, or upgraded,
- the source tree at `<source.root_path>` changes,
- the active profile's `bsp_image.*` or `documents.*` fields are edited.

This file is overwritten on every run. Do not hand-edit it — edit the
source data (profile YAML or the BSP tree) and re-run instead.
Confirm

Print a short summary:

  • Output path: target-platform/<profile-stem>.md.
  • BSP top-level directory count and which canonical subtrees were present / absent.
  • nvpmodel match count for the active SKU.
  • Source-tree section: rendered or skipped (and why).
  • Documents: count of recorded fields, count of local paths flagged (missing).

If a downstream skill triggered this run, tell the user to re-issue their original request.

Show full SKILL.md (512 more words)Show less

Gotchas

  • The KB is a snapshot, not a live view. The dated header is authoritative — if it doesn't match today, the BSP/source/docs may have changed underneath. Re-run on demand.
  • Always overwrites. No prompt before clobbering the previous KB at target-platform/<profile-stem>.md. This is intentional — re-runnability is the whole point. Tell the user not to hand-edit the file; edit profile YAML or the BSP and regenerate.
  • Refuses on bsp_image.root_path = NA. A profile with no BSP path produces a content-free KB. Do not write one — instead, point the user at the profile YAML to fill in.
  • No URL fetching. Document URLs are recorded verbatim. Promoting to deep indexing (HTTP HEAD, PDF parsing) is out of scope for v0.1.
  • No recursive scans. Discovery is one level deep per directory, with at most one targeted glob (nvpmodel + devicetree). Never walk the entire BSP — it's huge and slow.
  • Cap devicetree listings at 30 entries to keep the KB readable. Show "first 30 of N" when truncating.
  • Don't auto-invoke from setup skills. Setup may suggest running this skill in its summary, but the user opts in. Auto-running hides the I/O step and surprises users whose BSP/doc paths are incomplete.
  • Filename collision risk. The KB sits at target-platform/<stem>.md next to <stem>.yaml. Don't accidentally read .md files in the profile-listing logic of jetson-set-target (it already filters to *.yaml, but check before adding new file types).
  • Chip-family map is short. If a future module SKU is added that isn't in the map, the devicetree filter step is skipped — the KB will note chip: unknown rather than fabricate a <chip> prefix. Update this skill's chip-family table when a new chip lands.

Prerequisites

  • Active target profile resolved per ../../context/target-platform-contract.md.
  • bsp_image: recorded by /jetson-init-image; this is the only required on-disk tree. If source.root_path is missing, render the KB without the source-tree section.
  • Optional: /jetson-init-source already resolved source: when the user wants source-tree discovery included.
  • Optional but recommended: /jetson-link-docs already wrote the documents: block.

Limitations

  • Read-only against the BSP and source trees; never edits the profile YAML or rewrites source files.
  • Devicetree-file enumeration depends on the chip-family table inside this skill; an unknown module SKU lands in the KB as chip: unknown rather than a fabricated prefix.
  • Filename layout is fixed at target-platform/<stem>.md to stay next to the profile YAML; renaming the YAML invalidates the link.

Troubleshooting

  • bsp_image.root_path not found — re-run /jetson-init-image so the BSP is extracted and the path is recorded before regenerating the KB.
  • Source tree walk picks up wrong subtrees — source.root_path override is stale; rerun /jetson-init-source or correct the profile field.
  • documents: block missing from the KB — /jetson-link-docs was never run; the KB falls back to "no documents bound" rather than guessing paths.
  • Devicetree section short / empty — chip-family table doesn't cover the active SoC; update the table and rerun.

References

© 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

Files

SKILL.md and 4 other files in skills/jetson-generate-kb of NVIDIA/skills.

  • SKILL.md
  • BENCHMARK.md
  • evals/evals.json
  • skill-card.md
  • skill.oms.sig

Open the folder on GitHubat commit 67a13c0

Compare with similar skills

Jetson Generate Kb 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.

Jetson Generate Kb compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Jetson Generate Kb this skillNVIDIA/skills3.5k—~3.8kAutomated safety check: PassApache-2.0
Megatron-Core LLM TrainingOrchestra-Research/AI-Research-SKILLs13k3 repos~2.4kAutomated safety check: PassMIT
OpenVLA-OFT Fine-TuningOrchestra-Research/AI-Research-SKILLs13k1 repos~3.7kAutomated safety check: PassMIT
Cosmos Policy EvaluationOrchestra-Research/AI-Research-SKILLs13k—~3.7kAutomated safety check: PassMIT
Compound Docsoliver-kriska/claude-elixir-phoenix565—~547Automated safety check: PassMIT
Knowledgebaseopen-edge-platform/edge-ai-suites140—~900Automated safety check: PassApache-2.0

Similar skills

  • Megatron-Core LLM Training

    Orchestra-Research/AI-Research-SKILLs

    Sets up large-scale LLM training with NVIDIA Megatron-Core, choosing tensor, pipeline, data, context and expert parallelism for a given model size and GPU count.

    13k GitHub starsUsed in 3 repos~2.4k tokens
    AI & LLM EngineeringAuto-check passed
  • OpenVLA-OFT Fine-Tuning

    Orchestra-Research/AI-Research-SKILLs

    Fine-tunes and evaluates OpenVLA-OFT and OFT+ robot policies with LoRA and continuous action heads on LIBERO simulation and ALOHA real-robot setups.

    13k GitHub starsUsed in 1 repo~3.7k tokens
    AI & LLM EngineeringAuto-check passed
  • Cosmos Policy Evaluation

    Orchestra-Research/AI-Research-SKILLs

    Sets up and runs NVIDIA Cosmos Policy evaluations on the LIBERO and RoboCasa simulators, including headless GPU rendering and inference latency profiling.

    13k GitHub stars~3.7k tokensUpdated 3 mo ago
    AI & LLM EngineeringAuto-check passed
  • Compound Docs

    oliver-kriska/claude-elixir-phoenix

    Searchable Elixir/Phoenix/Ecto solution documentation system with YAML frontmatter.

    565 GitHub stars~547 tokensUpdated 3 days ago
    Knowledge ManagementAuto-check passed
  • Knowledgebase

    open-edge-platform/edge-ai-suites

    Generic RAG query skill - Retrieve any information from the local knowledge base and generate structured reports, summaries, or Q&A responses.

    140 GitHub stars~900 tokensUpdated yesterday
    Knowledge ManagementAuto-check passed
  • Work Operating Model

    NateBJones-Projects/OB1

    Conversation-first workflow for turning tacit work patterns into a structured operating model.

    4.7k GitHub stars~2.2k tokensUpdated yesterday
    Knowledge ManagementAuto-check passed

More from NVIDIA/skills

All 380 skills in this repo
  • Official

    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.

    3.5k GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed
  • Official

    Generates, validates, compares and explains HOLOLINK_def.svh macro files for the HSB IP, using bundled Python scripts and asking before it writes anything.

    3.5k GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Official

    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.

    3.5k GitHub stars~4.8k tokensUpdated yesterday
    Auto-check passed
  • 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.

    3.5k GitHub stars~5k tokensUpdated yesterday
    Auto-check: notes
  • Orchestrates video data augmentation and auto-labeling workflows on OSMO, from flow selection and preflight checks to submission, monitoring and output download.

    3.5k GitHub stars~4.7k tokensUpdated yesterday
    Auto-check: notes
  • Official

    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.

    3.5k GitHub stars~2.7k tokensUpdated yesterday
    Auto-check: notes

Questions about Jetson Generate Kb

What does Jetson Generate Kb do?

Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree. Jetson Generate Kb is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Build a per-target knowledge-base markdown next to the active profile by walking the BSP root and source tree.

When should I use Jetson Generate Kb?

Jetson Generate Kb fits situations like: tasks that involve GPU and accelerator computing; tasks that involve Knowledge bases.

How do I install Jetson Generate Kb in Claude Code?

Run `npx skills add NVIDIA/skills --skill jetson-generate-kb -a claude-code`. Or copy the skill folder (skills/jetson-generate-kb in NVIDIA/skills) into .claude/skills/jetson-generate-kb in your project. Claude Code loads it when a task matches its description.

How do I install Jetson Generate Kb in Codex?

Run `npx skills add NVIDIA/skills --skill jetson-generate-kb -a codex`. Or copy the skill folder (skills/jetson-generate-kb in NVIDIA/skills) into .agents/skills/jetson-generate-kb in your project. Codex loads it when a task matches its description.

Can I use Jetson Generate Kb in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NVIDIA/skills --skill jetson-generate-kb -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/jetson-generate-kb, .gemini/skills/jetson-generate-kb, .github/skills/jetson-generate-kb and .opencode/skills/jetson-generate-kb in your project.

What does Jetson Generate Kb need to run?

SKILL.md names no scripts, command-line tools or credentials: Jetson Generate Kb is instructions for the agent only.

Does Jetson Generate Kb access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Jetson Generate Kb safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Jetson Generate Kb use?

Jetson Generate Kb 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.

How many tokens does Jetson Generate Kb use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Jetson Generate Kb?

Skills that share tags, products or a category with Jetson Generate Kb: Megatron-Core LLM Training (Orchestra-Research/AI-Research-SKILLs, 13k stars), OpenVLA-OFT Fine-Tuning (Orchestra-Research/AI-Research-SKILLs, 13k stars), Cosmos Policy Evaluation (Orchestra-Research/AI-Research-SKILLs, 13k stars) and Compound Docs (oliver-kriska/claude-elixir-phoenix, 565 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Jetson Generate Kb?

NVIDIA (a GitHub organization, an official publisher) maintains it in NVIDIA/skills, which has 3,539 GitHub stars. The repository holds 380 skills in this directory. The repository was last updated on October 7, 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.