Verificate MCP
OfficialVerificate MCP is a hosted review gate that vets AI-written code, plans and generated code with deterministic veto checks plus a model review, returning a binary verdict with findings and a receipt.
Gate AI-written code (
validate_ai_output) — pass a diff, function or file (ortextfor prose) and get a binary approve/reject, a 0–100 score, severity-ranked findings (severity|category|detail), the vetoing gates, and concrete fix suggestions; deterministic vetoes (mock/placeholder, reward-gamed tests, invented standard-library APIs, secrets in logs) run first and cannot be overridden by the model review.Gate plans before any code exists (
validate_plan) — check a design, spec or migration plan for completeness, feasibility, performance/scalability math and security gaps, with optional constraints viacontext.Get an advisory deep-dive (
analyze_code) — scores and findings with no pass/fail verdict (so it never blocks an agent); pick a lens (quality,performance,scalability,security,tech_debt) to find hot paths, latency cliffs, reliability gaps and tech debt.Generate then gate in one step (
generate_code) — an LLM writes the implementation in a chosen language and the same protection engine vets it, retrying on veto; you always get the last attempt withvalidated: falseand the gate findings if it never passes.Inspect why something failed — every response exposes the
protectionblock (vetoed,verdict,vetoed_by,protection_score) plusproviderandconfidence, so verdicts are auditable rather than a bare score.Run it safely inside an agent loop — all four tools are read-only, analyzed-but-never-executed, and idempotent (except
generate_code), so they can be called on every change; free tier gives 100 validations with no signup.Caveat: the README also advertises a
validate_artifacttool plus prompts (gate_my_changes,review_my_plan) and resources (verificate://gates,verificate://example-verdict), but this schema exposes only the four tools above.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Verificate MCP — your vibe-coded MVP, all the way to production
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.
Related MCP server: Context7 MCP
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.Inventoryis 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.
Adversarial case | LLM review alone | Verificate gate |
Reward-gaming ( | 0 / 6 | 6 / 6 |
Hallucinated API (nonexistent SDK call) | 0 / 6 | 6 / 6 |
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:
Tool | Job | Returns |
| The merge gate for AI-written code and documents. Deterministic veto checks (placeholders and mocks, reward-gamed tests, invented standard-library APIs, secrets in logs) run first and can't be overridden; a Claude Haiku 5.5 review (ISO/IEC 25010, ISO/IEC 5055) then checks the rest, including third-party API calls. | One decision (approved / approved with conditions / rejected / incomplete) + severity-ranked findings + a receipt |
| The gate for plans and designs, before any code exists — completeness, feasibility, scalability implications, risk. The cheapest place to catch a bad design. | Binary approve/reject verdict + findings |
| The gate for a deployable: every critical component present and loading, imports resolving, dependencies declared, health checks that really fail closed. | Binary approve/reject verdict + fix plan |
| Advisory deep-dive on existing code — hot paths, rate-limit math, failure modes, tech debt. Use it to understand a rejection or review inherited code. | Scores + findings, deliberately no verdict |
| Generate + gate in one step — the LLM writes it, the same checks vet it before you see it. | Gated code, with the verdict |
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) andverificate://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/mcpOr 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@verificateCursor / 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 <token> 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 findings block
│
▼
One decision + findings + receipt
(rejected = agent fixes findings and re-validates;
incomplete = the review could not cover the scope, never an approval)The two stages are deliberately separate: if reality and quality were blended into one score, a beautifully structured function that fakes its refund path could still average out to "acceptable." A veto architecture makes that impossible.
The category, honestly
Everything else on the MCP code-quality shelf is free — and that's fair, because a wrapper should be free. What you can't get for free is judgment with authority:
What you'll find on the directories | What it is | What it structurally can't do |
Linter wrappers — ESLint MCP, Semgrep MCP, SonarQube MCP | Rule-based scanners exposed as MCP tools. Deterministic, free, worth running. | No judgment. Rules can't know the refund function never calls the payment provider, or that |
BYO-key review relays | Your repo + a review prompt, piped to your own OpenAI/Anthropic key. | Self-review with extra steps: the reviewer shares the generator's blind spots, there are no deterministic gates underneath, and whatever the model says goes. You maintain keys, versions and hosting. |
A bigger model | Hope the generator reviews itself better. | Self-review inherits self-blindness. An external gate holds the same bar for every model — which also makes smaller, cheaper models safe to ship with: same gate either way. |
Human review of every AI diff | The gold standard, at human speed. | Doesn't scale at AI generation speed. The gate does the first pass in seconds; humans review verdicts, not raw diffs. |
Verificate MCP | Deterministic checks with veto, then a Claude Haiku 5.5 review — fused into one decision with a receipt. Hosted. | — |
That second layer is the part you pay for: a model doing the deep review — production arithmetic, failure modes, SDK reality — with a deterministic floor under it that the model itself cannot argue away.
Run locally (stdio bridge)
This repo is also a runnable, zero-dependency MCP server: a stdio bridge that serves initialize/tools/list locally and forwards tool calls to the hosted gateway. Use it with clients that prefer stdio servers:
VERIFICATE_TOKEN=<your-token> npx github:VerificateAI/verificate-mcp-quickstartOr with Docker:
docker build -t verificate-mcp .
docker run -i -e VERIFICATE_TOKEN=<your-token> verificate-mcpWithout VERIFICATE_TOKEN, tool calls use the free tier (100 validations, no signup).
FAQ
Does it slow the agent down? Each validation takes seconds, inside the loop, before work is presented. Compare with a defect found in CI or production plus the context switch to fix it — gating is net-faster for any change that matters.
Which languages? Validation is language-agnostic; analysis covers mainstream languages (Python, JS/TS, C++, SQL, Swift, …). Pass context.language for best results.
Can it block my agent? Yes — that's the point. A REJECTED verdict is designed to send the agent back to fix findings instead of presenting broken work. Your standing rule decides how hard the stop is.
What about false positives? Verdicts come with specific findings and the math, so they're auditable in seconds — you're never asked to trust a bare score. The new secrets-in-logs check was measured on 34,849 real third-party source files before launch: it flagged 5 lines, all genuine password or credential logging.
Security & privacy
Without a key, each machine (or, in CI, each repository) gets 100 free validations. With a key, calls draw on your own quota; keys are single-user and rate-limited.
Submitted code is read, never executed. It is processed to produce the verdict and is not used to train models.
initialize/tools/listare public, so clients and directories can introspect the server.
Pricing
30-day free trial, then USD $30/month (launch offer: 50% off for 3 months). Volume and academic pricing: info@verificate.ai.
Guides
Every Bob needs a Wendy (IBM Community)
About
Built by Verificate Pty Ltd (Sydney, Australia) — an IBM Business Partner. Verificate builds sovereign AI infrastructure: the HELIX inference engine (calibrated confidence scores on every answer), the deterministic Decision Transformer, and this MCP validation server. Product page: https://verificate.ai/mcp · Official registry: ai.verificate/mcp
Licensing
This repo (the stdio bridge, client configs and CI examples) is MIT — use it freely. The Verificate validation engine and hosted gateway it talks to are a commercial service (30-day free trial, then subscription): the deterministic checks and the model review run server-side and are not part of this repository.
Glama
🌐 Not an English speaker? Install instructions in हिन्दी · Português · Bahasa Indonesia · Español · 中文 · Tiếng Việt → INSTALL.md
Available Tools
4 toolsanalyze_codeAdvisory code deep-diveARead-onlyIdempotentInspect
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.
Inputs: code (required), language, analysis_type. Returns: issues, provider, complexity, suggestions, +1 more
generate_codeGenerate gated codeARead-onlyInspect
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.
Inputs: prompt (required), language, max_tokens. Returns: code, attempts, provider, generated, +3 more
validate_ai_outputGate AI-written codeARead-onlyIdempotentInspect
The merge gate for AI-written CODE: returns a binary approve/reject verdict with veto power — e.g. it rejects code calling the nonexistent stripe.Inventory API, or an N+1 loop with the latency arithmetic to prove it. 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 performance, scalability, reliability and tech debt. Read-only: the code is analyzed, never executed. Call it on every AI-generated diff before accepting it; use validate_plan for plans, analyze_code for an advisory report without a verdict.
Inputs: ai_output (required), context, validation_type. Returns: score, valid, issues, provider, +3 more
validate_planGate an implementation planARead-onlyIdempotentInspect
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.
Inputs: plan (required), context. Returns: score, valid, issues, provider, +3 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool targets a distinct artifact and action: validate_plan is for design specs, validate_ai_output is for code verification, analyze_code is advisory without a verdict, and generate_code is generation with built-in validation. Even the overlapping gate logic in validate_ai_output and generate_code is clearly differentiated by purpose, leaving no ambiguity.
All tool names follow a consistent verb_noun pattern using lowercase and underscores: validate_*, analyze_code, generate_code. The verbs clearly indicate the action (validate, analyze, generate) and the objects specify the target, making the naming predictable and scannable.
Four tools is an ideal size for this server's purpose—covering validation, analysis, and generation without unnecessary bloat. Each tool earns its place in the workflow, and the count is well within the 3-15 range for a focused server.
The server covers the full verification lifecycle: plan validation before code, code validation for AI-generated diffs, advisory analysis for existing code, and generation with built-in gating. There are no obvious missing operations or dead ends—the tools form a complete pipeline.
Maintenance
Related MCP Connectors
Governance copilot for AI-assisted coding. 72 packs, 532 rules, proof bundles.
AI code governance and code review for Claude Code, Copilot and Cursor. Checks rules and security.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Verify AI-generated code before you commit: independent reviewers check it. PR review too.
Related MCP Servers
AlicenseBqualityFmaintenanceAn MCP server that provides a comprehensive interface to Semgrep, enabling users to scan code for security vulnerabilities, create custom rules, and analyze scan results through the Model Context Protocol.61,203 PyPI689MIT- AlicenseAqualityBmaintenanceA Model Context Protocol server that fetches up-to-date, version-specific documentation and code examples from libraries directly into LLM prompts, helping developers get accurate answers without outdated or hallucinated information.265,222MIT
- AlicenseAqualityDmaintenanceValidates AI-generated code against actual codebases to catch hallucinations, dead code, and API mismatches before runtime.1220 npm1MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding agents to enforce spec-driven development and verify code before it is marked done, using six tools that catch invented APIs, scan for hallucinated content, check plugin conformance, sandbox-run tests, validate schemas, and record audit evidence.771 npm8PolyForm Noncommercial 1.0.0