Verificate MCP

ai.verificatePublished by verificate.aiOfficial publisherv1.9.0Updated Nov 11, 2026

Merge gate for AI-written code: deterministic vetoes plus a Claude Haiku 5.5 review. No signup.

VerifiedStreamable HTTPWeb executableDeveloper ToolsAI & ML

Overview

AI-generated overview

Hosted code-review gate that lets an assistant validate AI-written code, plans and outputs against deterministic gates plus a frontier-model review, returning…

What you can do
  • Validate AI-written code, docs, configs and reports with a binary approve/reject verdict and severity-ranked findings
  • Gate plans, designs and specs before any code is written, checking completeness, feasibility, scalability and risk
  • Run an advisory deep-dive on existing code for hot paths, rate-limit math, failure modes and tech debt, with no verdict
  • Generate code and have the same gate vet it, retrying when a result is rejected
  • Use bundled prompts that loop validate, fix and re-validate, and resources describing the gates and an example verdict
When to use it
Worth adding when an assistant writes or reviews code and you want an external check that can veto mock implementations, invented SDK calls and claimed-complete work before it reaches the codebase. Also useful for reviewing plans and inherited code, or wiring a merge gate into CI.
Requirements
Remote streamable HTTP endpoint; no local install needed, though a stdio bridge via npx or Docker is offered. The free tier needs no account or token (25 validations per machine); beyond that a bearer token from the Verificate dashboard is sent in the Authorization header. Network access required.
Before you install
The service is commercial: a 30-day trial then USD 30/month, and the validation engine is closed and server-side. Your code and plans are sent to a third-party hosted gateway for processing. The Authorization token is a personal, rate-limited credential with key-sharing detection, so keep it out of shared configs. Verdicts can block an agent's work depending on your standing rules.

Installation

In SourceWeft

  1. Open Verificate MCP in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/ai.verificate%2Fmcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

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

README

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

[Verificate Gate]

[Verificate MCP rejecting AI-written payment code at 70, then approving the fix at 91.2 — real output from the live server]

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: 17 deterministic reality gates with veto power, fused with a frontier-model enterprise review (ISO/IEC 25010: performance, scalability, reliability), run on every AI-written change before it reaches your codebase. 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: the gates hold veto power that no model output can override.

[License: MIT] [Official MCP Registry] [Docker MCP Registry] [MCP Market] [Free trial]

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.

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 — deterministically, with 0 false positives on clean code.

Adversarial caseLLM review aloneVerificate gate
Reward-gaming (assert True test)0 / 66 / 6
Hallucinated API (nonexistent SDK call)0 / 66 / 6

Battle-tested: 2,581 audited validations over 5 weeks (66 rejected, 270 flagged unfit), including guarding the write-path of a 21M-entity source-cited knowledge base (98.6% cited, 100% licensed across 268 sources). Reproduce it: scripts/ · full write-up: COMPARISON.md.

Tools

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

ToolJobReturns
validate_ai_outputThe merge gate for AI-written code. Deterministic reality gates (mock/placeholder veto, gaming & bypass detection, invented-API checks) run first and can't be overridden; ISO/IEC 25010 review scores what survives.Binary approve/reject verdict + severity-ranked findings
validate_planThe 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
analyze_codeAdvisory 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_codeGenerate + gate in one step — the LLM writes it, the same protection engine vets it before you see it.Gated code (no placeholders, no invented APIs)

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 (what each of the 17 deterministic gates watches for) and verificate://example-verdict (a verbatim production rejection).

Quick start — no signup, no token, 30 seconds

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

Claude Code

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

Cursor / VS Code — one-click install:

[Add Verificate to Cursor] [Add to VS Code] [Add to VS Code Insiders]

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

Windsurf / any MCP client (JSON)

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, and every free-tier response shows how many validations you have left and what the gate has caught for you.

Keep going after the free 25

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

bash
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):

text
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

text
AI output ──► Reality gates (deterministic, any one vetoes)
              • mock/placeholder in the wire path
              • invented/hallucinated APIs
              • claimed-complete without proof
              • gaming & bypass detection
                       │ survivors only
                       ▼
              Enterprise review (ISO/IEC 25010 + MLOps)
              performance · scalability · reliability · tech debt
                       │
                       ▼
              Verdict: score /100 + severity-ranked findings
              (REJECTED = agent fixes findings and re-validates)

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 directoriesWhat it isWhat it structurally can't do
Linter wrappers — ESLint MCP, Semgrep MCP, SonarQube MCPRule-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 stripe.Inventory doesn't exist. No verdict, no veto — findings your agent is free to ignore.
BYO-key review relaysYour 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 modelHope 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 diffThe 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 MCPDeterministic reality gates with veto, then a frontier-model enterprise review — fused into one binary verdict. Hosted, always on the current model.—

That second layer is the part you pay for: a frontier agent doing the deep review — production arithmetic, failure modes, SDK reality — with a deterministic floor under it that the agent 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:

bash
VERIFICATE_TOKEN=<your-token> npx github:Verificate-Dev/verificate-mcp-quickstart

Or with Docker:

bash
docker build -t verificate-mcp .
docker run -i -e VERIFICATE_TOKEN=<your-token> verificate-mcp

Without VERIFICATE_TOKEN, introspection still works and tool calls return instructions for getting a trial token.

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.

Security & privacy

  • Requests are authenticated with your personal token; keys are single-user and rate-limited, with key-sharing detection.
  • Code is processed to produce the verdict and is not used to train models.
  • initialize/tools/list are public (so clients and directories can introspect); every tools/call requires your key.

Pricing

30-day free trial, then USD $30/month (launch offer: 50% off for 3 months). Volume and academic pricing: [email protected].

Guides

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 17 protection gates and the frontier-model review run server-side and are not part of this repository.

Glama

[Verificate MCP server score]

🌐 Not an English speaker? Install instructions in हिन्दी · Português · Bahasa Indonesia · Español · 中文 · Tiếng Việt → INSTALL.md

Source: README.md at commit 62880eb

Tools

5

validate_artifact

Gate a deployable artifact against the Verificate production doctrine

Deterministic production-readiness gate for AI-built systems. Verifies the invariants that stop a system silently shipping broken: every critical component is PRESENT and LOADS, the import closure resolves (nothing assumed 'already on the box'), all runtime dependencies are declared, and health is a REAL fail-closed check. Returns approve/reject with a fix plan and ISO 27001 / ISO 5055 control evidence. Facts are gathered by the Verificate collector in your CI; the gate is the authority. Non-bypassable, fails closed. This is the control-plane sibling of validate_ai_output — code quality is one invariant; this gates the whole deployable.

Parametersartifactrequired

validate_ai_output

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 checks (mock/placeholder veto, reward-gamed tests, standard-library calls that do not exist, secrets written to logs) run first and cannot be overridden; a Claude Haiku 5.5 review (ISO/IEC 25010, ISO/IEC 5055) then verifies third-party API calls and scores quality, accuracy, reliability and tech debt; its high/critical security and API findings block. In a benchmark, a frontier model reviewing alone caught reward-gaming and hallucinated APIs 0/6 times in a natural review workflow; this gate checks for both on every call. 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.

Parameterscontextai_outputrequiredvalidation_typeprevious_receipt_idexpected_input_sha256

validate_plan

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.

Parametersplanrequiredcontextprevious_receipt_idexpected_input_sha256

analyze_code

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.

Parameterscoderequiredlanguageanalysis_type

generate_code

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.

Parameterspromptrequiredlanguagemax_tokens

Version history

1
  1. v1.8.7Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts