Jetson Device Skills: Agentic Edge AI on AGX Orin 64GB

NVIDIA quietly shipped something significant this month: jetson-device-skills, an open-source catalog of agent skills that wire Claude Code, Codex, and Cursor directly into Jetson-specific workflows. This is part of the larger JetPack 7.2 push that also landed NemoClaw on Jetson — but the skills repo itself installs cleanly on JetPack 6.x hardware too.

This post covers what the skills actually are, how to install them, and live benchmark output from a Jetson AGX Orin 64GB running JetPack 6.4.

What Are Jetson Device Skills?

Agent skills are structured SKILL.md files plus helper scripts that a coding agent (Claude Code, Cursor, Codex, or NemoClaw/OpenClaw) can discover and invoke automatically. The Jetson Device Skills repo provides nine device-side skills:

Skill	What it does
`jetson-diagnostic`	Read-only health snapshot: identity, memory, GPU, thermal, power, storage, services
`jetson-memory-audit`	DRAM/NvMap usage measurement with before/after reclamation verification
`jetson-headless-mode`	Disable desktop and background daemons to reclaim memory
`jetson-inference-mem-tune`	Pick serving runtime (vLLM / SGLang / llama.cpp / TRT-ELLM) and memory flags
`jetson-llm-serve`	Jetson-appropriate vLLM and SGLang container recipes
`jetson-llm-benchmark`	Structured JSON benchmarks for vLLM, llama.cpp, and Ollama
`jetson-package`	Guidance on GHCR + Jetson AI Lab PyPI indexes vs generic ARM wheels
`jetson-speculative-decoding`	EAGLE-3 and draft-model speculative decoding guidance for vLLM
`jetson-print-device-info`	Concise baseline snapshot (module model, L4T, kernel, power mode)

There is also a companion jetson-perf-investigator sub-agent that chains diagnostic → memory-audit → inference-mem-tune into a single investigative workflow.

A sibling repo, jetson-bsp-skills, handles BSP customization and carrier-board bring-up before the device boots. The device-skills repo is for the running system.

Context: JetPack 7.2 and NemoClaw

JetPack 7.2 is NVIDIA's production release for agentic AI at the edge. Three things shipped together:

NemoClaw — NVIDIA's agentic AI framework, deployed with a single bash script via install.sh, running in Docker with policy-based security via OpenShell.
Jetson Device Skills — the agent-skill layer that gives NemoClaw (and any other coding agent) Jetson-native knowledge.
Hardware enhancements — MIG support on Jetson Thor, AGX Orin 32GB Super Mode (+20% TOPS), official Yocto Project support.

The device tested here runs JetPack 6.4 (R36.4.4), not yet 7.2. The skills repo installs and works correctly on 6.x — NemoClaw had already been deployed separately on this device.

Test Environment

Spec	Value
Device	NVIDIA Jetson AGX Orin Developer Kit
Unified Memory	62.8 GB (64 GB SKU)
JetPack	R36.4.4 (JetPack 6.4)
CUDA	12.6
TensorRT	10.3.0
OS	Ubuntu 22.04.5 LTS
Docker	29.5.2
NvPModel	MAXN (max performance)
Storage	937 GB NVMe (9% used)
Claude Code	2.1.196

At the time of testing, the device already had NemoClaw/OpenShell running (6 days uptime), Qdrant and Meilisearch for vector search, and Ollama 0.30.10 with qwen2.5:7b and nomic-embed-text pulled.

Installation

Step 1 — Install Claude Code (if not present)

Claude Code is not pre-installed on JetPack 6.x. Node.js is available via nvm:

source ~/.nvm/nvm.sh
npm install -g @anthropic-ai/claude-code
claude --version
# 2.1.196 (Claude Code)

Step 2 — Clone and install the skills

git clone --depth 1 https://github.com/NVIDIA-AI-IOT/jetson-device-skills.git ~/jetson-device-skills
cd ~/jetson-device-skills
./install.sh --targets claude

The installer creates symlinks in ~/.claude/skills/ (one per skill) and ~/.claude/agents/ (the perf-investigator sub-agent):

Mode: symlink
Targets: claude
Source: /home/nvidia/jetson-device-skills

[claude] Skills → /home/nvidia/.claude/skills
  ✓ jetson-diagnostic
  ✓ jetson-headless-mode
  ✓ jetson-inference-mem-tune
  ✓ jetson-llm-benchmark
  ✓ jetson-llm-serve
  ✓ jetson-memory-audit
  ✓ jetson-package
  ✓ jetson-print-device-info
  ✓ jetson-speculative-decoding
  ✓ claude verified (9 skills visible)

[claude] Agents → /home/nvidia/.claude/agents
  ✓ jetson-perf-investigator.md

Done.

To install for NemoClaw/OpenClaw instead (or in addition):

./install.sh --targets nemoclaw --nemoclaw-sandbox jetson-skills

Skill in Action: jetson-diagnostic

The jetson-diagnostic skill runs scripts/snapshot.sh, which calls tegrastats, nvpmodel, free, df, and /sys/kernel/debug/nvmap and emits a unified JSON. On this device (unprivileged, so nvmap requires sudo):

