AMD Had Zero Agent Skills. I Built the First 10.

NVIDIA has 428+ agent skills on skills.sh. AMD had zero. This is the story of building the first open-source collection of agent skills for AMD ROCm GPU workloads — and why it matters for the entire AI ecosystem.

The Problem

If you’ve used AI coding agents like Claude Code, OpenCode, Cursor, or Codex, you’ve probably encountered agent skills — reusable instruction sets that teach agents how to perform specific tasks. Skills are the building blocks of agent workflows: “set up my GPU”, “deploy vLLM”, “run YOLO inference”, “check PPE compliance”.

The agent skills ecosystem is powered by skills.sh, a registry that indexes skill repositories from GitHub. When you run npx skills add owner/repo, the CLI clones the repo and installs skills into your agent’s configuration directory.

Here’s the problem:

GPU Vendor Agent Skills on skills.sh NVIDIA 428+ AMD 0

Zero. Not a single skill for AMD ROCm. If you’re a developer using AMD MI300X, MI250, or even a Radeon RX 7900 with an AI coding agent, you had nothing. Every GPU setup, every Docker configuration, every inference deployment required manual documentation lookup and copy-paste.

The Solution

I built amd-rocm-skills — 10 production-ready agent skills covering the full AMD ROCm GPU workflow:

Core (4 skills)

Skill What it does rocm-setup Install, verify, and configure ROCm on AMD GPUs with PyTorch. Auto-detects NVIDIA CUDA and CPU fallback. rocm-docker Docker with AMD GPU passthrough (--device=/dev/kfd), NVIDIA runtime, and CPU profiles. docker-compose multi-profile. vllm-rocm-deploy Deploy vLLM for LLM/VLM inference on ROCm. InternVL2, Qwen2-VL, LLaVA. OpenAI-compatible API. yolo-rocm-deploy YOLOv8 on PyTorch ROCm. Inference, model export (ONNX, TorchScript), benchmarking.

Pipeline (3 skills)

Skill What it does video-pipeline-rocm Video inference pipeline with GStreamer + ROCm. RTSP capture, hardware decode (AMD VCN / NVIDIA NVDEC), frame extraction, batch inference. vlm-rocm-inference VLM inference directly with PyTorch on ROCm. InternVL2, Qwen2-VL. Multimodal (text + image). rocm-benchmark GPU benchmarking: matmul, memory bandwidth, inference latency, VRAM monitoring. ROCm + CUDA + CPU comparison.

Industrial (3 skills)

Skill What it does ppe-detection-pipeline PPE (Personal Protective Equipment) detection in video for industrial safety. YOLOv8 + tracking + alerts (webhook, MQTT, log). Multi-camera, multi-GPU. ds132-compliance Chilean DS 132 mining safety compliance checker. Zone-based EPP requirements, audit logging, compliance reports. rocm-troubleshoot Diagnostics and troubleshooting for ROCm. Error codes, compatibility checks, quick fixes, optimization checklist.

Architecture

agentskills.io Specification

Every skill follows the agentskills.io specification — the open standard for agent skills:

skills/<skill-name>/
├── SKILL.md          # Required: YAML frontmatter + instructions
├── scripts/          # Required: executable Python/Bash scripts
└── references/       # Optional: technical documentation

Enter fullscreen mode Exit fullscreen mode

The SKILL.md frontmatter uses only standard, portable fields:

---
name: rocm-setup
description: >
  Install, verify, and configure AMD ROCm on Linux for AI/ML workloads
  with PyTorch. Use this skill when setting up AMD GPUs (MI300X, MI250,
  RX 7900) for GPU-accelerated PyTorch, verifying ROCm installation, or
  diagnosing GPU detection issues. Keywords: rocm, amd, gpu, pytorch,
  hip, setup, mi300x, detect-gpu, rocm-smi, rocminfo, cuda, check-rocm
license: Apache-2.0
compatibility: >
  Compatible with Claude Code, OpenCode, Codex, Cursor, Cline, Roo Code,
  Windsurf, Gemini CLI, and Kiro CLI. Requires Linux with AMD ROCm or
  NVIDIA CUDA GPU (CPU fallback supported).
metadata:
  version: "1.1.0"
  author: yechua-silva
---

Enter fullscreen mode Exit fullscreen mode

No Claude Code-specific fields. No context: fork, no agent: Explore, no model: claude-sonnet-*. Every skill works identically across 9+ agents.

Multi-GPU Design

The key differentiator: every skill supports three backends with automatic detection.

# Auto-detection pattern used across all skills
import torch

if torch.cuda.is_available():
    if torch.version.hip:
        backend = "rocm"        # AMD ROCm
        device = "cuda:0"       # torch.cuda works on both!
    elif torch.version.cuda:
        backend = "cuda"        # NVIDIA CUDA
        device = "cuda:0"
    else:
        backend = "cpu"
        device = "cpu"

Enter fullscreen mode Exit fullscreen mode

This is the critical insight: PyTorch’s torch.cuda API works on both AMD ROCm and NVIDIA CUDA. There is no torch.rocm. ROCm uses the standard torch.cuda namespace transparently. Use torch.version.hip to distinguish AMD from NVIDIA.

Component AMD ROCm NVIDIA CUDA CPU PyTorch torch.cuda + torch.version.hip torch.cuda + torch.version.cuda device='cpu' vLLM vllm-openai-rocm vllm-openai --device cpu Docker --device /dev/kfd --device /dev/dri --gpus all No flags Video decode VAAPI / VCN NVDEC avdec (software)

Docker Multi-Profile

The rocm-docker skill includes a docker-compose.yml with three profiles:

# AMD ROCm
docker compose --profile rocm up -d

# NVIDIA CUDA
docker compose --profile nvidia up -d

# CPU fallback
docker compose --profile cpu up -d

Enter fullscreen mode Exit fullscreen mode

Agent Compatibility

Agent Supported How Claude Code ✅ .claude/skills/ OpenCode ✅ .agents/skills/ Codex ✅ .codex/skills/ Cursor ✅ .cursor/skills/ Cline ✅ .cline/skills/ Roo Code ✅ .roo/skills/ Windsurf ✅ .windsurf/skills/ Gemini CLI ✅ .gemini/skills/ Kiro CLI ✅ .kiro/skills/

Quick Start

Install all skills

# List available skills
npx skills add yechua-silva/amd-rocm-skills --list

# Install a single skill
npx skills add yechua-silva/amd-rocm-skills --skill rocm-setup --agent opencode --yes

# Install all skills in multiple agents
npx skills add yechua-silva/amd-rocm-skills -a claude-code -a opencode -a cursor --yes

Enter fullscreen mode Exit fullscreen mode

Example: Setting up an AMD MI300X

After installing the rocm-setup skill, just tell your agent:

“Set up this AMD server for GPU workloads”

The agent will:

1. Run detect-gpu.py to identify your backend (ROCm, CUDA, or CPU)
2. Run check-rocm.sh for a full health check
3. Install ROCm if missing
4. Configure environment variables (HIP_VISIBLE_DEVICES, ROCm_PATH)
5. Verify PyTorch can access the GPU
6. Run a smoke test (tensor allocation, matmul, memory info)

Example: PPE Detection Pipeline

After installing ppe-detection-pipeline:

“Detect PPE in this RTSP stream and alert when workers are missing helmets”

The agent will:

1. Auto-detect GPU backend (ROCm / CUDA / CPU)
2. Load YOLOv8 model for PPE detection
3. Track persons across frames with IoU matching
4. Check compliance per person (hardhat, vest, gloves, glasses, boots)
5. Send alerts via webhook, MQTT, or log
6. Export annotated video + JSON results

Technical Deep Dive: Multi-GPU Detection

The detect-gpu.py script (from rocm-setup) is the foundation of all 10 skills. It detects the GPU backend in three levels:

# Level 1: PyTorch
import torch
if torch.cuda.is_available():
    if hasattr(torch.version, 'hip') and torch.version.hip:
        backend = "ROCM"
        device_name = torch.cuda.get_device_name(0)
        # e.g., "AMD Instinct MI300X"
    elif torch.version.cuda:
        backend = "CUDA"
        device_name = torch.cuda.get_device_name(0)
        # e.g., "NVIDIA A100-SXM-80GB"

