Verificate MCP

{ "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.

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" }.

Tools an agentmaycall 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.

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.

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 isjudgment with authority:

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.

This repo is also a runnable, zero-dependency MCP server: a stdio bridge that servesinitialize/tools/listlocally and forwards tool calls to the hosted gateway. Use it with clients that prefer stdio servers:

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

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

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

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, …). Passcontext.languagefor 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.

- 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/listare public (so clients and directories can introspect); everytools/callrequires your key.

This repo (the stdio bridge, client configs and CI examples) isMIT— use it freely. The Verificate validation engine and hosted gateway it talks to are acommercial 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.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

300+ tools that connect AI assistants directly to the Godot editor. Build scenes, write scripts, test gameplay — all through natural language.

Deterministic music-theory engine for AI agents to analyze, resolve, voice, and reharm chords.

An MCP server that allows AI assistants to interact with Adobe After Effects.

An MCP server that lets an AI agent deploy a web game to a playable multiplayer URL — rooms, live state sync, and leaderboards — in one conversation.

MCP server for CTFd that lets regular users browse challenges, manage dynamic instances, and submit flags.

Fetch and process images from URLs, local file paths, and numpy arrays, returning them as base64-encoded strings.

Analyzes audio files and extracts metadata, tailored for game audio development workflows.

An MCP server exposing @playbykey/theory as AI-callable, computed music theory tools, includes chords, scales, progressions, transpositions, and MIDI/frequency conversions.

Query and interact with ShaderToy shaders using large language models.