⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

roofline

@lenialno⭐ 2 stars

Router for the Inference Engineer role on on-prem LLM serving (vLLM/SGLang, OpenAI-compatible endpoint, air-gap). Use when the user asks what to do first with a local LLM server, how to approach a serving task, which skill, task or agent to use, what is inside or outside the inference engineer role, or talks about LLM serving, GPU inference, inference engineering in general terms.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 2 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

skills.sh Roofline, a Lenialno product line. По-русски

Agent Skills for the Inference Engineer role: run vLLM or SGLang on your own GPUs behind an OpenAI-compatible endpoint, serve Claude Code and Qwen Code through a proxy, stay healthy on air-gapped hosts. 13 skills, one Claude Code subagent and a Taskfile toolbox; the competency map follows roadmap.sh/inference-engineering.

Quick start

As Agent Skills, for any agent that supports them (Claude Code, Codex, Cursor, OpenCode and others):

npx skills add lenialno/roofline --list                                      # see what is inside
npx skills add lenialno/roofline --skill roofline --skill roofline-toolbox   # pick skills
npx skills add lenialno/roofline --all                                       # everything, all agents
npx skills add lenialno/roofline -g -a claude-code --skill roofline-toolbox  # user scope, Claude Code only

As a Claude Code plugin, available in every project on the machine, from the Lenialno catalog lenialno/skills:

claude plugin marketplace add lenialno/skills
claude plugin install roofline@lenialno

[!TIP] Update with claude plugin marketplace update lenialno, then claude plugin update roofline@lenialno and /reload-plugins. To try a local clone for one session: claude --plugin-dir /path/to/roofline.

Then ask the agent what to do first with your local LLM server. The roofline skill routes the question to the right skill, task or subagent.

The toolbox needs python3 and curl, go-task for task, and nvidia-smi for the gpu task. The scripts also run without task.

Skills

SkillCoversAsk it when
rooflinerole router: first steps, what is in and out of the role, which skill, task or agent to use"where do I start", "is this my job", "which skill handles this"
roofline-runtimebring up vLLM or SGLang and keep it healthy: engine choice, flag order, launch profiles, air-gap, docker"start or stop the server", "vLLM or SGLang", "set TP or max-model-len", "it fails to start"
roofline-toolcalltool calling and chat template: parsers by model family, streaming tool_calls, Claude Code and Qwen Code wiring"tool calls come back as text", "arguments are not valid JSON", "400 on role tool"
roofline-perfVRAM and KV cache budget, batching, prefix cache, quantization and its cost, speculative decoding, benchmark method"why is it slow", "more throughput", "which quantization", "how to read a benchmark"
roofline-incidentrunbook: triage health, metrics, gpu, logs; OOM variants, queue, p95 breaches, regressions after upgrades, postmortem"server is down", "GPU memory is full", "p95 spiked", "Claude Code reports errors"
roofline-capacityGPU, VRAM and TP sizing, concurrency under SLO, replicas, model choice by evals, canary and rollback, cost"how many GPUs", "which model fits", "how many concurrent users", "roll out safely"
roofline-toolboxTaskfile and dependency-free scripts the other skills call"check, start, stop, benchmark or probe the server", or another skill says to run a task

Agents pick a skill by its description, so phrases like the ones in the last column are enough. The first six also ship in Russian under the same name with a -ru suffix: roofline-ru, roofline-runtime-ru, roofline-toolcall-ru, roofline-perf-ru, roofline-incident-ru, roofline-capacity-ru. The toolbox is language-neutral and shared by both sets.

[!NOTE] No MCP servers and no hooks, by design. Live state comes from Task: the agent reads GPU memory, health, metrics and logs from the real server instead of guessing.

Subagent

incident-investigator (agents/incident-investigator.md) is a Claude Code subagent that roofline-incident hands an investigation to when it needs long logs or hours of metrics. It only reads and measures (health, metrics, gpu, models, logs, smoke-toolcall), never runs serve, stop or restart, and returns a verdict of at most 25 lines: cause, evidence, rejected hypotheses, next action.

Toolbox

A Taskfile plus dependency-free bash and python3 scripts in skills/roofline-toolbox/; the root Taskfile.yml re-exports it without a namespace. Every task is idempotent and exits non-zero on failure. From any project:

task -t /path/to/roofline/Taskfile.yml health

Or include it in the project Taskfile and call task infer:health:

version: '3'
includes:
  infer:
    taskfile: /path/to/roofline/skills/roofline-toolbox/Taskfile.yml

Commands run in the directory you call task from, where inference.env (KEY=value lines) and .inference-state/ live. task with no arguments prints the task list under the Roofline mark.

[!NOTE] task serve starts only a named profile from profiles/ (or PROFILES_DIR). Before promoting a profile: task health && task smoke-toolcall && task bench.

TaskWhat it does
gpumemory, utilization, processes from nvidia-smi
health/health, /v1/models, one short completion with latency
modelsserved model ids and max context from /v1/models
profileslist launch profiles in profiles/
metricsqueue, KV usage, prefix-cache hit rate, preemptions, p50/p95 TTFT and TPOT from /metrics
statusgpu, then health, then models
serve INFER_PROFILE=<name>start from a profile, wait for /health, pid and log in .inference-state/
stop, restart, logsstop by pid (no profile means all), stop then serve, tail the log (LINES=200 FOLLOW=1)
benchfixed SLO benchmark: BENCH_N, BENCH_C, BENCH_IN, BENCH_OUT; -- --json for a JSON line; exit 1 when the SLO is missed
smoke-toolcalltool-calling contract: non-stream, stream, negative prompt, round trip, parallel calls
doctorafter an engine upgrade: parser names and /metrics series against the installed version, then smoke-toolcall; prints an issue link on a mismatch
vram MODEL=/models/xVRAM and KV budget, concurrency from config.json; GPU_GB, TP, CTX, KV_DTYPE=fp8
flags Q=<word>grep the installed engine's --help (RUNTIME=vllm or sglang)

Profiles and their variables: skills/roofline-toolbox/profiles/README.md.

Priority, highest first: task variable (task serve INFER_PROFILE=x), environment, inference.env in the current directory, built-in default.

VariableMeaningDefault
INFER_URLOpenAI-compatible base URL, no /v1http://127.0.0.1:8000
INFER_API_KEYbearer token if the server needs oneempty
INFER_PROFILEprofile name from profiles/ for serve, stop, logsnone
INFER_STATE_DIRpid files and logs./.inference-state
SLO_TTFT_P95_MSbench gate, p95 time to first token2000
SLO_TPOT_P95_MSbench gate, p95 time per output token60
BENCH_N, BENCH_C, BENCH_IN, BENCH_OUTbench shape: requests, concurrency, input and output tokens32, 8, 2048, 256

Examples

Real output, cap

// HOW IT'S BUILT

KEY FILES

skills/roofline/SKILL.mdREADME.md

// REPO STATS

2 stars