What makes NVIDIA CUDA notable?

973 downloads. Trust evidence available

How should NVIDIA CUDA be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

NVIDIA CUDA

Use when work targets NVIDIA GPUs for deep learning training, inference, distributed execution, CUDA/Triton kernels, or AI infra tuning. Enforces GPU-aware c... Skill: NVIDIA CUDA Owner: kkellyoffical Summary: Use when work targets NVIDIA GPUs for deep learning training, inference, distributed execution, CUDA/Triton kernels, or AI infra tuning. Enforces GPU-aware c... Tags: latest:0.4.0 Version history: v0.4.0 | 2026-04-19T09:11:55.823Z | user Add official FA/DDP/FSDP tooling and broader scanner coverage v0.3.0 | 2026-04-19T09:02:50.881Z | user Add latest GPU recommendations

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

973

Updated

Oct 11, 2026

Version

0.4.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 973 downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 973 downloadsadoption · observed Oct 11, 2026
Latest release: 0.4.0release · observed Apr 19, 2026
Handshake status: UNKNOWNsecurity

What changed

Newest first. Only changes that point at a source are listed.

Release 0.4.0release
Add official FA/DDP/FSDP tooling and broader scanner coverage
Observed Apr 19, 2026 · source

Install and run

Setup complexity: low.

clawhub skill install s17c3bh00scgwm0549padd6cc18547af:nvidia-cuda

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-kkellyoffical-nvidia-cuda/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

143,955 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: nvidia-cuda
description: Use when work targets NVIDIA GPUs for deep learning training, inference, distributed execution, CUDA/Triton kernels, or AI infra tuning. Enforces GPU-aware code conventions for PyTorch on CUDA, including dtype policy, memory movement, NCCL/DDP/FSDP choices, profiling, benchmarking, and H100/H200/B200 optimization habits.
---

# NVIDIA CUDA

Use this skill when the task involves NVIDIA GPU training or inference, multi-GPU execution, CUDA/Triton kernels, or CUDA-specific performance/debugging work.

This skill is for implementation and review, not generic theory. It should push the work toward:

- correct GPU usage first
- stable and measurable performance second
- low-risk tuning before low-level kernel work
- frontier algorithms only when the workload shape justifies them

## Hardware stance

Probe the actual machine before acting. This skill is written for modern NVIDIA Tensor Core systems and is especially opinionated for:

- H100 / Hopper
- H200
- B200 / Blackwell-class accelerators

It assumes the agent should actively choose precision, attention backends, sharding strategy, logging frequency, and dataloader settings instead of inheriting slow defaults.

## Use this skill for

- PyTorch training or inference on CUDA
- GPU memory, throughput, or latency bottlenecks
- DDP / FSDP / NCCL decisions
- CUDA env var and runtime hygiene
- Triton or custom CUDA kernel review
- benchmark and profiler setup for NVIDIA GPUs

## Do not use this skill for

- CPU-only optimization
- ROCm / AMD-specific work
- TPU / XLA-specific work
- vague "make it faster" requests without inspecting the actual GPU path first

## First-pass workflow

Before changing code, inspect the actual runtime surface:

1. Check hardware and driver: `nvidia-smi`
2. Check framework build: `python -c "import torch; print(torch.__version__, torch.version.cuda, torch.cuda.is_available())"`
3. Check device visibility and topology:
   - `CUDA_VISIBLE_DEVICES`
   - `torch.cuda.device_count()`
   - `torch.cuda.get_device_properties(i)`
4. Check whether the bottleneck is:
   - input pipeline
   - host/device transfer
   - eager Python overhead
   - kernel efficiency
   - distributed communication
   - memory pressure / fragmentation / OOM

Do not jump to kernel rewrites before ruling out bad data movement, wrong dtype, graph breaks, or poor distributed setup.

## Bundled tooling

Use the included scripts when you need deterministic probes instead of ad hoc snippets:

- `scripts/cuda_env_probe.py`: collect CUDA, PyTorch, device, and env facts
- `scripts/check_training_stack.py`: scan Python code for high-cost anti-patterns
- `scripts/benchmark_attention.py`: benchmark SDPA, flash, cuDNN, and official flash-implementation activation paths
- `scripts/training_step_benchmark.py`: benchmark a synthetic transformer training step with dtype, compile, and `.item()` logging knobs
- `scripts/dataloader_benchmark.py`: benchmark DataLoader worker, pinning, and prefetch se

README.md

# nvidia-cuda

