# crit (pypi · crit)

Build, evaluate and serve a bespoke LLM inference engine for your own GPU with crit's commands.

- Trust score: 63/100 (medium)
- Change this week: −12
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `crit`: 63/100 (this document), [markdown](https://verifymcp.io/servers/crit-labs-crit/crit.md), [page](https://verifymcp.io/servers/crit-labs-crit/crit)

## Channel facts

- Registry: `pypi`
- Package: `crit`
- Version: `0.17.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 2 of 25 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to crit-labs/crit).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 2 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 33/100
  - 0% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 12725 tokens (~176/item across 72 items; 62 tools + 10 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 40/100
  - Stability observed for 12 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 96/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 88% of tool parameters carry a description.
- **Tool Safety**: 94/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 13 of 17 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "crit_eval_context" implies "eval" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 64 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the crit MCP server?

crit runs locally as a PyPI package, launched with uvx crit mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add crit-labs-crit -- uvx crit mcp
```

### Cursor

```json
{
  "mcpServers": {
    "crit-labs-crit": {
      "command": "uvx",
      "args": [
        "crit",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "crit-labs-crit": {
      "command": "uvx",
      "args": [
        "crit",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add crit-labs-crit -- uvx crit mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "crit-labs-crit": {
      "type": "local",
      "command": [
        "uvx",
        "crit",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add crit-labs-crit --command uvx --arg crit --arg mcp
```

### Hermes

```yaml
mcp_servers:
  crit-labs-crit:
    command: "uvx"
    args: ["crit", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "crit-labs-crit": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "crit",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add crit-labs-crit -t stdio -c uvx -a crit mcp
```

### Other

```json
{
  "mcpServers": {
    "crit-labs-crit": {
      "command": "uvx",
      "args": [
        "crit",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-20 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-18 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 61, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-16 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-14 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-12 (score 74, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-11 (score 59, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-09 (score 73)

First indexed and scored.

## MCP tools (62)

### `crit_run_create` (~187 tokens)

crit run create

Create a run and its first segment from a request

Input parameters:

- `from_engine` (string): Start from a crit-hub engine: its engines/<owner>/<name>/ folder (card.yaml, card.lock.json, evidence/) is recorded as the run's origin_engine
- `id` (string): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_resolve` (~143 tokens)

crit run resolve

Freeze the verified model and input identities

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_plan` (~170 tokens)

crit run plan

Record the next candidate's plan

Input parameters:

- `check` (boolean): Run the plan's checks and print the record crit would store, recording nothing (the plan command of a replay)
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_check` (~195 tokens)

crit run check

Append a case's check evidence to a candidate

Input parameters:

- `candidate` (string, required)
- `from_eval` (boolean|string): Instead of --record: record the arithmetic, functional and resources check of every case from the candidate's retained Eval result (default its newest). true gives --from-eval alone
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_benchmark` (~152 tokens)

crit run benchmark

Append a case's benchmark evidence to a candidate

Input parameters:

- `candidate` (string, required)
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_stop` (~148 tokens)

crit run stop

Stop the run with its reason, critique, headroom and cleanup

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_candidate` (~169 tokens)

crit run candidate

Allocate a candidate ID and retain its source and proposal

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): label, rationale, strategy, configuration, store_decisions, parent/origin IDs. A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `source` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_recon` (~210 tokens)

crit run recon

Gather the model's sampling, stop tokens, chat template and config into work/recon.json

Input parameters:

- `compare` (string): Instead: compare the run's model fingerprint with another checkpoint's (architecture, weight layout, tokenizer, template) and print what differs
- `drafter` (array): A companion drafter to record (EAGLE-3, DFlash, DSpark or crit models drafter output); repeatable
- `force` (boolean): Gather again over an existing work/recon.json
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_capture` (~255 tokens)

crit run capture

Write a case's chat request (captured/CASE/request.json) that renders to the workload's prompt tokens with the template variables candidates serve

Input parameters:

- `case` (string)
- `id` (string, required): Existing run identity
- `inputs` (string): Set the case's manifest row in this resolve payload (created when missing)
- `instruction` (string): Line after the text (default: a summary request; '' for none)
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `system` (string): A leading system message
- `template_kwargs` (string): chat_template_kwargs the request renders with, over recon's frozen template_variables (text or a file)
- `text` (string): File of the user message's text (default: a neutral passage); it is cut to whole words and padded to the exact count
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_build` (~252 tokens)

crit run build

Build a candidate's retained source with the recipe's build.command under a build attempt (log kept, attempt settled), then package the result

Input parameters:

- `candidate` (string, required)
- `drop` (array): Remove these build-folder paths (intermediates) before packaging; repeatable
- `id` (string, required): Existing run identity
- `no_package` (boolean): Build and settle only
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): Recipe: build {toolchain, command[, dependencies]}; the build's outputs are bound as dependencies, and the package is the plugin package Core's loader runs. A JSON object (written to a file for the c…
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number): Reservation length (default: the build process cap)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_package` (~169 tokens)

crit run package

Package a candidate's runnable files and manifest

Input parameters:

- `candidate` (string, required)
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): Recipe: build {toolchain, command[, dependencies]}. A JSON object (written to a file for the command) or a JSON file's path
- `root` (string): Run root; defaults to PROJECT/runs
- `source` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_reserve` (~142 tokens)

