Verificate MCP

Verificate MCP — your vibe-coded MVP, all the way to production

Real output from the live server: 12 lines of AI-written payment code — rejected, fixed, approved, in seconds.

You vibe-coded the demo. This ships it. Between a working demo and a launched product used to stand an experienced CTO and a senior dev team — the people who catch the mock refund path, the invented SDK call, the loop that dies at real traffic. Verificate MCP is that review team as an MCP server: deterministic veto checks (placeholders and mocks, reward-gamed tests, invented standard-library APIs, secrets written to logs, deceptive or evidence-free claims), then a Claude Haiku 5.5 review against ISO/IEC 25010 and ISO/IEC 5055, run on every AI-written change before it reaches your codebase. Every verdict comes with a receipt. The AI writes; the gate holds the bar; you ship. Hosted, zero-install, binary verdict in seconds — in Claude Code, Cursor, Windsurf or any MCP client.

Not another linter wrapper. The code-quality shelf on every MCP directory is two things: scanners (ESLint, Semgrep and SonarQube bridges — deterministic rules, no judgment) and prompt relays that pipe your repo to your own LLM key (self-review with extra steps). Verificate is neither: its deterministic checks hold a veto that no model output can override.

Your coding assistant writes a mock and calls it done. It invents an SDK call that doesn't exist. It ships an N+1 loop that passes every test and dies under load. Verificate MCP runs the deep review pass on every AI output — deterministic reality gates first (any one can veto), then an enterprise-grade review scores what survives — before the code reaches your codebase.

New in November 2026

• A stronger reviewer. The model stage now runs on Claude Haiku 5.5. On our frozen benchmark (12 cases, each reviewed 3 times), unsafe approvals went from 6 in 36 to 0 in 36, with all 12 clean controls still approved. Method and numbers.
• Secrets in logs are now a deterministic veto. Passing a password, API key, access token or access code to a log or console call fails the review in Python, JS/TS, Java, Go, Rust, C#, PHP, Ruby, Swift and Kotlin (CWE-532). Logging that a key is present, its length or a fingerprint is fine.
• Invented standard-library calls are a deterministic veto (for example os.read_text). Third-party SDK calls are checked by the model review.
• One decision and a receipt. Every response carries one final decision, the model's unmodified opinion beside it, and a receipt: input and prompt hashes, prompt and policy versions, the model, whether the review was complete, and what was not verified. A review that cannot cover the scope says so and is never an approval.
• Used hard in our own engineering. 3,844 Gate reviews across 54 of our own projects between 7 October and 10 November 2026; 943 were rejected and sent back for fixes.

A real rejection (verbatim)

12 plausible lines of AI-written payment code were sent through the production gateway. Verdict: REJECTED — score 30.8/100, vetoed by `code_reality_gate`, with findings including:

*"N+1 synchronous API calls … For 100 items, this results in 100 sequential HTTP roundtrips, taking ~10–20 seconds and blocking the event loop/worker thread … will trigger Stripe rate limiting (100 req/sec limit)."*

*"stripe.Inventory is not a valid Stripe SDK resource."*

*"Floating-point representation issues lead to rounding errors in financial transactions; Stripe API requires integer cents."*

Each of those is an afternoon of production debugging, caught in seconds.

Measured — vs. asking the model to review its own code

A frontier model asked *"is this OK to merge?"* in a natural workflow missed reward-gaming (a test that only does assert True) and a hallucinated API (stripe.Refund.create_partial) in 0 of 6 runs each. Verificate's gate caught both 6 of 6, with 0 false positives on clean code. The reward-gamed test is a deterministic veto; the invented third-party SDK call was caught by the model review stage.

That benchmark is from September 2026. The November frozen A/B (36 reviews, 6 unsafe approvals → 0) is in BENCHMARK_2026-11.md. Reproduce the September run: scripts/ · full write-up: COMPARISON.md.

Tools

Each tool has one job — three gates that return verdicts, one advisor that doesn't, one generator:

Beyond tools

The server also ships prompts and resources for a richer client experience:

• Prompts gate_my_changes / review_my_plan — one-click workflows that loop validate → fix → re-validate until approved.
• Resources verificate://gates (each deterministic check, the model review stage, and what is not run on the hosted gate) and verificate://example-verdict (a verbatim production rejection).

Quick start — no signup, no token, 30 seconds

Every machine gets 100 free validations — no account, no card, no key. Add the URL and go:

Claude Code

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

Or install it as a Claude Code plugin (adds the MCP server *and* the verificate skill, so Claude gates its own work before presenting it):

/plugin marketplace add VerificateAI/verificate-mcp-quickstart

/plugin install verificate@verificate

Cursor / VS Code — one-click install:

*LM Studio and Goose one-click buttons are at https://verificate.ai/mcp (GitHub strips their custom-protocol links).*

Windsurf / any MCP client (JSON)

{

"mcpServers": { "verificate": { "url": "https://mcp.verificate.ai/mcp", "transport": "http" } } }

Cursor: ~/.cursor/mcp.json. Windsurf: ~/.codeium/windsurf/mcp_config.json.

Then ask your assistant to *"validate this function with verificate"* — a structured verdict comes back in seconds (typically 5–25 s).

Cursor plugin — this repo is also a Cursor plugin (.cursor-plugin/plugin.json + mcp.json). The optional VERIFICATE_TOKEN variable can stay empty for the free tier.

OpenAI Codex — add the server in ~/.codex/config.toml:

[mcp_servers.verificate]

url = "https://mcp.verificate.ai/mcp"

A packaged Codex/ChatGPT plugin (no auth headers, logo, skill) is in plugins/codex/.

Google Antigravity — add to Antigravity's mcp_config.json (Streamable HTTP):

{

"mcpServers": { "verificate": { "serverUrl": "https://mcp.verificate.ai/mcp" } } }

The Gemini CLI / Antigravity extension installs the same server.

Devin — add a custom MCP server in Devin's MCP settings: transport HTTP (Streamable), URL https://mcp.verificate.ai/mcp, authentication None (or Auth Header Authorization: Bearer once you have a token).

IBM Bob — add to Bob's mcp.json:

{

"mcpServers": { "verificate": { "type": "streamable-http", "url": "https://mcp.verificate.ai/mcp" } } }

Keep going after the free 100

Sign up at https://verificate.ai/auth/signup (30-day trial, no card — then $30/mo) and add your token to the same config:

claude mcp add --transport http verificate \

https://mcp.verificate.ai/mcp \ --header "Authorization: Bearer YOUR_TRIAL_TOKEN"

or in the JSON config add "headers": { "Authorization": "Bearer YOUR_TRIAL_TOKEN" }.

Make gating the default

Tools an agent *may* call are tools it will skip under pressure. Add a standing rule (Claude Code: CLAUDE.md; Cursor: a rule file):

Before presenting any substantive code change as complete:

1. Call validate_ai_output on the change.
2. If the verdict is REJECTED, fix the findings and re-validate.
3. Never claim tests pass or systems are deployed without proof.

One-paste setup prompts that install these rules for you: PROMPTS.md. Or wire it into CI as a merge gate — see examples/.

How it decides

AI output ──► Deterministic veto checks (same input, same result)

• mock/placeholder presented as done • reward-gamed tests • invented standard-library APIs • secrets written to logs (CWE-532) • deceptive or evidence-free claims │ ▼ Claude Haiku 5.5 review (ISO/IEC 25010 + ISO/IEC 5055) security · reliability · performance · maintainability third-party API reality · high/critical L0/L2 find