`nvidia-cuda` is an open-source skill package for Codex, OpenClaw, and similar agent systems that need to write or review deep learning code for NVIDIA GPUs.

It is opinionated on purpose. The package encodes modern AI infra practice for H100, H200, and B200-class systems:

- BF16 and FP8-aware precision policy
- `torch.compile` as a benchmarked option, not a taboo
- attention backend selection that does not stop at default SDPA
- FSDP and ZeRO before using gradient checkpointing as a crutch
- `.item()` and host sync anti-pattern detection
- dataloader, pinning, prefetch, and persistent worker checks
- NCCL, TP/SP/CP/EP, TensorRT-LLM, speculative decoding, and TE guidance

## Why this exists

A lot of GPU training code still leaves major performance on the floor because it inherits conservative defaults:

- full FP32 everywhere
- no compile pass
- no attention backend evaluation on newer hardware
- per-step host synchronization for metrics
- checkpointing used before state sharding
- dataloaders that starve the GPU

Those mistakes compound. This skill gives an agent a clear optimization order and a concrete review checklist.

## What is inside

- [SKILL.md](SKILL.md): the main operational policy
- [references/official-notes.md](references/official-notes.md): official PyTorch and NVIDIA references
- [references/latest-gpu-recommendations-2026-04.md](references/latest-gpu-recommendations-2026-04.md): latest GPU shortlist as of 2026-04-19
- [references/runtime-support.md](references/runtime-support.md): tested and expected runtime surface
- [agents/openai.yaml](agents/openai.yaml): optional UI metadata for skill-aware clients
- [scripts/](scripts/): reusable probes, scanners, and benchmarks
- [examples/](examples/): sample environment and planning configs

## Bundled tooling

The repository now includes reusable scripts:

- `scripts/cuda_env_probe.py`
- `scripts/check_training_stack.py`
- `scripts/benchmark_attention.py`
- `scripts/training_step_benchmark.py`
- `scripts/dataloader_benchmark.py`
- `scripts/nccl_smoke.py`
- `scripts/ddp_fsdp_smoke.py`

Example commands:

```bash
python scripts/cuda_env_probe.py --json
python scripts/check_training_stack.py path/to/project
python scripts/benchmark_attention.py --list-flash-impls
python scripts/benchmark_attention.py --backend cudnn --dtype bf16 --seq 4096 --compile
python scripts/training_step_benchmark.py --dtype bf16 --compile --iters 10
python scripts/dataloader_benchmark.py --pin-memory --num-workers 8 --persistent-workers --prefetch-factor 4
torchrun --standalone --nproc_per_node=2 scripts/nccl_smoke.py --json
torchrun --standalone --nproc_per_node=2 scripts/ddp_fsdp_smoke.py --mode ddp --json
torchrun --standalone --nproc_per_node=2 scripts/ddp_fsdp_smoke.py --mode fsdp --json
```

## Install locally

### Codex

Copy this directory to your skills path as `~/.codex/skills/nvidia-cuda/`.

### OpenClaw / ClawHub-compatible agents

The repository root is already a skill package:

- `SK

_meta.json

{
  "ownerId": "kn7bcfdgsryztp2rsxyq54gydh82b5be",
  "slug": "nvidia-cuda",
  "version": "0.4.0",
  "publishedAt": 1776589915823
}

references/latest-gpu-recommendations-2026-04.md

# Latest NVIDIA GPU Recommendations for AI Infra

Last reviewed: 2026-04-19

This note summarizes practical NVIDIA GPU recommendations for AI infrastructure based on official NVIDIA product positioning and published specifications as of 2026-04-19.

Important: these recommendations are partly **inference from official specs and positioning**, not direct vendor buying advice. Use them to choose a shortlist, then validate availability, thermals, interconnect, memory, and software fit for your workload.

NVIDIA's own data center line card labels products relative to each workload column. The ranking below is a practical shortlist built from that line card plus current product pages, not an official NVIDIA rank list.

## Recommendation matrix

### 1. Cost-sensitive local prototyping

Recommended:

- **GeForce RTX 5090**

Use when:

- you need a powerful local GPU for experimentation
- your models fit within **32 GB GDDR7**
- you are doing inference, small finetunes, QLoRA-style work, or kernel benchmarking

Avoid as the default choice when:

- you need large-memory training
- you need ECC-centric enterprise workflows
- you need dense multi-GPU workstation or server deployment

Why:

- NVIDIA positions RTX 5090 as its flagship GeForce GPU with **32 GB GDDR7** and Blackwell architecture.

Official:

- https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5090/

### 2. Serious single-workstation AI development

Recommended:

- **NVIDIA RTX PRO 6000 Blackwell Workstation Edition**
- **NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition** when density or power matters more than peak board power

Use when:

- you want a desk-side AI workstation
- you need **96 GB GDDR7 with ECC**
- you want stronger enterprise and workstation ergonomics than GeForce

Why:

- NVIDIA positions the Workstation Edition as its most powerful desktop GPU for professionals.
- NVIDIA positions the Max-Q variant as a **300 W** option that scales to **up to four GPUs in one system**.

Official:

- https://www.nvidia.com/en-us/products/workstations/professional-desktop-gpus/rtx-pro-6000/
- https://www.nvidia.com/en-us/products/workstations/professional-desktop-gpus/rtx-pro-6000-max-q/

If you want a full deskside AI system rather than a loose card:

- **NVIDIA DGX Station**

Official:

- https://www.nvidia.com/en-us/products/workstations/dgx-station/

### 3. Universal enterprise server GPU

Recommended:

- **NVIDIA RTX PRO 6000 Blackwell Server Edition**

Use when:

- you need a flexible enterprise server GPU for AI plus graphics or simulation
- you want **96 GB GDDR7 with ECC**
- you are building enterprise servers rather than bare enthusiast workstations

Why:

- NVIDIA positions this card as a universal Blackwell data center GPU for AI and visual computing.
- It is a strong fit for enterprise inference, agentic AI, multimodal systems, and mixed graphics plus AI environments.

Official:

- https://www.nvidia.com/en-us/data-center/rtx-pro-6000-blackwell-server-edition

references/official-notes.md

# NVIDIA CUDA Skill Notes

This file is reference material for the `nvidia-cuda` skill. Read it when you need official grounding for a tuning choice, a code review decision, or a user-facing explanation.

## Official facts to use

### Mixed precision

- PyTorch AMP says lower precision ops such as linear layers and convolutions are often much faster in lower precision, while other ops still need FP32 range.
- Current AMP API is `torch.amp.autocast(...)` and `torch.amp.GradScaler(...)`; old `torch.cuda.amp.*` entry points are deprecated.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/amp.html

### TF32 and FP32 matmul precision

- `torch.set_float32_matmul_precision("high" | "medium")` can significantly improve performance for FP32 matmuls on CUDA.
- It changes internal computation precision, not output dtype.
- On Ampere and later, TF32 can improve speed but may reduce accuracy for some workloads.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
- https://docs.pytorch.org/docs/stable/notes/numerical_accuracy.html

### CUDA env vars and allocator/debug knobs

- `PYTORCH_ALLOC_CONF`, `CUDA_LAUNCH_BLOCKING`, `CUDA_VISIBLE_DEVICES`, TF32 override knobs, cuDNN cache or workspace knobs, and NCCL non-blocking error handling are documented in one place.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/cuda_environment_variables.html

### Data movement

- PyTorch data docs say host-to-GPU copies are much faster from pinned memory.
- `DataLoader(pin_memory=True)` automatically places fetched tensors in pinned memory.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/data.html

### Distributed backend choice

- PyTorch distributed docs say the rule of thumb for CUDA distributed training is NCCL.
- PyTorch distributed overview says:
- use DDP when the model fits on one GPU
- use FSDP2 when the model cannot fit on one GPU
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/distributed.html
- https://docs.pytorch.org/tutorials/beginner/dist_overview.html
- https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html

### Activation checkpointing

- Activation checkpointing trades compute for memory.
- PyTorch recommends `use_reentrant=False`.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/checkpoint.html

### `torch.compile`

- `torch.compile` supports modes `default`, `reduce-overhead`, `max-autotune`, and `max-autotune-no-cudagraphs`.
- `reduce-overhead` and `max-autotune` can leverage CUDA Graphs for suitable GPU paths.
- `shape_padding` exists to better align loads on GPUs, especially for tensor cores.
- PyTorch docs:
- https://docs.pytorch.org/docs/stable/generated/torch.compile.html

### NCCL tuning and debug

- PyTorch docs recommend NCCL for CUDA and point to NVIDIA NCCL docs for the full env list.
- NCCL docs describe debug and subsystem filters such as `NCCL_DEBUG` and `NCCL_DEBUG_SUBSYS`.
- PyTorch docs:
- https://docs.pytorch.org/do

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.

MCPOPENCLAW

Github ReposUpdated 7mo agoRank 70

CopilotKit

The Frontend for Agents & Generative UI. React + Angular