{
  "sku": "orin-agx",
  "generation": "orin",
  "variant": "orin-agx-64gb",
  "mem_total_gb": 61,
  "l4t_version": "36.4.4",
  "product_model": "nvidia jetson agx orin developer kit",
  "memory_kb": {
    "total": 64348488,
    "available": 46242404,
    "free": 8227216,
    "cached": 36332936,
    "swap_total": 32174208
  },
  "thermal_c": {
    "cpu-thermal": 61.3,
    "gpu-thermal": 55.8,
    "soc1-thermal": 59.0
  },
  "power": {
    "nvpmodel_id": 0,
    "nvpmodel_name": "MAXN"
  },
  "top_processes": [
    { "pid": 4082, "pss_kb": 985988, "cmd": "gnome-software" },
    { "pid": 3194602, "pss_kb": 761363, "cmd": "python" },
    { "pid": 1870, "pss_kb": 726851, "cmd": "python" }
  ],
  "gpu_source": "none"
}

gpu_source: "none" is expected on an unprivileged Orin — the nvgpu driver exposes GPU memory through /sys/kernel/debug/nvmap/iovmm/clients, which requires root. Run sudo to populate nvmap.top_clients. On Jetson Thor (which uses the unified nvidia.ko driver), nvidia-smi works normally and gpu_source will be "nvidia-smi:compute-apps".

The memory summary shortcut:

bash ~/jetson-device-skills/skills/jetson-diagnostic/scripts/mem_summary.sh
# RAM  used 16.9 / 61.4 GiB (27.5%)  |  GPU  (needs sudo)  |  swap  0.0 / 30.7 GiB

Skill in Action: jetson-llm-benchmark (Ollama)

The jetson-llm-benchmark skill wraps vllm bench serve, llama-bench, and Ollama's REST API in a structured JSON harness. Since this device already runs Ollama with qwen2.5:7b, this is the fastest path:

bash ~/jetson-device-skills/skills/jetson-llm-benchmark/scripts/bench_ollama.sh \
  --model qwen2.5:7b \
  --num-prompts 5 \
  --input-len 128 \
  --output-len 256

Output:

{
  "skill": "jetson-llm-benchmark",
  "runtime": "ollama",
  "model": "qwen2.5:7b",
  "sku": "orin-agx",
  "variant": "orin-agx-64gb",
  "l4t": "36.4.4",
  "container": "native/ollama",
  "config": {
    "input_len": 128,
    "output_len": 256,
    "num_prompts": 5,
    "concurrency": 1
  },
  "metrics": {
    "ttft_ms_p50": 42.37,
    "ttft_ms_p99": 42.94,
    "itl_ms_p50": 41.04,
    "itl_ms_p99": 41.28,
    "tpot_ms_p50": 41.04,
    "throughput_tok_s": 24.4,
    "e2e_latency_ms_p50": 3001.13
  },
  "warnings": []
}

Benchmark Summary

Metric	Value
Model	Qwen2.5 7B (Ollama native, 4-bit)
TTFT p50	42.37 ms
TTFT p99	42.94 ms
Inter-token latency p50	41.04 ms
Throughput	24.4 tok/s
E2E latency p50	3,001 ms (128 in / 256 out)

The TTFT is impressively tight — under 43 ms even at the 99th percentile. At 24.4 tok/s, Qwen2.5 7B via Ollama on Orin is well into interactive territory. The E2E figure reflects a 256-token output; shorter responses will be proportionally faster.

Note this was a lightly loaded device with gnome-software and two Python processes each consuming ~700–900 MB PSS. In a headless production configuration (use jetson-headless-mode to disable gdm3 and auxiliary daemons), both memory pressure and thermal load would be lower, likely pushing throughput higher.

What Changes With JetPack 7.2

Feature	JetPack 6.x	JetPack 7.2
NemoClaw	Manual Docker setup	Single-command `install.sh`
Jetson Device Skills	Installable from GitHub	Bundled, auto-discovered
AGX Orin 32GB TOPS	200	241 (Super Mode, +20%)
Jetson Thor MIG	No	Yes
Yocto Project	Community only	Officially supported
GPU memory query	`nvmap` (nvgpu, root needed)	`nvidia-smi` full (Thor only)

The skills themselves are version-agnostic — the same nine skills work on both JetPack 6.x and 7.x, since they probe the runtime environment rather than assuming a specific software stack.

Practical Notes

Which agent runtime to use: Claude Code is the most capable option for complex multi-step Jetson workflows (diagnose → tune → benchmark). NemoClaw/OpenClaw is better for air-gapped deployments where an API key to a cloud model is not available or permitted.

The gpu_source: "none" problem: On Orin-family devices, always run the benchmark and diagnostic scripts with sudo if you need per-process GPU memory accounting. Without it, nvmap.top_clients is empty and jetson-inference-mem-tune cannot accurately estimate available GPU headroom.

Headless mode before benchmarking: The jetson-headless-mode skill disables gdm3 and several background daemons. On this device, the GNOME shell alone consumed ~241 MB PSS and gnome-software ~986 MB. Disabling these before a benchmark gives cleaner numbers and more headroom for the model.

Conclusion

Jetson Device Skills are a clean, practical layer that closes the gap between general-purpose coding agents and Jetson-specific hardware operations. The install is three commands, the diagnostic JSON is immediately useful for automated pipelines, and the benchmark harness produces structured output that an agent can compare across runs without screen-scraping. The AGX Orin 64GB delivers 24.4 tok/s on Qwen2.5 7B via Ollama with a 42 ms TTFT — solid interactive performance from a 60W edge device.

Measured 2026-06-30 on Jetson AGX Orin 64GB. JetPack R36.4.4 · CUDA 12.6 · Ollama 0.30.10 · Claude Code 2.1.196 · jetson-device-skills v0.0.x.

Jetson Device Skills: Agentic Edge AI on AGX Orin 64GB — Install & Live Test