# Guardian Engine (remote · api.kaimeilabs.dev)

Deterministic recipe verification engine — validates AI-generated recipes against master SOPs.

- Trust score: 62/100 (medium)
- Change this week: +2
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `api.kaimeilabs.dev`: 62/100 (this document), [markdown](https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api.md), [page](https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api)

## Channel facts

- Endpoint: `https://api.kaimeilabs.dev/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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-08-03.

- **Endpoint Security**: 46/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 7 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS not yet verified: we couldn't determine whether a plaintext access path exists.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 73/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2422 tokens (~346/item across 7 items; 7 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http dev-kaimeilabs-guardian-engine https://api.kaimeilabs.dev/mcp
```

### Codex

```toml
[mcp_servers.dev-kaimeilabs-guardian-engine]
url = "https://api.kaimeilabs.dev/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dev-kaimeilabs-guardian-engine": {
      "type": "remote",
      "url": "https://api.kaimeilabs.dev/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add dev-kaimeilabs-guardian-engine --url https://api.kaimeilabs.dev/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  dev-kaimeilabs-guardian-engine:
    url: "https://api.kaimeilabs.dev/mcp"
```

### Other

```json
{
  "mcpServers": {
    "dev-kaimeilabs-guardian-engine": {
      "type": "http",
      "url": "https://api.kaimeilabs.dev/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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-08-03 (score 62, +1)

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

### 2026-07-31 (score 61, −1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 62, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 62, +1)

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

### 2026-07-28 (score 61, +1)

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

### 2026-07-27 (score 60, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 60)

First indexed and scored.

## MCP tools (7)

### `verify_recipe` (~745 tokens)

Verify a candidate recipe against a Guardian master recipe.

Uses deterministic graph-based verification to check technique, temperature,
timing, cooking medium, and required ingredients.

\**Verdict**: `verdict` is strictly PASSED or FAILED and is policy-driven — any CRITICAL
finding fails the recipe; more than 5 WARNINGs also fail. There is no score in the
response (ADR-013): gate on `verdict` and explain failures from `findings`.

\**Field audience**: `issue` is a machine-readable code for programmatic handling — never
show it to end users. Use `title` and `suggested_correction` as the user-facing fields.

Returns structured JSON by default (machine-actionable findings and patches);
response_format="text" renders a human-readable report. Both formats are
transparent (ADR-009 / ADR-018): exact values and ingredient names included.

Input parameters:

- `candidate_json`: The full candidate recipe as a JSON string or object. Expected schema: {"title": "<string>", "cuisine": "<string>", "serves": <int>, "ingredients": [{"name": "<string>", "quantity": "<string>"}], "st…
- `dish`: Alias for dish_name — for backward compatibility with production clients.
- `dish_name` (string): Name of the dish to verify against (e.g. 'carbonara', 'rendang', 'roast-chicken', 'confit', 'cheesecake', 'kung-pao', 'fried-chicken', 'brisket', 'wellington', 'cheese-souffle'). Use list_dishes() to…
- `master_json`: Optional user-supplied master SOP to verify against (BYO master, ADR-018), as a JSON string or object using the same schema as catalog masters (dish_name, steps[], required_ingredients[]; see get_mas…
- `operator_id`: Optional audit identifier for the calling operator (letters, digits, hyphens; max 64 chars). Tags the verification in the tamper-evident log and compliance record. Defaults to 'anonymous'.
- `original_prompt`: RECOMMENDED for best results. Include the user's original cooking request. Copy the user's exact message that triggered this recipe (e.g., 'Make me a spicy vegan rendang' or 'Generate a traditional c…
- `response_format` (string): Response format: 'json' (default — machine-actionable verdict, findings, and patches) or 'text' (human-readable report).
- `session_id`: Optional session ID to track an agent's improvement loop across multiple attempts.

Output parameters:

- `result` (string)

### `fix_recipe` (~434 tokens)

Deterministically repair a candidate recipe against a Guardian master.

Verifies the candidate, applies every machine-actionable correction the
symbolic engine produced (missing ingredients, quantities, temperatures,
durations, cooking media, ingredient substitutions), then re-verifies the
result. No LLM is used — the repair is a deterministic function of the
candidate recipe and the master ruleset.

Findings that need recipe-authoring judgement — adding a whole cooking
phase, rewriting step instructions, ingredient-ratio rebalancing — are not
auto-applied; they are returned under `patches_skipped`. Allergen findings
are never auto-fixed. The response reports the verdict before and after so
the caller can see exactly what was resolved.

Note: `verdict_after` may still be FAILED when structural changes (e.g.
adding a cooking step, rebalancing ingredient ratios) are needed. These
require recipe-authoring judgement and are returned under `patches_skipped`.
Callers should NOT assume a fixed recipe will pass verification.

Input parameters:

- `candidate_json`: The full candidate recipe as a JSON string or object — same schema as verify_recipe's candidate_json (title, cuisine, ingredients[], steps[]).
- `dish`: Alias for dish_name — for backward compatibility with production clients.
- `dish_name` (string): Name of the dish to repair against (e.g. 'carbonara', 'rendang', 'roast-chicken'). Use list_dishes() to see all available recipes and their aliases.
- `master_json`: Optional user-supplied master SOP to repair against (BYO master, ADR-018), same schema as catalog masters. When provided, the catalog is bypassed and dish_name may be omitted; patches (including sugg…
- `original_prompt`: Optional. The user's original cooking request, used only for safety-context awareness during verification. Does not change which fixes are applied.
- `response_format` (string): Response format: 'json' (default — includes the full fixed_recipe object) or 'text' (human-readable report).

Output parameters:

- `result` (string)

### `list_dishes` (~128 tokens)

List all available master dishes with rich metadata.

Returns:
    Dictionary with `schema_version` and a `dishes` list. Each dish includes
    slug, title, cuisine, region, aliases, and complexity.

Input parameters:

- `cuisine_filter` (string): Optional cuisine to filter by. Case-insensitive exact match against the dish's cuisine field. Valid values: italian | french | spanish | british | thai | chinese | indian | indonesian | japanese | ma…

### `get_master` (~256 tokens)

Return the canonical master recipe for a dish (read-only, no LLM).

Enables compare-then-verify agentic loops: fetch the master, diff it against the
user's recipe, then call verify_recipe — instead of verifying blind. Pure knowledge-base
lookup, no LLM in the hot path.

Master content is transparent by default (ADR-009 / ADR-010): exact temperatures, timings,
and EU FIC 1169/2011 allergen codes are returned verbatim, never obfuscated. No score is
included (ADR-013) — this is reference data, not a verdict.

Returns ingredients, steps (technique/temperature/timing/medium), and the EU FIC allergens
derived from the required ingredients. Unknown dishes return a structured UNKNOWN_DISH error.

Input parameters:

- `dish_name` (string): Name or alias of the dish to fetch the canonical master recipe for (e.g. 'carbonara', 'spaghetti bolognese', 'angel food cake'). Alias resolution and slug normalisation are applied. Use list_dishes()…
- `response_format` (string): Response format: 'json' (default, structured) or 'text' (human-readable summary).

Output parameters:

- `result` (string)

### `check_safety` (~182 tokens)

Run master-independent safety checks on a candidate recipe.

Works for ANY recipe — no dish resolution, no master SOP required. Checks
poultry internal-temperature safety and scans all ingredients for the 14
EU FIC 1169/2011 Annex II allergen groups. The verdict is a deterministic
function of (candidate, kb_version_hash) — no LLM involvement.

Use this when verify_recipe has no matching master for the dish: the
safety layer still applies to every recipe.

Returns:
    Safety envelope: verdict (PASSED/FAILED per the zero-critical policy
    gate), safe flag, issues found, and the pinned kb_version_hash.

Input parameters:

- `candidate_json` (string, required): The full candidate recipe as a JSON string. Checked for poultry internal temperature safety (≥74°C) and EU FIC 1169 allergen presence.

### `check_allergens` (~289 tokens)

Check ingredients for EU FIC 1169/2011 allergen compliance.

Returns a detailed audit trace mapping each ingredient to its EU Annex II
allergen group with entry numbers and labels. The safety verdict is
deterministic — no LLM involvement in the decision.

Use check_all_eu_allergens=True for food labelling (detect all allergens).
Use restrictions=['dairy', 'gluten'] to check for specific user allergies.

Input parameters:

- `check_all_eu_allergens` (boolean): If True, scans for all 14 EU Annex II allergens regardless of restrictions list. Use this for food labelling (declare all allergens present).
- `dish_name`: Optional dish name for reporting context.
- `ingredients` (array, required): List of ingredient names (freeform or canonical IDs). Examples: ['butter', 'wheat_flour', 'eggs', 'peanut_butter']
- `response_format` (string): Response format: 'text' (default) or 'json'. Use 'json' for machine-actionable output.
- `restrictions`: Allergen group IDs to check against user restrictions. Valid IDs: gluten, crustaceans, eggs, fish, peanuts, soy, dairy, tree_nuts, celery, mustard, sesame, sulphites, lupin, molluscs. If None and che…

Output parameters:

- `result`

### `verify_dietary_claim` (~188 tokens)

Verify that a recipe satisfies a dietary claim (vegan, halal, gluten-free, ...).

Reuses the existing allergen-detection logic plus a curated forbidden-ingredient
map (apps/guardian/knowledge/dietary_claims.yaml). Returns a structured verdict
with the specific offending ingredients and a short justification — never a
vague paraphrase.

Input parameters:

- `candidate_json` (string): Recipe JSON string (CandidateRecipe schema). Expected shape: {"title": "...", "ingredients": [{"name": "..."}, ...], "steps": [...]}. Only the ingredient list is required for dietary verification.
- `claim` (string): Dietary claim to verify: vegan | vegetarian | gluten_free | dairy_free | nut_free | halal | kosher.
- `response_format` (string): Response format: 'text' (default, human-readable) or 'json' (machine-actionable).

Output parameters:

- `result` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api#diagnostics

## Score history

- 2026-08-03: 62
- 2026-08-02: 61
- 2026-08-01: 61
- 2026-07-31: 61
- 2026-07-30: 62
- 2026-07-29: 62
- 2026-07-28: 61
- 2026-07-27: 60
- 2026-07-26: 60

## Links

- Remote endpoint: https://api.kaimeilabs.dev/mcp
- Repository: https://github.com/kaimeilabs/guardian-api-docs
- Changelog RSS feed: https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api/changelog.json
- HTML version of this page: https://verifymcp.io/servers/dev-kaimeilabs-guardian-engine/api