# Level 2: System commands
import subprocess
if backend == "unknown":
    try:
        result = subprocess.run(["rocm-smi", "--showproductname"],
                                capture_output=True, text=True)
        if result.returncode == 0:
            backend = "ROCM"
    except FileNotFoundError:
        pass

    try:
        result = subprocess.run(["nvidia-smi", "--query-gpu=name",
                                "--format=csv,noheader"],
                                capture_output=True, text=True)
        if result.returncode == 0:
            backend = "CUDA"
    except FileNotFoundError:
        pass

# Level 3: CPU fallback
if backend == "unknown":
    backend = "CPU"

Enter fullscreen mode Exit fullscreen mode

This three-level detection ensures every skill works on any machine — whether you have an MI300X with 192GB HBM3, an RTX 4090, or just a laptop CPU.

Industry Standard Compliance

This isn’t just a collection of scripts. It’s built to industry standards:

• ✅ agentskills.io specification — the canonical format for agent skills
• ✅ skills.sh registry — auto-indexed, discoverable via npx skills add
• ✅ skills.sh.json — groupings for organized discovery (Core, Pipeline, Industrial)
• ✅ CONTRIBUTING.md — quality checklist, naming conventions, PR process
• ✅ CODE_OF_CONDUCT.md — Contributor Covenant 2.1
• ✅ AGENTS.md — agent-facing overview
• ✅ Apache 2.0 license — permissive, commercial-friendly

Quality Checklist (from CONTRIBUTING.md)

Before any skill is merged:

• [ ] name field matches directory name (kebab-case)
• [ ] description includes keywords for agent matching
• [ ] description includes trigger phrases (“Use when…”)
• [ ] compatibility is a string, not a YAML list
• [ ] No Claude Code-specific fields (context, agent, model, hooks)
• [ ] Scripts are executable (chmod +x)
• [ ] No hardcoded secrets or API keys
• [ ] No references to specific projects (keep it agnostic)
• [ ] Related skills cross-referenced in ## Related Skills section
• [ ] SKILL.md under 1000 lines

The Numbers

Metric Value Skills 10 Total lines of content ~32,000 Scripts (Python + Bash) 26 Reference documents 23 Compatible agents 9+ GPU backends 3 (ROCm + CUDA + CPU) License Apache 2.0 References to specific projects 0 (fully agnostic)

Why This Matters

The AI ecosystem has a GPU diversity problem. NVIDIA dominates not just hardware, but the entire software tooling stack — documentation, tutorials, community, and now agent skills. AMD’s MI300X is a phenomenal chip (192GB HBM3, competitive with H100 for many workloads), but the developer experience gap is real.

Agent skills are the newest frontier of this gap. When a developer asks Claude Code to “set up my AMD GPU for PyTorch”, the agent should know how. Without a skill, it hallucinates or gives generic advice. With a skill, it follows a tested, verified workflow.

10 skills won’t close a 428-skill gap. But it’s a start — and it’s open source.

Contributing

Want to add a skill? Here’s how:

1. Fork the repo
2. Create skills/your-skill-name/SKILL.md with frontmatter
3. Add scripts/ with executable Python/Bash
4. Add references/ with technical docs
5. Ensure multi-GPU support (ROCm + CUDA + CPU)
6. Submit a PR

See CONTRIBUTING.md for the full guide.

Skills I’d love to see contributed

• rocm-tuning — ROCm performance tuning (HIPBLAS, RCCL, MIOpen)
• onnx-rocm — ONNX Runtime with ROCm execution provider
• fsdp-rocm — Fully Sharded Data Parallel on AMD GPU
• triton-rocm — Triton kernels on ROCm
• composable-kernel — AMD CK for custom kernels

Install Now

npx skills add yechua-silva/amd-rocm-skills --list

Enter fullscreen mode Exit fullscreen mode

Repo: github.com/yechua-silva/amd-rocm-skills

License: Apache 2.0

Built during AMD Developer Hackathon Act II — Pista Unicornio. If you’re using AMD GPUs with AI agents, I’d love to hear your feedback.