Skip to content
Skills Library
AI & agents · Building & coding

build-engine

/build-engine

Build, measure and serve a bespoke inference engine for an open LLM on the user's own NVIDIA GPU with crit. Use when the user wants a model to run faster on their GPU, a custom or specialized inference engine, CUDA kernel or quantization work on one model, speculative decoding, a crit run, crit Eval results, or a crit-hub engine installed and served.

Repository
crit-mcp ↗
Licence
Apache-2.0
Last repository change
09.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
2
Deprecation

No signals detected. Repository changed on 09.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Build, measure and serve a bespoke inference engine for an open LLM on the user's own NVIDIA GPU with crit. Use when the user wants a model to run faster on their GPU, a custom or specialized inference engine, CUDA kernel or quantization work on one model, speculative decoding, a crit run, crit Eval results, or a crit-hub engine installed and served.

Original author description

Build, measure and serve a bespoke inference engine for an open LLM on the user's own NVIDIA GPU with crit. Use when the user wants a model to run faster on their GPU, a custom or specialized inference engine, CUDA kernel or quantization work on one model, speculative decoding, a crit run, crit Eval results, or a crit-hub engine installed and served.

How it works

  1. Before you start
  2. The workflow
  3. Rules that always hold
Original SKILL.md headings · 43 lines, 462 words
SKILL.md preview
---
name: build-engine
description: Build, measure and serve a bespoke inference engine for an open LLM on the user's own NVIDIA GPU with crit. Use when the user wants a model to run faster on their GPU, a custom or specialized inference engine, CUDA kernel or quantization work on one model, speculative decoding, a crit run, crit Eval results, or a crit-hub engine installed and served.
---

# Build an engine with crit

crit builds one engine for one model on one GPU: candidates that each try a strategy, measured with crit Eval,
recorded through `crit run`, and served through `crit serve`, an OpenAI-compatible API on localhost. You drive it
through crit's command line, or through crit's MCP tools (`crit_*`) when the `crit` MCP server is connected: they
run the same commands.

## Before you start

- crit 0.17.2 or later must be installed where the engines run (`python -m pip install "crit>=0.17.2"`), with an
  NVIDIA GPU and a CUDA toolkit. Check with `crit --version`; if it is missing, say so and give that install
  command.
- **Read the workflow first.** The installed crit carries its own rules for the release it is: read AGENTS.md at
  that release's tag, `https://github.com/crit-labs/crit/blob/vVERSION/AGENTS.md` (VERSION from `crit --version`),
  or the `crit://AGENTS.md` resource when the crit MCP server is connected. A run's brief (`agent_request.md`)
  names the same guides. Their rules win over this summary when they differ.
- **Name the folders.** Pass the crit project folder (`--project`, the folder of `settings.toml` and `runs/`) as an
  absolute path in the user's workspace on every `crit run` command, and keep every other path absolute too.
- Each command's `--help` gives its arguments; `crit run --help` lists the run's steps.

## The workflow

1. **Set up.** Agree the model, GPU, workload, quality criteria and limits with the user. Probe the device
   (`crit eval probe`), create the run (`crit run --project P create`) and study the model
   (`crit run --project P --id RUN recon`).
2. **Start from what exists.** If crit-hub has an engine for the model, start from it (`crit pull`).
3. **Build candidates.** Plan each one (`crit run ... plan`), allocate it (`crit run ... candidate`), build and
   package it, and measure it with Eval (`crit run ... eval`); `crit eval status` names the next goal. Search crit's
   techniques (`crit inference search`) and kernels (`crit kernels search`) before writing new code.
4. **Long commands.** Builds and Eval take a while: run them in the background, follow their logs, and do the next
   round's CPU work while the GPU is busy.
5. **Deliver.** Check the package (`crit run ... serve --check`), seal and select the best candidate
   (`crit run ... seal`, `crit run ... select`), serve it (`crit serve`), and stop the run with its critique
   (`crit run ... stop`).

## Rules that always hold

- Never fit the engine to Eval's suite, and never invent a measurement: label anything unmeasured.
- Never run `crit run ... cost`: it reads the agent's transcript files.
- Ask before destructive steps: stopping a run, sealing or selecting a candidate, killing a running build or Eval.
- Give the user the served candidate's `crit serve` command and the endpoint, `http://127.0.0.1:8000/v1`.

Versions

The database has no other skills named build-engine.

Database snapshot: 13.11.2026 · package version 09eda4b7cec6 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100speculative-decoding
    Accelerate LLM inference using speculative decoding, Medusa multiple heads, and lookahead decoding techniques. Use when optimizing inference speed (1.5-3.6× speedup), reducing latency for real-time applications, or deploying models with limited compute. Covers draft models,…
  • 95ml-inference-optimization
    Use this skill when the user says 'llm inference optimization', 'reduce latency llm', 'time to first token', 'ttft', 'tokens per second', 'llm throughput', 'vllm vs tgi', 'speculative decoding', 'continuous batching', 'serve llm cheaper'. Diagnoses and optimizes LLM inference…
  • 85colibri
    Assist with Colibri: pure-C LLM inference engine for running GLM-5.2 (744B MoE) on consumer machines with ~25 GB RAM. Use when setting up, building, converting models, running inference, configuring expert streaming and caching, optimizing speculative decoding (MTP), GPU…
  • 100enginesmith-setup
    Lead a user step by step through building a specialized inference engine for one model on their own machine with EngineSmith, and through sharing it. Covers the proposal and the questions (model, goal, scale, agent), the task file and model card, measuring the reference, the…
  • 100cloudgpu-open-model-inference
    Run open-model GPU inference or evaluation and retrieve outputs, metrics and logs. Use when a private or custom model needs CUDA, larger VRAM, an Ollama instance or a bounded batch beyond the local machine.
  • 100minicpm5-deploy
    Pick the right inference backend for a MiniCPM5-1B or MiniCPM5-2B checkpoint and route to a backend-specific cookbook skill. Use when the user wants to deploy / serve / chat-with / benchmark a MiniCPM5 model and has not yet committed to a specific engine, or when they say…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.