crit run reserve

Consume an attempt before a launch

Input parameters:

- `candidate` (string): Candidate owner; omit only for discovery
- `id` (string, required): Existing run identity
- `operation` (string, required)
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_settle` (~159 tokens)

crit run settle

Settle a reserved attempt: exit, logs, cleanup

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `record` (object|array|string, required): A JSON object (written to a file for the command) or a JSON file's path
- `reservation` (string, required): Reservation path relative to run
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_measure` (~203 tokens)

crit run measure

Benchmark the run's cases on a packaged candidate through crit serve, once its checks are recorded (check --from-eval)

Input parameters:

- `candidate` (string, required)
- `exploratory` (boolean): Measure even when the candidate's checks would leave its benchmarks exploratory (not recorded, or a required one did not pass), for telemetry or memory: a benchmark that does not qualify keeps the ca…
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number): Reservation length (default: the benchmark process cap)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_eval` (~469 tokens)

crit run eval

Run Eval on a packaged candidate through crit serve, quality against the run's model's scores of the fixed texts (scored once into the data)

Input parameters:

- `baseline` (string): Earlier Eval result to show KPI changes against
- `budget_minutes` (number): Eval's wall-clock budget, loads included (default: crit-eval's 45)
- `candidate` (string, required)
- `certify` (boolean): The candidate that will ship: stage 3 whatever the budget, then one request at the run's kv_tokens, which the resources check needs. On the candidate ladder the full Eval of candidate 5 on and of the…
- `data` (string, required): Eval data directory prepared from the run's model
- `id` (string, required): Existing run identity
- `label` (string)
- `only` (array): Run only these Eval parts (repeatable); default all
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `resume` (boolean|string): Go on from an Eval attempt that stopped (interrupted, failed, timed out, a disturbed or hung engine): its journal's requests are answered again, the engine loads for the requests left; default the ca…
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number): Reservation length (default: to the segment's deadline; each request is bounded by the rates the engine measured)
- `stage` (string): How far Eval measures (crit-eval's protocol stages): by default as far as its budget allows at the candidate's measured rates; 1, 2 or 3 at most that far; full every part as before stages. On the can…
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_serve` (~331 tokens)

crit run serve

Serve a packaged candidate before it is sealed through crit serve, under a check attempt, until Ctrl+C: for the checks a candidate passes before sealing

Input parameters:

- `candidate` (string, required)
- `check` (boolean): Run the standard serving checks (consecutive requests, system message, streaming, stop string, cancelling, tool call, logprobs, template switch, stopping), keep their report and record a functional c…
- `data` (string): With --check: crit-eval's prepared data for the run's model; the report adds the gate pre-check (honesty of short replies and one long reply, request history, device memory, the lower context), the g…
- `host` (string)
- `id` (string, required): Existing run identity
- `no_smoke` (boolean): With --check: leave out crit smoke, the quality component tests --check runs at the run's context and at a quarter of it (smoke/README.md)
- `port` (integer)
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number): Reservation length (default: the check process cap)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_ablate` (~277 tokens)

crit run ablate

Serve a candidate built from plugins with each variant of its plugins (as built, at its base, without each and with each alone): a short bench of the run's cases and crit smoke per variant, and what each plugin adds, costs or breaks (docs/PLUGINS.md)

Input parameters:

- `candidate` (string, required)
- `id` (string, required): Existing run identity
- `no_smoke` (boolean): Leave out crit smoke on each variant
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `repetitions` (integer): Repetitions per case and variant (default 3)
- `root` (string): Run root; defaults to PROJECT/runs
- `seconds` (number): Reservation length (default: the check process cap)
- `smoke_test` (array): Run only this crit smoke test on each variant (repeatable)
- `variant` (array): Serve only this variant (repeatable), e.g. full, base, without:ID, only:ID; crit plugins variants lists them
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_seal` (~141 tokens)

crit run seal

Close a candidate (sealed candidates are immutable)

Input parameters:

- `candidate` (string, required)
- `failure` (string): Retained failure message
- `id` (string, required): Existing run identity
- `lifecycle` (string, required)
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_select` (~119 tokens)

crit run select

Select a sealed eligible candidate

Input parameters:

- `candidate` (string, required)
- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_resume` (~240 tokens)

crit run resume

Open a new segment for more candidates, optionally amending the quality terms

Input parameters:

- `approved_by` (string): Who approved the amendment (required with --quality-budget or --exactness)
- `attempt_limit` (integer)
- `candidates` (integer): Candidates this segment builds (no working time budget)
- `exactness` (string): Amend the speculative exactness mode
- `external_agent_stopped` (boolean)
- `id` (string, required): Existing run identity
- `minutes` (integer): Time-budget segment instead, or the safety window with --candidates
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `quality_budget` (string): Amend the drift budget: any of ppl_ratio_max, kld_mean_max, kld_p99_max
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_cost` (~246 tokens)

crit run cost

Account the run's build cost from the agent's transcripts: wall time, tokens and API price per candidate, written to cost.json

Input parameters:

- `agent` (string): The agent and model that built the run, as the record names it
- `id` (string, required): Existing run identity
- `prices` (string): JSON object or file of {model: {input, cache_read, cache_write_5m, cache_write_1h, output}} in USD per million tokens, over the list prices
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `transcript` (array, required): A Claude Code session, Codex rollout or plain usage JSONL (repeatable)
- `until` (string): Count requests up to this UTC timestamp (default: the run's stop, else now)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_replay` (~306 tokens)

crit run replay

Copy the run as it stood when a candidate's Eval finished, for an agent to say what it would do next with today's crit and crit-eval (records nothing)

Input parameters:

- `agent` (string): Start an agent on every replay at once with this command (any harness; {brief}, {folder}, {root} and {number} name the replay's), wait for all, then collect
- `at` (string): The candidate whose newest completed Eval the replays start from
- `before` (string): Instead: the run as it stood just before this plan was recorded (with the work done toward it since its parent's Eval, without drafts of the plan)
- `collect` (boolean): Instead: check and list the plans the replays under --out wrote
- `count` (integer): Replays to make, one per agent (default 1)
- `id` (string, required): Existing run identity
- `out` (string, required): Folder of the replays: replay-1 ... replay-N, each a run root
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_show` (~118 tokens)

crit run show

Print the run, its state and its candidates as JSON

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_run_recover` (~123 tokens)

crit run recover

Explicit dead-owner lease recovery and projection rebuild; never resets attempts/deadlines

Input parameters:

- `id` (string, required): Existing run identity
- `project` (string): crit checkout the run follows, whose settings.toml it reads (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `root` (string): Run root; defaults to PROJECT/runs
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_run` (~1266 tokens)

crit eval run

Evaluate one engine (prepares the data first when missing)

Input parameters:

- `adapter` (string): Python file exporting create_eval_engine(context)
- `adaptive_sampled` (string): Repeat each sampled speed case at further seeds until its relative standard error reaches the protocol's target or its repetition cap (protocol sampled_speed.adaptive), recorded in the result; off by…
- `attribute_drift` (boolean): After quality, score it again on an engine opened with each of the adapter's exact_variants (one matrix group or arithmetic choice exact) and report each one's share of the drift budget
- `bandwidth` (number): Achievable device memory bandwidth in GB/s; overrides the --device value
- `baseline` (string): Earlier result of the same data to show KPI changes against
- `budget_minutes` (number): The staged run's wall-clock budget, loads included (default: the protocol's 45)
- `certify` (boolean): The candidate that will ship: stage 3 whatever the budget, then one request at the required context itself, which the capacity gate needs
- `chat_template` (string): Chat template (jinja) to render the prompts with, for a model that carries none (default: the one crit ships for the model's family); it becomes part of the model's identity; data prepared already mu…
- `config` (string): JSON configuration overrides for the adapter, text or a file, over the configuration.json packaged beside it
- `context` (integer): Context (prompt plus output) every engine is built and measured for: the run's kv_tokens. Default: crit-eval's max context for the model on the --device
- `context_reserve_gib` (number): Device memory kept out of the KV cache when crit-eval computes the max context: activations, workspaces, graphs and speed techniques (default: settings.toml context_reserve_gib, else the protocol's r…
- `data` (string, required): Prepared suite directory for this model
- `device` (string): Device ceilings from `crit eval probe` (bandwidth and GEMM rates)
- `exactness` (string): reported (default): agreement with plain greedy is shown and the quality budget judges the output; required: any difference fails the gate
- `jitter_seed` (integer): Draw the held-out prompts' and the long-context curve's lengths from this seed, a recorded result's jitter.seed, to measure at its lengths again (default: a new seed per run; a resumed round's from i…
- `keep_disturbed` (boolean): Finish the round even when a speed case's repetitions show a disturbed device (by default the round stops there; protocol speed.disturbed_spread)
- `label` (string): Name shown in comparisons
- `model` (string, required): Model directory passed to the adapter
- `no_journal` (boolean): Write no journal beside the result (by default every engine opened and request served is one line of OUT's .journal.jsonl, synced as it completes)
- `only` (array): Run only these parts (repeatable); default is all. context: the long-context curve and retrieval up to the required context and the speed cases again at a lower context; history: the same requests on…
- `out` (string, required): Result JSON path
- `package` (string): A crit engine package (plugins/ and configuration.json), which Core's eval-v1 adapter opens through Core's loader
- `profile` (string): A protocol profile fixing what the run measures (protocol profiles). hub: crit-hub submissions, 200,000 tokens of context, the curve at its two ends, one engine load
- `quality_budget` (string): Drift limits over the protocol defaults, e.g. '{"ppl_ratio_max": 1.02}'; keys ppl_ratio_max, kld_mean_max, kld_p99_max
- `quality_mode` (string): The quality mode: how much output drift from the checkpoint the engine may trade for speed, whatever format the checkpoint is stored in; both modes judge against the same reference (its stored weight…
- `repetitions` (integer): Override the protocol's measured repetitions
- `requested_context` (integer): The longest request wanted, which caps the max context crit-eval computes without --context (default: settings.toml context_tokens, else 200,000)
- `resume` (string): Go on from a round that stopped (interrupted, crashed, a disturbed device, a hung engine): its journal (R.journal.jsonl beside its result R.json) answers the requests it served, the engine loads only…
- `served_model` (string): With --url: the model to request (default: the one the server lists)
- `stage` (string): How far a run without a profile measures (protocol stages): by default as far as the budget allows at the engine's measured rates; 1, 2 or 3 at most that far; full every part at the protocol's repeti…
- `url` (string): Base URL of an OpenAI-compatible server the engine runs behind, for example http://127.0.0.1:8000/v1 (needs --context: the context the server was started with)
- `vram_headroom_gib` (number): Device memory left free when crit-eval computes the max context (default 1)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)
- `warmups` (integer): Override the protocol's warmup runs

### `crit_eval_precheck` (~365 tokens)

crit eval precheck

In minutes, the gates a candidate most often fails a whole round on: honesty of short replies and of one long reply, the request history around them, device memory and (with an adapter) the lower context

Input parameters:

- `adapter` (string): Python file exporting create_eval_engine(context)
- `chat_template` (string): Chat template (jinja) to render the prompts with, for a model that carries none (default: the one crit ships for the model's family); it becomes part of the model's identity
- `config` (string): JSON configuration overrides for the adapter
- `context` (integer, required): Context the engine is built for (the run's kv_tokens)
- `data` (string, required): Prepared suite directory for this model
- `model` (string, required): Model directory passed to the adapter
- `no_lower` (boolean): Skip the lower-context reopen
- `out` (string): Write the items as JSON here
- `package` (string): A crit engine package, opened through Core's loader
- `quality_mode` (string): The run's quality mode (default speed): speed bounds honesty as Eval does and lets history part at near-ties; preserve does neither
- `served_model` (string): With --url: the model to request
- `url` (string): Base URL of an OpenAI-compatible server the engine runs behind (no lower-context check: a server cannot be opened again)
- `vram_headroom_gib` (number): Device memory to find free after the load (default: settings.toml vram_headroom_gib, else 1)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_context` (~271 tokens)

crit eval context

The max context for a model on a device: the model's positions and the KV cache that fits next to its weights

Input parameters:

- `context_reserve_gib` (number): Device memory kept out of the KV cache for workspaces and speed techniques (default: settings.toml context_reserve_gib, else the protocol's reserve_gib)
- `device` (string, required): Device file from `crit eval probe`
- `drafter` (array): A companion drafter the engine may load beside the model; its stored weights are kept out of the KV cache (repeatable)
- `json` (boolean): Print the computation as JSON
- `model` (string, required): Model directory
- `ram_headroom_gib` (number): Host memory left free, for the placement scenario (default: settings.toml ram_headroom_gib, else 2)
- `requested_context` (integer): The longest request wanted (default: settings.toml context_tokens, else 200,000)
- `vram_headroom_gib` (number): Device memory left free (default: settings.toml vram_headroom_gib, else 1)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_probe` (~214 tokens)

crit eval probe

Measure device bandwidth and GEMM rates per weight format (needs nvcc, or hipcc on ROCm)

Input parameters:

- `backend` (string): Device API to probe (default: cuda when nvcc is found, else hip when hipcc is)
- `devices` (string): Probe several GPUs (CUDA): each one's figures and the copy rate between each pair, for multi-GPU limits (default: device 0 alone)
- `hipcc` (string): hipcc to build the HIP probe with (default: PATH, ROCM_PATH, /opt/rocm*)
- `nvcc` (string): nvcc to build the probe with (default: PATH, CUDA_HOME, /usr/local/cuda*)
- `out` (string, required): Device JSON path for `run --device`
- `repeats` (integer): Probe runs; each value is the median
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_status` (~188 tokens)

crit eval status

Gates, goals, KPIs against their physical limits, gaps and missing inputs

Input parameters:

- `baseline` (string): Earlier result to show KPI changes against
- `data` (string): The data directory the result was measured on: its model arithmetic prices prefill for a result that does not record it
- `device` (string): Price prefill and time to first token with this `crit eval probe` result's rates instead of the result's own device
- `json` (boolean): Print the status as JSON
- `kernels` (string): A kernel trace of the engine (crit eval kernels): its prefill GPU time per floor term against the term's floor, with a gap each
- `result` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_prepare` (~179 tokens)

crit eval prepare

Freeze the suite as token ids for one model

Input parameters:

- `chat_template` (string): Chat template (jinja) to render the prompts with, for a model that carries none (default: the one crit ships for the model's family); it becomes part of the model's identity
- `data` (string, required)
- `model` (string, required)
- `sampling` (string): The user's sampling for the sampled speed suite in place of the model's generation_config.json, e.g. temperature=0.6,top_p=0.95,top_k=20 (temperature required; top_p, top_k, min_p optional). Results…
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_reference` (~147 tokens)

crit eval reference

Score the prepared quality texts once on the checkpoint they were prepared from and store the scores under the data (torch + transformers, GPU; stop any engine first)

Input parameters:

- `allowance` (boolean): Also score the texts with the activations quantized as the checkpoint declares and store how far that lands from the scores (allowance.json): what the format itself costs, reported, not judged; a sec…
- `data` (string, required): Prepared suite directory
- `model` (string, required): The checkpoint the data was prepared from
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_fetch` (~169 tokens)

crit eval fetch

Fetch the checkpoint's reference package (prepared data and reference scores) into the data, so a run needs only the engine

Input parameters:

- `chat_template` (string): Chat template (jinja) to render the prompts with, for a model that carries none (default: the one crit ships for the model's family); it becomes part of the model's identity; the package was prepared…
- `data` (string, required): Data directory to write
- `model` (string, required): The checkpoint the engine serves
- `packages` (string): Package source: a folder or an https base URL (default: settings.toml's eval_packages)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_pack` (~79 tokens)

crit eval pack

Add prepared data scored by the reference to a package folder

Input parameters:

- `data` (string, required): Prepared suite directory holding reference scores
- `packages` (string, required): Package folder to add it to
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_journal` (~89 tokens)

crit eval journal

How far a round got: its journal's engines, parts and requests, replayed and live, and how it ended

Input parameters:

- `journal` (string, required): A round's journal (R.journal.jsonl beside its result R.json)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_compare` (~58 tokens)

crit eval compare

Print a side-by-side table of result files

Input parameters:

- `results` (array, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_pin` (~172 tokens)

crit eval pin

Record one engine's plain greedy output of every speed case as the data directory's pinned continuation (decode is then measured on that text)

Input parameters:

- `adapter` (string): Python file exporting create_eval_engine(context)
- `config` (string): JSON configuration overrides for the adapter, text or a file, over the configuration.json packaged beside it
- `context` (integer): Context the engine is built for (the run's kv_tokens)
- `data` (string, required): Prepared data directory to pin the continuation in
- `model` (string, required): Model directory passed to the adapter
- `package` (string): A crit engine package, opened through Core's loader
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_eval_ab` (~262 tokens)

crit eval ab

Alternate two engines' speed runs in one session and report paired ratios

Input parameters:

- `adapter` (string): Adapter of engine A
- `adapter_b` (string): Adapter of engine B (default: engine A's adapter)
- `config` (string): JSON configuration overrides of engine A (text or a file), over its packaged configuration.json
- `config_b` (string): JSON configuration overrides of engine B (text or a file), over its packaged configuration.json
- `context` (integer): Context both engines are built for (the run's kv_tokens)
- `data` (string, required)
- `model` (string, required)
- `out` (string, required): Result JSON path
- `package` (string): Engine A's crit package, opened through Core's loader
- `package_b` (string): Engine B's crit package (default: engine A's engine)
- `repetitions` (integer): Measured repetitions per engine and round
- `rounds` (integer): Rounds; each round runs both engines, order alternating
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)
- `warmups` (integer): Warmup runs per engine and round

### `crit_eval_kernels` (~360 tokens)

crit eval kernels

Trace every kernel of the speed cases (CUPTI, Linux) and rank them per phase by time, launch width and share of peak

Input parameters:

- `adapter` (string): Python file exporting create_eval_engine(context)
- `backend` (string): Device API the engine runs on: cuda (CUPTI) or hip (rocprofiler-sdk)
- `case` (array): Trace only these speed cases (repeatable); default all
- `config` (string): JSON configuration overrides for the adapter, text or a file, over the configuration.json packaged beside it
- `context` (integer): Context the engine is built for (the run's kv_tokens)
- `data` (string, required): Prepared suite directory for this model
- `device` (string): Device ceilings from `crit eval probe` for share of peak
- `hipcc` (string): hipcc of a ROCm that ships rocprofiler-sdk (--backend hip)
- `model` (string, required): Model directory passed to the adapter
- `nvcc` (string): nvcc of a CUDA toolkit that ships CUPTI
- `out` (string, required): Kernel report JSON path
- `package` (string): A crit engine package, opened through Core's loader
- `top` (integer): Kernels listed per phase
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)
- `work` (string): kernel_work rules ahead of the adapter's own, as JSON text or a file: [{"match": NAME_PART, "term": matmul|attention|recurrent|other|draft, "format": nvfp4|fp8|bf16, ...}]

### `crit_eval_workbench` (~205 tokens)

crit eval workbench

Check, time or profile a kernel on its workbench folder (crit kernels new): reference, floor, yardstick

Input parameters:

- `action` (string, required)
- `device` (string): bench: a `crit eval probe` result, for the floor
- `folder` (string, required): The workbench folder
- `iters` (integer): bench: timed calls per shape and column count
- `ncu` (string): profile: Nsight Compute's ncu, to add its sections
- `out` (string): check and bench: the result JSON (default FOLDER/check.json, bench.json)
- `python` (string): The engine's Python (torch and the GPU); default this one
- `shape` (integer): One shape of kernel.json by index (profile: default the first)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_pull` (~645 tokens)

crit pull

crit pull OWNER/NAME: install a crit-hub engine, so that crit serve --engine OWNER/NAME serves it. It reads the engine's card (from a crit-hub checkout with --hub, else crit-hub's index.json), checks the card's requirements against this machine (a crit eval probe result, and nvcc), fetches the engine's source at the commit the card pins (from a crit-engines checkout with --engines, else its repository), checks its configuration against the sealed run's in card.lock.json, fetches the checkpoint at its pinned Hugging Face revision (or takes a local folder with --model) and checks every file against card.lock.json, fetches and checks the card's drafter downloads the same way, runs the card's build command (or unpacks a prebuilt artifact whose toolchain matches this machine instead), and installs the built package in the engine store (crit.pull.store). Nothing is installed until every step has passed.

Input parameters:

- `build_from_source` (boolean): Build even when one of the card's prebuilt artifacts matches this machine
- `build_timeout` (number): Seconds the build may take (default: 1800)
- `checkpoint` (string): The checkpoint, when the engine was measured on several
- `context` (integer): Context the engine serves at (default: the context its card measured)
- `device` (string): A crit eval probe result to check the requirements against (default: settings.toml's device, else a probe run now)
- `download` (array): A local copy of one of the card's downloads (a drafter's folder, an artifact's file), checked like a download (repeatable; default: fetch it from Hugging Face)
- `engine` (string): The crit-hub engine, as OWNER/NAME
- `engines` (string): Take the source from this crit-engines checkout, which holds the pinned commit (default: fetch that commit from the card's source repository)
- `force` (boolean): Install again over an installed engine
- `hub` (string): Read the card from this crit-hub checkout (default: crit-hub's index.json)
- `ignore_requirements` (boolean): Install even when this machine does not meet the card's requirements
- `index` (string): crit-hub's index.json, a URL or file (default: https://crit-hub.dev/index.json)
- `list` (boolean): List the installed engines instead
- `model` (string): A local copy of the checkpoint, checked file by file and hard-linked into the store (default: download it at the pinned Hugging Face revision)
- `project` (string): crit checkout whose settings.toml gives the device and headroom and whose engines/ is the default store (default: this checkout); a crit installed without a checkout takes any folder (default: the cu…
- `store` (string): Engine store (default: PROJECT/engines)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_serve` (~901 tokens)

crit serve

crit serve: load a sealed candidate once and answer OpenAI-compatible requests until stopped.

Input parameters:

- `api_key` (array): Require this bearer key; repeat for several (default: the comma-separated keys in the CRIT_API_KEY environment variable, else none)
- `api_key_file` (string): Also accept the keys in this file, one per line; blank lines and lines starting with # are skipped
- `candidate` (string): Candidate ID (default: the run's selected candidate)
- `cors_origin` (string): Allow browser requests from this origin, for example http://localhost:3000 or *
- `engine` (string): Serve an engine crit pull installed, as OWNER/NAME
- `host` (string): Address to listen on (default: 127.0.0.1, this machine only)
- `idle_unload` (number): Unload the engine's weights after this many seconds without a request; the next request loads it again (default: stay loaded)
- `lenient` (boolean): Ignore request parameters crit does not apply (unknown ones, sampling fields the package does not declare, extra samplers) instead of refusing them with 400; responses list them in X-Crit-Ignored-Par…
- `load_timeout` (number): Seconds loading the candidate at startup may take (default: 600 plus the model's size at 200 MB/s, or at 50 MB/s with --verify-model)
- `max_concurrency` (integer): Run at most N requests at once, below the engine's declared capacity (max_concurrent_requests; default: the engine's)
- `max_queue` (integer): Requests that may wait while the engine is busy; one more is refused at once with 429 (Anthropic 529, /api/chat 503) and Retry-After (default: 64)
- `model_name` (string): Model ID reported to clients (default: RUN_ID/CANDIDATE_ID)
- `models` (string): JSON catalog of named models from sealed runs (docs/SERVING.md)
- `port` (integer): Port (default: 8000)
- `project` (string): crit repository (default: this checkout); a crit installed without a checkout takes any folder (default: the current one)
- `queue_timeout` (number): Seconds a request may wait for the engine before it is refused the same way (default: no limit; --timeout starts when the engine takes the request)
- `reasoning_alias` (boolean): Return reasoning under "reasoning" as well as "reasoning_content", for clients that read the field reasoning (off by default: a client that joins every field of a delta, as crit Eval does, would read…
- `recover_runtime` (boolean): Recover a dead runtime owner after verifying its processes settled, then exit
- `resident_ram_gib` (number): Optional cap on retained model bytes in host memory
- `resident_vram_gib` (number): Optional cap on retained model bytes in device memory
- `run` (string): Run ID (default: the workspace's only run)
- `sse_ping_interval` (number): Send a keep-alive ping on an OpenAI or Anthropic stream after this many quiet seconds, so proxies and clients do not close it while a model loads or a prompt prefills; 0 sends none (default: 15)
- `ssl_certfile` (string): Serve HTTPS with this PEM certificate chain
- `ssl_keyfile` (string): The certificate's PEM private key (default: the key in --ssl-certfile)
- `store` (string): Installed-engine store --engine reads (default: PROJECT/engines, where crit pull installs)
- `timeout` (number): Seconds one request may run (default: 600)
- `verify_model` (boolean): Read and SHA-256 every model file against the run's frozen manifest before loading (default: check file sizes only and load right away)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)
- `workspace` (string): Folder containing the run-* project directories
- `write_launchers` (boolean): Write serve.cmd and serve.sh into the run folder, which start this exact command, then exit

### `crit_kernels_target` (~52 tokens)

crit kernels target

Observe host OS/architecture; ABI remains explicit

Input parameters:

- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_inventory` (~57 tokens)

crit kernels inventory

Hash local artifact files without importing them

Input parameters:

- `root` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_search` (~61 tokens)

crit kernels search

Search local implementation declarations

Input parameters:

- `catalog` (string, required)
- `query` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_inspect` (~67 tokens)

crit kernels inspect

Explain every declared applicability match, rejection or unknown

Input parameters:

- `catalog` (string, required)
- `request` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_retain` (~104 tokens)

crit kernels retain

Copy and verify a selected dependency into a new directory

Input parameters:

- `catalog` (string, required)
- `destination` (string, required)
- `max_bytes` (integer)
- `reason` (string, required)
- `request` (string, required)
- `root` (string, required)
- `select` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_verify` (~59 tokens)

crit kernels verify

Recheck a retained dependency's bytes and applicability

Input parameters:

- `directory` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_kernels_new` (~377 tokens)

crit kernels new

Scaffold a workbench folder for a kernel: reference, shapes, yardstick, harness (measure it with crit eval workbench)

Input parameters:

- `column_invariant` (string)
- `columns` (string): column (token) counts, comma-separated
- `format` (string): bf16, fp8 or nvfp4 (NVFP4 weights against bf16 activations) for gemv and gemm
- `from` (string): a kernel-builder project to start src/ from (a crit-kernels project, a Hub kernel's source); without it, kernel-builder init starts one
- `model` (string): take the shapes from this checkpoint's matrices in the format
- `name` (string, required)
- `op` (string, required): gemv or gemm (a working start in bf16, fp8 or nvfp4), or any other operation name for a harness to fill in
- `repeatable` (string): no: the kernel may give other bits on a repeat (atomics, a split the workload chooses); the check judges repeats within the tolerance. For quality mode speed engines
- `root` (string)
- `run` (string): the run folder, for --starter
- `shape` (array): N,K (repeatable)
- `starter` (boolean): the kernel --from copies is the starter (crit-kernels' workbench-starter: a simple, correct gemv/gemm in bf16 and fp8); allowed from a run's fourth candidate on
- `tolerance` (number)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)
- `yardstick` (string): the provider to time beside the kernel (provider syntax of plan levers)

### `crit_models_plan` (~92 tokens)

crit models plan

Resolve a recipe against a checkpoint's headers: targets and bytes

Input parameters:

- `json` (boolean): Print the resolved recipe and plan as JSON
- `recipe` (string, required): models_recipe JSON
- `source` (string, required): Unquantized source model directory
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_models_ptq` (~149 tokens)

crit models ptq

Quantize a checkpoint and write its models_transform record

Input parameters:

- `calibration` (string): JSONL of {"text": ...} documents unrelated to Eval (gptq only)
- `device` (string): torch device (default: cuda when available, else cpu)
- `out` (string, required): New or empty directory for the transformed checkpoint
- `recipe` (string, required): models_recipe JSON
- `record` (string, required): New models_transform JSON outside the source and output
- `source` (string, required): Unquantized source model directory
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_models_drafter` (~161 tokens)

crit models drafter

Distill a draft head for speculative decoding from the target itself and write its models_transform record

Input parameters:

- `calibration` (string, required): JSONL of {"text": ...} documents unrelated to Eval
- `device` (string): torch device (default: cuda when available, else cpu)
- `out` (string, required): New or empty directory for the drafter
- `recipe` (string, required): models_recipe JSON with method drafter
- `record` (string, required): New models_transform JSON outside the source and output
- `source` (string, required): The target model directory (the checkpoint the engine serves)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_models_eval` (~126 tokens)

crit models eval

Bind the Eval result of an engine serving the output to its record, with its quality replies scored on the source checkpoint

Input parameters:

- `data` (string, required): Eval data directory prepared from the source checkpoint
- `evaluation` (string, required): New models_evaluation JSON
- `record` (string, required): models_transform JSON
- `result` (string, required): crit eval run --url result of the engine serving the output; stop the server first
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_models_verify` (~61 tokens)

crit models verify

Re-hash a transform's output and source against its record

Input parameters:

- `record` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_inference_list` (~55 tokens)

crit inference list

List the techniques by category

Input parameters:

- `json` (boolean)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_inference_search` (~67 tokens)

crit inference search

The techniques whose metadata holds every word of the query

Input parameters:

- `json` (boolean)
- `query` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_inference_show` (~65 tokens)

crit inference show

One technique's guidance, symbols and files

Input parameters:

- `json` (boolean)
- `query` (string, required)
- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_inference_check` (~51 tokens)

crit inference check

Check the techniques' code against their metadata

Input parameters:

- `wait_seconds` (number): Seconds to wait for the command to end before returning its job to wait on with crit_job_wait (the command keeps running)

### `crit_job_wait` (~77 tokens)

Wait on a job

Wait for a job to end, at most SECONDS; returns its result once it ended, else its state and newest errors

Input parameters:

- `job` (string, required): The job a command's call returned, such as job-3
- `seconds` (number): Longest wait (at most 3600); call again to go on

### `crit_job_output` (~79 tokens)

Read a job's logs

A job's command output (its JSON result) or errors (progress and reports) from a byte offset; offset -1 reads the end

Input parameters:

- `job` (string, required): The job a command's call returned, such as job-3
- `limit` (integer)
- `offset` (integer)
- `stream` (string)

### `crit_job_stop` (~76 tokens)

Stop a job

Interrupt a running job as Ctrl+C would (crit releases its leases and settles what it can), ending its process tree after grace_seconds; an Eval stopped so goes on with crit_run_eval resume

Input parameters:

- `grace_seconds` (number)
- `job` (string, required): The job a command's call returned, such as job-3

### `crit_jobs` (~20 tokens)

List jobs

This server's jobs: state, exit code, logs

### `crit_serve_status` (~67 tokens)

Ask crit serve

A running crit serve's /health (loaded engine, readiness, capacity) and /v1/models

Input parameters:

- `api_key` (string): One of the server's --api-key values, if it has any
- `url` (string): The server, without /v1

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/crit-labs-crit/crit#diagnostics

## Score history

- 2026-11-21: 63
- 2026-11-20: 63
- 2026-11-19: 62
- 2026-11-18: 62
- 2026-11-17: 61
- 2026-11-16: 76
- 2026-11-15: 75
- 2026-11-14: 75
- 2026-11-13: 74
- 2026-11-12: 74
- 2026-11-11: 59
- 2026-11-10: 73
- 2026-11-09: 73

## Common questions

### What is the crit MCP server?

crit is an MCP server listed in the public MCP registry as io.github.crit-labs/crit. Build, evaluate and serve a bespoke LLM inference engine for your own GPU with crit's commands. This page covers its PyPI package (crit).

### Is the crit MCP server safe to use?

crit scores 63 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the crit MCP server expose?

crit exposes 62 tools: crit_run_create, crit_run_resolve, crit_run_plan, crit_run_check, crit_run_benchmark, and 57 more. Their descriptions and schemas cost roughly 12,417 tokens of context every time the server is loaded.

### Is the crit MCP server still maintained?

crit is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the crit MCP server under?

crit declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the crit MCP server?

VerifyMCP ran 15 checks on crit, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about crit: Malware scan. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/crit/
- Socket report: https://socket.dev/pypi/package/crit
- Repository: https://github.com/crit-labs/crit
- Website: https://crit-hub.dev/
- Changelog RSS feed: https://verifymcp.io/servers/crit-labs-crit/crit.xml
- Changelog JSON feed: https://verifymcp.io/servers/crit-labs-crit/crit/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/crit-labs-crit/crit.json
- HTML version of this page: https://verifymcp.io/servers/crit-labs-crit/crit
