Agentic code review, no signup to try: reality gates + frontier-model review, with veto.
ai.verificate/mcp (Model Context Protocol)
This MCP server provides agentic code review with “reality gates” plus a “frontier-model review,” including a veto mechanism. It supports code-quality evaluation focused on reducing hallucination risk, and is distributed without requiring signup to try. It exposes four tools via MCP.
🛠️ Key Features
Agentic code review
Reality gates
Frontier-model review
Veto
🚀 Use Cases
Reviewing AI-written code for quality issues
Gatekeeping code changes, including rejecting and approving fixes
Reducing hallucination impact in code
⚡ Developer Benefits
“Reality gates + frontier-model review, with veto” workflow
Faster review loop demonstrated with rejected then approved code output
No signup required to try
⚠️ Limitations
Based on provided metadata only; specific tool capabilities are not described beyond toolCount (4)
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. In a benchmark, a frontier model reviewing alone caught reward-gaming and hallucinated APIs 0/6 times in a natural review workflow; these gates catch them deterministically 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.
Parameters3
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).
validation_type
string
optional
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 still run); 'plan' for designs/specs.
context
object | string
optional
Optional review context — an object like {"language": "cpp", "scale": "10k req/s"} ('language' sharpens SDK-reality checks) or a free-text sentence describing intent.
Raw schema
{
"type": "object",
"properties": {
"ai_output": {
"type": "string",
"description": "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)."
},
"validation_type": {
"type": "string",
"default": "code_generation",
"description": "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 still run); 'plan' for designs/specs."
},
"context": {
"type": [
"object",
"string"
],
"description": "Optional review context — an object like {\"language\": \"cpp\", \"scale\": \"10k req/s\"} ('language' sharpens SDK-reality checks) or a free-text sentence describing intent."
}
},
"required": [
"ai_output"
]
}
validate_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.
Parameters2
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.
context
object
optional
Optional constraints the review should weigh, e.g. {"system": "payments API", "scale": "1M users", "constraints": "PostgreSQL only"}.
Raw schema
{
"type": "object",
"properties": {
"plan": {
"type": "string",
"description": "The implementation plan, design or spec to validate, as plain text or markdown — e.g. a numbered migration plan or an architecture sketch."
},
"context": {
"type": "object",
"description": "Optional constraints the review should weigh, e.g. {\"system\": \"payments API\", \"scale\": \"1M users\", \"constraints\": \"PostgreSQL only\"}."
}
},
"required": [
"plan"
]
}
analyze_code
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.
Parameters3
code
string
required
The source code to analyze — a function, file or pasted excerpt.
analysis_type
string
optional
Lens for the review: 'quality' (default, broad ISO/IEC 25010 pass) or a focused pass on one dimension.
language
string
optional
Source language, e.g. 'python', 'typescript', 'cpp', 'sql', 'swift'. Inferred if omitted; stating it sharpens findings.
Raw schema
{
"type": "object",
"properties": {
"code": {
"type": "string",
"description": "The source code to analyze — a function, file or pasted excerpt."
},
"analysis_type": {
"type": "string",
"default": "quality",
"enum": [
"quality",
"performance",
"scalability",
"security",
"tech_debt"
],
"description": "Lens for the review: 'quality' (default, broad ISO/IEC 25010 pass) or a focused pass on one dimension."
},
"language": {
"type": "string",
"description": "Source language, e.g. 'python', 'typescript', 'cpp', 'sql', 'swift'. Inferred if omitted; stating it sharpens findings."
}
},
"required": [
"code"
]
}
generate_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.
Parameters3
prompt
string
required
What to build, with any constraints worth enforcing — e.g. 'a rate-limited retry decorator with exponential backoff, stdlib only'.
language
string
optional
Target language for the generated code, e.g. 'python' (default), 'typescript', 'go', 'sql'.
max_tokens
integer
optional
Generation budget. The default 4000 fits most functions/classes; raise it for multi-file scaffolds.
Raw schema
{
"type": "object",
"properties": {
"prompt": {
"type": "string",
"description": "What to build, with any constraints worth enforcing — e.g. 'a rate-limited retry decorator with exponential backoff, stdlib only'."
},
"language": {
"type": "string",
"default": "python",
"description": "Target language for the generated code, e.g. 'python' (default), 'typescript', 'go', 'sql'."
},
"max_tokens": {
"type": "integer",
"default": 4000,
"minimum": 256,
"maximum": 32768,
"description": "Generation budget. The default 4000 fits most functions/classes; raise it for multi-file scaffolds."
}
},
"required": [
"prompt"
]
}
Verificate MCP — your vibe-coded MVP, all the way to production
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.
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 case
LLM review alone
Verificate gate
Reward-gaming (assert True test)
0 / 6
6 / 6
Hallucinated API (nonexistent SDK call)
0 / 6
6 / 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:
Tool
Job
Returns
validate_ai_output
The 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.
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
analyze_code
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_code
Generate + 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:
LM Studio and Goose one-click buttons are at https://verificate.ai/mcp (GitHub strips their custom-protocol links).
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.
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:
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 stripe.Inventory doesn't exist. No verdict, no veto — findings your agent is free to ignore.
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 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:
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: info@verificate.ai.
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.
