A self-improving skill catalog for AI agents

The catalog started from a recurring failure mode: agents enter specialized compute frameworks with broad conceptual knowledge but weak operational grounding. They hallucinate APIs, miss version-specific changes, and guess at patterns that should come from documentation or working code. I built the catalog to put that missing layer in the repository: compact Markdown skills that tell an agent what to inspect, which primitives to prefer, and where the dangerous edges are.

The useful surprise was that the maintenance loop could also be agent-driven. The same agents that consume the skills can research and draft new ones. When I needed a skill for Prime Intellect's verifiers, the agent cloned the repo, read the project instructions, analyzed the architecture, and wrote the first version. The same pattern worked for Tinker and autoresearch setup. The catalog is not autonomously correct, but it gives agents a repeatable way to extend their own working context.

How It Works

Each skill is a directory with a SKILL.md (under 500 lines) and a references/ folder for deep-dive content. The format follows the agentskills.io specification — compatible with Claude Code, OpenAI Codex, and any agent runtime that reads markdown.

skills/
  prime-verifiers/
    SKILL.md                      # RL environments, rubrics, reward functions
    references/

  tinker/
    SKILL.md                      # Low-level LLM training API
    references/

  autoresearch-setup/
    SKILL.md                      # Autonomous experiment loop scaffolding

An agent reads SKILL.md first, then drills into whichever reference file matches the task. The skills aren't summaries — they're the operational knowledge a senior engineer would pass to a new hire: current function signatures, right patterns, common pitfalls, which primitives to reach for.

The Self-Improving Loop

Here's how a new skill gets created:

1. I tell the agent "create a skill for X"
2. The agent clones the repo, reads the docs (and any existing AGENTS.md or CLAUDE.md in the project)
3. It analyzes the architecture, identifies key concepts, maps out the API surface
4. It generates a SKILL.md following the same structure as every other skill
5. It installs the skill in the agent's own skill directories, updates indexes, commits, and pushes

The newest three skills — autoresearch-setup, prime-verifiers, and tinker — were all created this way in a single session. The agent researched each project, understood the philosophy, wrote the skills, and deployed them. Then it updated this blog post to document what it built.

This is the loop: agents consume skills to be competent, then create new skills to make future agents more competent. The catalog compounds.

What's Inside

19 skills across 7 domains:

Autonomous Research:

LLM Post-Training & Fine-Tuning:

• Prime Intellect Verifiers & PrimeRL: RL environments, rubrics, and reward functions for LLM post-training. Environment class hierarchy from SingleTurnEnv to SandboxEnv. GEPA genetic-Pareto prompt optimization. Async distributed RL training at 1000+ GPUs with GRPO/PPO/RLOO.
• Tinker (Thinking Machines Lab): Low-level training API — four primitives (forward_backward, optim_step, save, sample) give full algorithmic control over remote GPU clusters. LoRA up to 235B-param models. 15+ recipes: math RL, code RL, multiplayer RL, prompt distillation, DPO, RLHF.

Computational Biology:

• BioNeMo: ESM-2, Evo2 (40kb genomic context), Geneformer single-cell models, NIM microservices.

GPU Programming & Kernels:

• Triton: Block-based GPU kernels, Flash Attention v2, persistent kernels, FP8/FP4, auto-tuning, CUDA/HIP/CPU backends.
• FlashInfer: Paged KV-cache attention, cascade inference (31x speedup), MoE fusion, vLLM/SGLang integration.

LLM & Generative AI:

• Nemotron: Hybrid Mamba-Transformer MoE (up to 253B), 1M context, NIM deployment, synthetic data generation.

HPC & Distributed Computing:

• SLURM: Job scheduling, GPU/GRES allocation, job arrays, monitoring.
• Dask: Parallel DataFrames/Arrays, GPU acceleration with RAPIDS, HPC deployment.
• Ray: Distributed tasks/actors, Ray Train/Serve/Tune/RLlib, KubeRay.
• MPI: Point-to-point, collectives, MPI-IO, GPU-aware MPI.

Data Processing:

• Polars: Lazy query optimization, GPU acceleration via cuDF, expressions API.

Why Markdown

Skills are just markdown files. No vector database. No embedding pipeline. No inference-time retrieval system. An agent loads the file, reads it, and has the knowledge. The "retraining" cost when a framework ships a breaking change is editing a text file.

The 500-line limit on SKILL.md is the constraint that matters. You can't dump every API — you have to decide what's important, what the right default is, what the agent should reach for first. The references/ directory holds depth. The skill file holds judgment.

What Keeps the Catalog Honest

Agent-generated documentation can become confidently stale. Every skill therefore needs three things beyond readable prose:

1. Primary-source grounding. Version-sensitive claims should point back to official documentation or code.
2. Executable checks. A minimal setup, import, or smoke test should prove that the recommended path still works.
3. Visible provenance. The skill should say when it was last verified and which versions or commits it describes.

Without those checks, a large catalog merely scales outdated advice. The self-improving loop only compounds if verification compounds with it.

Where This Is Going

The catalog started with 4 NVIDIA-specific skills. It's at 19 now, with 108 reference files, covering domains from LLM post-training to autonomous research loops.

The scope keeps expanding because the creation cost is low. An agent that already has the catalog can create a new skill in minutes — clone a repo, read the docs, write the skill, install it, push. The catalog is the flywheel: more skills → more capable agents → faster skill creation → more skills.

What's next: every major framework, SDK, or engine with accelerated compute backends. LLM training stacks, inference engines, autonomous research workflows, and genomics pipelines. If it has a nontrivial API surface and runs on specialized hardware, it's a candidate.

The long-term aim is a comprehensive, self-maintaining reference that lets any agent — mine or yours — walk into any specialized compute domain and have the operational knowledge to be useful immediately.

19 skills. 108 reference files. Built by agents, for agents. Self-improving.