{
  "meta": {
    "attribution": "Anchor Terminal (https://www.anchorterminal.com)",
    "docs": "https://www.anchorterminal.com/docs/",
    "generatedAt": "2026-10-05",
    "license": "CC-BY-4.0",
    "method": "https://www.anchorterminal.com/benchmark/",
    "methodology": "0.3",
    "openapi": "https://www.anchorterminal.com/openapi.json",
    "preview": false,
    "run": "2026-10-01",
    "runLabel": "October 2026 research run"
  },
  "tool": {
    "category": "",
    "endpoint": "https://mcp.verificate.ai/mcp",
    "jsonUrl": "https://www.anchorterminal.com/api/v1/tools/verificate-mcp.json",
    "kind": "mcp",
    "listed": "indexed",
    "liveUrl": "https://www.anchorterminal.com/api/v1/live/verificate-mcp.json",
    "markdownUrl": "https://www.anchorterminal.com/tools/verificate-mcp.md",
    "mcpTools": {
      "check": {
        "checker": "anchor-check/1.0",
        "totalTokens": 2858,
        "counts": {
          "error": 0,
          "note": 1,
          "warn": 2
        },
        "findings": [
          {
            "rule": "TC13",
            "severity": "warn",
            "tool": "validate_artifact",
            "message": "artifact (object with no properties)",
            "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
          },
          {
            "rule": "TC13",
            "severity": "warn",
            "tool": "validate_plan",
            "message": "context (object with no properties)",
            "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
          },
          {
            "rule": "TC24",
            "severity": "note",
            "message": "1 of 5 tools have no outputSchema",
            "fix": "Declare outputSchema for tools that return structured data, and return structuredContent that matches it."
          }
        ]
      },
      "checkedAt": "2026-10-04T22:20:57Z",
      "count": 5,
      "note": "answered without the initialize handshake",
      "schemaTokens": 2858,
      "status": "ok",
      "tools": [
        {
          "name": "validate_artifact",
          "title": "Gate a deployable artifact against the Verificate production doctrine",
          "description": "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.",
          "inputSchema": {
            "properties": {
              "artifact": {
                "description": "Collected artifact facts: {critical_components:[{name,loads:bool}], import_closure_ok:bool, undeclared_deps:[str], health_truthful:bool}.",
                "type": "object"
              }
            },
            "required": [
              "artifact"
            ],
            "type": "object"
          },
          "annotations": {
            "destructiveHint": false,
            "idempotentHint": true,
            "openWorldHint": false,
            "readOnlyHint": true
          }
        },
        {
          "name": "validate_ai_output",
          "title": "Gate AI-written output (code or documents)",
          "description": "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.",
          "inputSchema": {
            "properties": {
              "ai_output": {
                "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). For reliable latency keep one submission under ~15,000 characters; split larger artifacts at natural boundaries (functions, SQL statements, sections) and validate the units separately. Reviews are wall-clock bounded: an over-budget model review returns an explicit timed-out result (deterministic gates still run) rather than hanging.",
                "type": "string"
              },
              "context": {
                "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.",
                "type": [
                  "object",
                  "string"
                ]
              },
              "validation_type": {
                "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). Use 'report' (or 'status_report' / 'handover') for anything that CLAIMS work is done or passing: there, a completion claim with no evidence in the text is a veto. 'plan' for designs/specs.",
                "type": "string"
              }
            },
            "required": [
              "ai_output"
            ],
            "type": "object"
          },
          "outputSchema": {
            "additionalProperties": true,
            "properties": {
              "confidence": {
                "description": "score / 100",
                "type": "number"
              },
              "issues": {
                "description": "Severity-ranked findings, each 'severity|category|detail' with the reasoning",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "protection": {
                "additionalProperties": true,
                "description": "Deterministic gate result. A veto here is final — the model review cannot override it.",
                "properties": {
                  "protection_score": {
                    "description": "Deterministic gate score, 0-100",
                    "type": "number"
                  },
                  "verdict": {
                    "description": "'approved' or 'rejected' from the gate layer",
                    "type": "string"
                  },
                  "vetoed": {
                    "description": "True if any veto gate failed the submission",
                    "type": "boolean"
                  },
                  "vetoed_by": {
                    "description": "Names of the gates that vetoed, e.g. ['code_reality_gate']",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  }
                },
                "type": "object"
              },
              "provider": {
                "description": "Model that ran the deep review, or 'protection-gates-only'",
                "type": "string"
              },
              "score": {
                "description": "Combined score 0-100 (gates fused with the model review)",
                "type": "number"
              },
              "suggestions": {
                "description": "Concrete fixes to reach approval",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "valid": {
                "description": "The binary verdict: true = approved, false = rejected",
                "type": "boolean"
              }
            },
            "required": [
              "valid",
              "score",
              "issues"
            ],
            "type": "object"
          },
          "annotations": {
            "destructiveHint": false,
            "idempotentHint": true,
            "openWorldHint": true,
            "readOnlyHint": true
          }
        },
        {
          "name": "validate_plan",
          "title": "Gate an implementation plan",
          "description": "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.",
          "inputSchema": {
            "properties": {
              "context": {
                "description": "Optional constraints the review should weigh, e.g. {\"system\": \"payments API\", \"scale\": \"1M users\", \"constraints\": \"PostgreSQL only\"}.",
                "type": "object"
              },
              "plan": {
                "description": "The implementation plan, design or spec to validate, as plain text or markdown — e.g. a numbered migration plan or an architecture sketch.",
                "type": "string"
              }
            },
            "required": [
              "plan"
            ],
            "type": "object"
          },
          "outputSchema": {
            "additionalProperties": true,
            "properties": {
              "confidence": {
                "description": "score / 100",
                "type": "number"
              },
              "issues": {
                "description": "Severity-ranked findings, each 'severity|category|detail' with the reasoning",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "protection": {
                "additionalProperties": true,
                "description": "Deterministic gate result. A veto here is final — the model review cannot override it.",
                "properties": {
                  "protection_score": {
                    "description": "Deterministic gate score, 0-100",
                    "type": "number"
                  },
                  "verdict": {
                    "description": "'approved' or 'rejected' from the gate layer",
                    "type": "string"
                  },
                  "vetoed": {
                    "description": "True if any veto gate failed the submission",
                    "type": "boolean"
                  },
                  "vetoed_by": {
                    "description": "Names of the gates that vetoed, e.g. ['code_reality_gate']",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  }
                },
                "type": "object"
              },
              "provider": {
                "description": "Model that ran the deep review, or 'protection-gates-only'",
                "type": "string"
              },
              "score": {
                "description": "Combined score 0-100 (gates fused with the model review)",
                "type": "number"
              },
              "suggestions": {
                "description": "Concrete fixes to reach approval",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "valid": {
                "description": "The binary verdict: true = approved, false = rejected",
                "type": "boolean"
              }
            },
            "required": [
              "valid",
              "score",
              "issues"
            ],
            "type": "object"
          },
          "annotations": {
            "destructiveHint": false,
            "idempotentHint": true,
            "openWorldHint": true,
            "readOnlyHint": true
          }
        },
        {
          "name": "analyze_code",
          "title": "Advisory code deep-dive",
          "description": "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.",
          "inputSchema": {
            "properties": {
              "analysis_type": {
                "default": "quality",
                "description": "Lens for the review: 'quality' (default, broad ISO/IEC 25010 pass) or a focused pass on one dimension.",
                "enum": [
                  "quality",
                  "performance",
                  "scalability",
                  "security",
                  "tech_debt"
                ],
                "type": "string"
              },
              "code": {
                "description": "The source code to analyze — a function, file or pasted excerpt.",
                "type": "string"
              },
              "language": {
                "description": "Source language, e.g. 'python', 'typescript', 'cpp', 'sql', 'swift'. Inferred if omitted; stating it sharpens findings.",
                "type": "string"
              }
            },
            "required": [
              "code"
            ],
            "type": "object"
          },
          "outputSchema": {
            "additionalProperties": true,
            "properties": {
              "complexity": {
                "description": "low | medium | high",
                "type": "string"
              },
              "issues": {
                "description": "Findings as 'severity|category|detail' with supporting arithmetic",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "provider": {
                "type": "string"
              },
              "quality_score": {
                "description": "0-100 advisory score for the chosen lens",
                "type": "number"
              },
              "suggestions": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "quality_score",
              "issues"
            ],
            "type": "object"
          },
          "annotations": {
            "destructiveHint": false,
            "idempotentHint": true,
            "openWorldHint": true,
            "readOnlyHint": true
          }
        },
        {
          "name": "generate_code",
          "title": "Generate gated code",
          "description": "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.",
          "inputSchema": {
            "properties": {
              "language": {
                "default": "python",
                "description": "Target language for the generated code, e.g. 'python' (default), 'typescript', 'go', 'sql'.",
                "type": "string"
              },
              "max_tokens": {
                "default": 4000,
                "description": "Generation budget. The default 4000 fits most functions/classes; raise it for multi-file scaffolds.",
                "maximum": 32768,
                "minimum": 256,
                "type": "integer"
              },
              "prompt": {
                "description": "What to build, with any constraints worth enforcing — e.g. 'a rate-limited retry decorator with exponential backoff, stdlib only'.",
                "type": "string"
              }
            },
            "required": [
              "prompt"
            ],
            "type": "object"
          },
          "outputSchema": {
            "additionalProperties": true,
            "properties": {
              "attempts": {
                "description": "Generation attempts before approval or give-up",
                "type": "integer"
              },
              "code": {
                "description": "The generated implementation",
                "type": "string"
              },
              "generated": {
                "description": "False only when no provider returned code",
                "type": "boolean"
              },
              "protection": {
                "additionalProperties": true,
                "description": "Deterministic gate result. A veto here is final — the model review cannot override it.",
                "properties": {
                  "protection_score": {
                    "description": "Deterministic gate score, 0-100",
                    "type": "number"
                  },
                  "verdict": {
                    "description": "'approved' or 'rejected' from the gate layer",
                    "type": "string"
                  },
                  "vetoed": {
                    "description": "True if any veto gate failed the submission",
                    "type": "boolean"
                  },
                  "vetoed_by": {
                    "description": "Names of the gates that vetoed, e.g. ['code_reality_gate']",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  }
                },
                "type": "object"
              },
              "provider": {
                "type": "string"
              },
              "validated": {
                "description": "True if the protection gates approved the final attempt; false means the gate findings in 'protection' explain the veto",
                "type": "boolean"
              },
              "validation_score": {
                "description": "Deterministic gate score, 0-100",
                "type": "number"
              }
            },
            "required": [
              "generated"
            ],
            "type": "object"
          },
          "annotations": {
            "destructiveHint": false,
            "idempotentHint": false,
            "openWorldHint": true,
            "readOnlyHint": true
          }
        }
      ]
    },
    "name": "Verificate MCP",
    "note": "Indexed from the official MCP registry: facts and our own checks, not reviewed, so no score, grade or rank.",
    "packages": null,
    "pageJsonUrl": "https://www.anchorterminal.com/tools/verificate-mcp.json",
    "popularity": {
      "githubStars": 1
    },
    "registryName": "ai.verificate/mcp",
    "remotes": [
      {
        "type": "streamable-http",
        "url": "https://mcp.verificate.ai/mcp"
      }
    ],
    "repository": "https://github.com/Verificate-Dev/verificate-mcp-quickstart",
    "reviewed": false,
    "slug": "verificate-mcp",
    "source": "the official MCP registry",
    "sourceUrl": "https://registry.modelcontextprotocol.io/v0.1/servers?search=ai.verificate/mcp",
    "summary": "Agentic code review, no signup to try: reality gates + frontier-model review, with veto.",
    "updatedAt": "2026-08-01T08:03:02Z",
    "url": "https://www.anchorterminal.com/tools/verificate-mcp",
    "vendor": "verificate.ai",
    "vendorUrl": "https://verificate.ai/mcp",
    "version": "1.8.7",
    "websiteUrl": "https://verificate.ai/mcp",
    "where": "hosted",
    "why": [
      "vendor"
    ]
  }
}