# Verificate MCP (remote · mcp.verificate.ai)

Agentic code review, no signup to try: reality gates + frontier-model review, with veto.

- Trust score: 61/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-04

## Components

- remote · `mcp.verificate.ai`: 61/100 (this document), [markdown](https://verifymcp.io/servers/ai-verificate-mcp/mcp.md), [page](https://verifymcp.io/servers/ai-verificate-mcp/mcp)

## Channel facts

- Endpoint: `https://mcp.verificate.ai/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.8.7`

## 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-04.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - 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**: 72/100
  - 100% 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 1042 tokens (~173/item across 6 items; 4 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: schema churn in the 4 days we've observed: 0 tool removals, 1 breaking changes, 1 auth/transport breaks, 0 additions.
- **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**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http ai-verificate-mcp https://mcp.verificate.ai/mcp
```

### Codex

```toml
[mcp_servers.ai-verificate-mcp]
url = "https://mcp.verificate.ai/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-verificate-mcp": {
      "type": "remote",
      "url": "https://mcp.verificate.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-verificate-mcp --url https://mcp.verificate.ai/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-verificate-mcp:
    url: "https://mcp.verificate.ai/mcp"
```

### Other

```json
{
  "mcpServers": {
    "ai-verificate-mcp": {
      "type": "http",
      "url": "https://mcp.verificate.ai/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 61, −2)

- [security regression] A breaking change shipped without a version bump: still 0.7.1
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “validate_ai_output” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 143 → 173
- [functional regression] “validate_ai_output” changed the type of “context”: object → object|string
- [functional] Schema quality: excellent → good
- [cosmetic] “validate_ai_output” reworded the description of “validation_type”
- [cosmetic] “validate_ai_output” reworded the description of “context”
- [cosmetic] “validate_ai_output” reworded the description of “ai_output”
- [cosmetic] Tool “validate_ai_output” changed its title: Gate AI-written code → Gate AI-written output (code or documents)

### 2026-08-01 (score 63, −3)

- [security regression] Stability: unverified → fail
- [security improvement] Authorization: fail → partial
- [functional improvement] Stability: unverified → 0.03

### 2026-07-31 (score 66)

First indexed and scored.

## MCP tools (4)

### `validate_ai_output` (~312 tokens)

Gate AI-written output (code or documents)

The merge gate for ANY AI-written output — code, documentation, reports, emails, configs: returns a binary approve/reject verdict with veto power — e.g. it rejects code calling the nonexistent stripe.Inventory API, an N+1 loop with the latency arithmetic to prove it, or a doc claiming success with no evidence. Deterministic reality gates (mock/placeholder veto, gaming and bypass detection, invented-API checks) run first and cannot be overridden; a frontier-model review (ISO/IEC 25010) then scores quality, accuracy, reliability and tech debt. Read-only: nothing is executed. Call it on every AI-generated deliverable before accepting it; use validate_plan for plans, analyze_code for an advisory report without a verdict.

Input parameters:

- `ai_output` (string, required): The AI-generated output to gate — source code (a diff, function or whole file, any mainstream language) or prose (documentation, a report, an email, release notes).
- `context` (object|string): Optional review context — an object like {"language": "cpp", "scale": "10k req/s"} ('language' sharpens SDK-reality checks) or a free-text sentence describing intent.
- `validation_type` (string): What the output is: 'code_generation' (default) for source code; 'documentation', 'report', 'email', 'text', ... for prose (code-marker gates are skipped, integrity gates and the frontier review stil…

Output parameters:

- `confidence` (number): score / 100
- `issues` (array): Severity-ranked findings, each 'severity|category|detail' with the reasoning
- `protection` (object): Deterministic gate result. A veto here is final — the model review cannot override it.
- `provider` (string): Model that ran the deep review, or 'protection-gates-only'
- `score` (number): Combined score 0-100 (gates fused with the model review)
- `suggestions` (array): Concrete fixes to reach approval
- `valid` (boolean): The binary verdict: true = approved, false = rejected

### `validate_plan` (~184 tokens)

Gate an implementation plan

The gate for PLANS, designs and specs — run BEFORE any code is written, the cheapest place to catch a bad design. Returns the same binary verdict shape as validate_ai_output, with findings on completeness, feasibility, performance and scalability implications, security risks and missing considerations (e.g. it rejects a plan that polls an API every 100ms per client, with the request-volume math). Read-only: nothing is executed or stored beyond the verdict. Use validate_ai_output for the code that follows.

Input parameters:

- `context` (object): Optional constraints the review should weigh, e.g. {"system": "payments API", "scale": "1M users", "constraints": "PostgreSQL only"}.
- `plan` (string, required): The implementation plan, design or spec to validate, as plain text or markdown — e.g. a numbered migration plan or an architecture sketch.

Output parameters:

- `confidence` (number): score / 100
- `issues` (array): Severity-ranked findings, each 'severity|category|detail' with the reasoning
- `protection` (object): Deterministic gate result. A veto here is final — the model review cannot override it.
- `provider` (string): Model that ran the deep review, or 'protection-gates-only'
- `score` (number): Combined score 0-100 (gates fused with the model review)
- `suggestions` (array): Concrete fixes to reach approval
- `valid` (boolean): The binary verdict: true = approved, false = rejected

### `analyze_code` (~207 tokens)

Advisory code deep-dive

Advisory deep-dive on existing code — scores and findings, deliberately NO pass/fail verdict, so it never blocks an agent. Surfaces performance hot paths, scalability cliffs, reliability gaps and tech debt with concrete latency/throughput arithmetic (e.g. 'O(n²) dedup: ~4s at 10k items'). Read-only: the code is analyzed, never executed. Use it to understand a validate_ai_output rejection or review inherited code; use validate_ai_output when you need an accept/reject decision.

Input parameters:

- `analysis_type` (string): Lens for the review: 'quality' (default, broad ISO/IEC 25010 pass) or a focused pass on one dimension.
- `code` (string, required): The source code to analyze — a function, file or pasted excerpt.
- `language` (string): Source language, e.g. 'python', 'typescript', 'cpp', 'sql', 'swift'. Inferred if omitted; stating it sharpens findings.

Output parameters:

- `complexity` (string): low | medium | high
- `issues` (array): Findings as 'severity|category|detail' with supporting arithmetic
- `provider` (string)
- `quality_score` (number): 0-100 advisory score for the chosen lens
- `suggestions` (array)

### `generate_code` (~180 tokens)

Generate gated code

Generate code and gate it in one step: an LLM writes the implementation, then the same protection engine as validate_ai_output vets it — retrying generation when the gate rejects. If every attempt is vetoed you still receive the last attempt, clearly marked validated:false with the gate findings — rejected code is never presented as clean. Generation runs on our infrastructure; nothing executes in your environment.

Input parameters:

- `language` (string): Target language for the generated code, e.g. 'python' (default), 'typescript', 'go', 'sql'.
- `max_tokens` (integer): Generation budget. The default 4000 fits most functions/classes; raise it for multi-file scaffolds.
- `prompt` (string, required): What to build, with any constraints worth enforcing — e.g. 'a rate-limited retry decorator with exponential backoff, stdlib only'.

Output parameters:

- `attempts` (integer): Generation attempts before approval or give-up
- `code` (string): The generated implementation
- `generated` (boolean): False only when no provider returned code
- `protection` (object): Deterministic gate result. A veto here is final — the model review cannot override it.
- `provider` (string)
- `validated` (boolean): True if the protection gates approved the final attempt; false means the gate findings in 'protection' explain the veto
- `validation_score` (number): Deterministic gate score, 0-100

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-verificate-mcp/mcp#diagnostics

## Score history

- 2026-08-04: 61
- 2026-08-03: 61
- 2026-08-02: 63
- 2026-08-01: 63
- 2026-07-31: 66

## Links

- Remote endpoint: https://mcp.verificate.ai/mcp
- Authorisation metadata: https://mcp.verificate.ai/.well-known/oauth-protected-resource/mcp
- Repository: https://github.com/Verificate-Dev/verificate-mcp-quickstart
- Website: https://verificate.ai/mcp
- Changelog RSS feed: https://verifymcp.io/servers/ai-verificate-mcp/mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-verificate-mcp/mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/ai-verificate-mcp/mcp