Agentes generan kernels CUDA listos para producción

Hicieron algo que suena a ciencia ficción pero es muy práctico: enseñaron a agentes de código a escribir kernels CUDA de producción, los integraron con transformers y diffusers, y obtuvieron binarios listos para usar con PyTorch y benchmarks reproducibles. ¿Te imaginas delegarle a un agente la tarea de optimizar un kernel para H100 y que produzca un proyecto compilable y medible de punta a punta? Eso es justo lo que lograron con una "skill" para agentes.

Qué hicieron

Construyeron una agent skill (habilidad para agentes) que empaqueta conocimiento de dominio sobre desarrollo de kernels CUDA: guías de optimización por arquitectura, plantillas vectorizadas, patrones de integración con transformers y diffusers, y scripts de benchmark. Luego apuntaron a Claude y Codex a dos objetivos reales: un pipeline de diffusers (LTX-Video) y un modelo en transformers (Qwen3-8B). Los agentes generaron kernels funcionales, los bindings en C++ para PyTorch, y scripts para medir micro-benchmarks y rendimiento end-to-end.

Por qué esto importa (y por qué es difícil)

Escribir kernels CUDA ya es complejo: accesos de memoria según la arquitectura, vectorización, reducciones por warp, uso correcto de memoria compartida versus registros. Integrar esos kernels en transformers o diffusers suma otras trampas: convenciones de normalización, jerarquías de módulos, y cómo registrar operaciones para torch.compile.

¿El resultado? Una skill que concentra esa experiencia dispersa en documentación, plantillas y ejemplos que un agente puede leer y aplicar automáticamente.

Cómo usar la skill ahora mismo

Instalas la librería de kernels y agregas la skill al agente con una línea. Ejemplos:

pip install kernels
kernels skills add cuda-kernels --claude
# Para Codex
kernels skills add cuda-kernels --codex
# Destino personalizado
kernels skills add cuda-kernels --dest ./my-agent/skills/

Después le pides al agente algo concreto, por ejemplo:

• "Build a vectorized RMSNorm kernel for H100 targeting the Qwen3-8B model in transformers."
• "Build an optimized attention kernel for H100 targeting Qwen3-8B. Benchmark it against the PyTorch baseline and validate improvements end-to-end."

El agente lee la skill, selecciona parámetros de arquitectura (por ejemplo capacidades CUDA para H100), genera *.cu, crea los bindings en torch-ext/, arma build.toml y prepara scripts de benchmark.

Qué incluye la skill (resumen técnico)

• Guías específicas para NVIDIA H100, A100 y T4: capacidades de cómputo, memoria compartida, bandwidth y block sizing.
• Patrones de integración para diffusers y transformers y los pitfalls comunes.
• Plantillas de kernels con accesos vectorizados para BF16, FP16 y FP32.
• Workflows de benchmarking: micro-benchmarks y comparaciones end-to-end.
• Integración con HuggingFace Kernel Hub via get_kernel.

Estructura de la skill (simplificada):

.claude/skills/cuda-kernels/
├── SKILL.md
├── scripts/
└── references/

La guidance principal ocupa ~550 tokens con scripts, guías de optimización y ejemplos listos.

Resultados y benchmarks clave

Probaron dos objetivos reales con H100 80GB HBM3 en BF16.

1. LTX-Video (diffusers)

• Micro-benchmarks de RMSNorm muestran un speedup promedio de 1.88x frente a PyTorch. Bandwidth efficiency: 34.7% del teórico H100 (3350 GB/s).

Tabla (ejemplo resumido):

• End-to-end video generation (un solo tipo de kernel optimizado) aportó ~6% de mejora cuando se combina con torch.compile.

2. Qwen3-8B (transformers)

• RMSNorm optimizado mostró speedups que escalan con la longitud de contexto: 1.58x a 128 tokens, hasta 2.47x a 8192 tokens. En promedio 1.94x y bandwidth efficiency 22.3% del H100.

Tabla (ejemplo resumido):

Interpretación: para inferencia de largo contexto, el kernel personalizado puede reducir casi a la mitad la latencia del RMSNorm, que aunque es solo ~5% del cómputo total en LTX-Video, su optimización reduce el cuello de botella relativo.

Del prototipo al Hub: flujo de trabajo para publicar kernels

El agente ya genera un proyecto con la estructura requerida por kernel-builder:

your_kernel/
├── build.toml
├── kernel_src/rmsnorm.cu
└── torch-ext/
    ├── torch_binding.cpp
    └── your_kernels/__init__.py

build.toml incluye las cuda-capabilities apropiadas (por ejemplo 9.0 para H100). El pipeline de publicación usa Nix flakes para compilar contra todas las combinaciones PyTorch/CUDA soportadas, luego subes los binarios al Hub:

# Ejecución simplificada
nix flake update
nix run .#build-and-copy -L
huggingface-cli repo create your-org/your-kernel --type model
huggingface-cli upload your-org/your-kernel ./build

Una vez publicado, cualquiera carga el kernel sin compilar con una línea:

from kernels import get_kernel
rmsnorm = get_kernel('your-org/your-kernel')

get_kernel detecta versión de Python, PyTorch y CUDA y descarga el binario precompilado adecuado.

Recomendaciones prácticas si quieres probarlo

• Si ya compilaste CUDA y odias las matrices de dependencias, esto te ahorra horas: el agente genera el proyecto y la Hub entrega binarios precompilados.
• Para kernels críticos, valida con los scripts de benchmark incluidos: micro-benchmarks y pruebas end-to-end.
• Contribuye a la skill si tienes optimizaciones específicas de arquitectura; la skill es un punto de partida, no una caja negra perfecta.

Publicar y compartir kernels reduce la fricción para que equipos pequeños y proyectos open source aprovechen optimizaciones hardware-específicas sin mantener múltiples toolchains.

En resumen, no es magia: es empaquetar conocimiento humano especializado en una skill y dejar que agentes como Claude y Codex apliquen ese conocimiento de forma reproducible. ¿El próximo paso? Más kernels, más arquitecturas y que la comunidad contribuya para que la carga de optimizar GPU deje de ser un cuello de botella para innovación.

Fuente original

https://huggingface.co/blog/custom-cuda-kernels-agent-skills