Verificate MCP

Verificate MCP — do seu MVP feito no vibe coding até a produção

Saída real do servidor ao vivo: 12 linhas de código de pagamento escrito por IA — rejeitado, corrigido, aprovado, em segundos.

Você fez a demo no vibe coding. Isto leva ao lançamento. Entre uma demo funcional e um produto lançado, costumava existir um CTO experiente e um time sênior de desenvolvimento — as pessoas que pegam o caminho de reembolso falso, a chamada de SDK inventada, o loop que morre sob tráfego real. Verificate MCP é esse time de revisão como um servidor MCP: 17 portões de realidade determinísticos com poder de veto, combinados com uma revisão empresarial de modelo de fronteira (ISO/IEC 25010: desempenho, escalabilidade, confiabilidade), executados em cada mudança escrita por IA antes de chegar ao seu código. A IA escreve; o portão mantém o padrão; você lança. Hospedado, sem instalação, veredito binário em segundos — no Claude Code, Cursor, Windsurf ou qualquer cliente MCP.

Não é outro wrapper de linter. A prateleira de qualidade de código em todos os diretórios MCP tem duas coisas: scanners (pontes ESLint, Semgrep e SonarQube — regras determinísticas, sem julgamento) e relays de prompt que enviam seu repositório para sua própria chave de LLM (auto-revisão com passos extras). Verificate não é nenhum dos dois: os portões têm poder de veto que nenhuma saída de modelo pode sobrescrever.

Seu assistente de codificação escreve um mock e diz que está pronto. Ele inventa uma chamada de SDK que não existe. Ele envia um loop N+1 que passa em todos os testes e morre sob carga. Verificate MCP executa a revisão profunda em cada saída de IA — primeiro os portões de realidade determinísticos (qualquer um pode vetar), depois uma revisão de nível empresarial pontua o que sobrevive — antes que o código chegue ao seu codebase.

Uma rejeição real (verbatim)

12 linhas plausíveis de código de pagamento escrito por IA foram enviadas pelo gateway de produção. Veredito: REJEITADO — pontuação 30,8/100, vetado por code_reality_gate, com descobertas incluindo:

"Chamadas de API síncronas N+1 … Para 100 itens, isso resulta em 100 roundtrips HTTP sequenciais, levando ~10–20 segundos e bloqueando o event loop/thread de trabalho … vai disparar o rate limiting do Stripe (limite de 100 req/seg)." "stripe.Inventory não é um recurso válido do SDK do Stripe." "Problemas de representação de ponto flutuante levam a erros de arredondamento em transações financeiras; a API do Stripe exige centavos inteiros."

Cada uma dessas é uma tarde de depuração de produção, pega em segundos.

Medido — vs. pedir ao modelo para revisar seu próprio código

Um modelo de fronteira perguntado "isso está OK para merge?" em um fluxo de trabalho natural perdeu reward-gaming (um teste que só faz assert True) e uma API alucinada (stripe.Refund.create_partial) em 0 de 6 execuções cada. O portão do Verificate pegou ambos 6 de 6 — deterministicamente, com 0 falsos positivos em código limpo.

Caso adversarial	Revisão de LLM sozinha	Portão Verificate
Reward-gaming (teste assert True)	0 / 6	6 / 6
API alucinada (chamada de SDK inexistente)	0 / 6	6 / 6

Testado em batalha: 2.581 validações auditadas ao longo de 5 semanas (66 rejeitadas, 270 sinalizadas como inadequadas), incluindo a proteção do caminho de escrita de uma base de conhecimento com citação de fontes de 21M de entidades (98,6% citado, 100% licenciado em 268 fontes). Reproduza: scripts/ · artigo completo: COMPARISON.md.

Ferramentas

Cada ferramenta tem um trabalho — dois portões que retornam vereditos, um consultor que não retorna, um gerador:

Ferramenta	Trabalho	Retorna
validate_ai_output	O portão de merge para código escrito por IA. Portões de realidade determinísticos (veto de mock/placeholder, detecção de gaming e bypass, verificações de API inventada) rodam primeiro e não podem ser sobrescritos; a revisão ISO/IEC 25010 pontua o que sobrevive.	Veredito binário aprovar/rejeitar + descobertas classificadas por severidade
validate_plan	O portão para planos e designs, antes de qualquer código existir — completude, viabilidade, implicações de escalabilidade, risco. O lugar mais barato para pegar um design ruim.	Veredito binário aprovar/rejeitar + descobertas
analyze_code	Mergulho profundo consultivo em código existente — caminhos quentes, matemática de rate limit, modos de falha, dívida técnica. Use para entender uma rejeição ou revisar código herdado.	Pontuações + descobertas, deliberadamente sem veredito
generate_code	Gerar + portão em um passo — o LLM escreve, o mesmo mecanismo de proteção valida antes de você ver.	Código com portão (sem placeholders, sem APIs inventadas)

Além das ferramentas

O servidor também inclui prompts e recursos para uma experiência de cliente mais rica:

• Prompts gate_my_changes / review_my_plan — fluxos de trabalho de um clique que fazem loop validar → corrigir → revalidar até aprovar.
• Recursos verificate://gates (o que cada um dos 17 portões determinísticos observa) e verificate://example-verdict (uma rejeição de produção verbatim).

Início rápido — sem cadastro, sem token, 30 segundos

Cada máquina recebe 25 validações gratuitas — sem conta, sem cartão, sem chave. Adicione a URL e vá:

Claude Code

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

Cursor / VS Code — instalação em um clique:

Os botões de um clique do LM Studio e Goose estão em https://verificate.ai/mcp (o GitHub remove links de protocolo personalizado).

Windsurf / qualquer cliente MCP (JSON)

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

Cursor: ~/.cursor/mcp.json. Windsurf: ~/.codeium/windsurf/mcp_config.json.

Depois, peça ao seu assistente para "validar esta função com verificate" — um veredito estruturado volta em segundos, e cada resposta do nível gratuito mostra quantas validações você ainda tem e o que o portão pegou para você.

Continue após os 25 gratuitos

Cadastre-se em https://verificate.ai/auth/signup (teste de 30 dias, sem cartão — depois $30/mês) e adicione seu token à mesma configuração:

claude mcp add --transport http verificate \
  https://mcp.verificate.ai/mcp \
  --header "Authorization: Bearer YOUR_TRIAL_TOKEN"

ou na configuração JSON adicione "headers": { "Authorization": "Bearer YOUR_TRIAL_TOKEN" }.

Torne o portão o padrão

Ferramentas que um agente pode chamar são ferramentas que ele vai pular sob pressão. Adicione uma regra permanente (Claude Code: CLAUDE.md; Cursor: um arquivo de regras):

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.

Prompts de configuração em um único paste que instalam essas regras para você: PROMPTS.md. Ou conecte no CI como um portão de merge — veja examples/.

Como ele decide

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)

As duas etapas são deliberadamente separadas: se realidade e qualidade fossem misturadas em uma única pontuação, uma função lindamente estruturada que falsifica seu caminho de reembolso ainda poderia ter média "aceitável". Uma arquitetura de veto torna isso impossível.

A categoria, honestamente

Tudo o mais na prateleira de qualidade de código MCP é gratuito — e isso é justo, porque um wrapper deveria ser gratuito. O que você não consegue de graça é julgamento com autoridade:

O que você encontrará nos diretórios	O que é	O que estruturalmente não pode fazer
Wrappers de linter — ESLint MCP, Semgrep MCP, SonarQube MCP	Scanners baseados em regras expostos como ferramentas MCP. Determinísticos, gratuitos, vale a pena rodar.	Sem julgamento. Regras não sabem que a função de reembolso nunca chama o provedor de pagamento, ou que stripe.Inventory não existe. Sem veredito, sem veto — descobertas que seu agente é livre para ignorar.
Relays de revisão com sua própria chave	Seu repositório + um prompt de revisão, enviados para sua própria chave OpenAI/Anthropic.	Auto-revisão com passos extras: o revisor compartilha os pontos cegos do gerador, não há portões determinísticos por baixo, e o que o modelo diz vale. Você mantém chaves, versões e hospedagem.
Um modelo maior	Esperar que o gerador se revise melhor.	Auto-revisão herda auto-cegueira. Um portão externo mantém o mesmo padrão para todo modelo — o que também torna modelos menores e mais baratos seguros para lançar: mesmo portão de qualquer forma.
Revisão humana de cada diff de IA	O padrão ouro, na velocidade humana.	Não escala na velocidade de geração de IA. O portão faz a primeira passagem em segundos; humanos revisam vereditos, não diffs brutos.
Verificate MCP	Portões de realidade determinísticos com veto, depois uma revisão empresarial de modelo de fronteira — fundidos em um veredito binário. Hospedado, sempre no modelo atual.	—

Essa segunda camada é a parte pela qual você paga: um agente de fronteira fazendo a revisão profunda — aritmética de produção, modos de falha, realidade de SDK — com um piso determinístico embaixo que o próprio agente não pode contestar.

Rode localmente (ponte stdio)

Este repositório também é um servidor MCP executável, sem dependências: uma ponte stdio que serve initialize/tools/list localmente e encaminha chamadas de ferramenta para o gateway hospedado. Use com clientes que preferem servidores stdio:

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

Ou com Docker:

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

Sem VERIFICATE_TOKEN, a introspecção ainda funciona e as chamadas de ferramenta retornam instruções para obter um token de teste.

FAQ

Isso deixa o agente mais lento? Cada validação leva segundos, dentro do loop, antes que o trabalho seja apresentado. Compare com um defeito encontrado em CI ou produção mais a troca de contexto para corrigi-lo — o portão é mais rápido no geral para qualquer mudança que importa.

Quais linguagens? A validação é agnóstica de linguagem; a análise cobre linguagens mainstream (Python, JS/TS, C++, SQL, Swift, …). Passe context.language para melhores resultados.

Pode bloquear meu agente? Sim — esse é o ponto. Um veredito REJEITADO é projetado para mandar o agente de volta para corrigir as descobertas em vez de apresentar trabalho quebrado. Sua regra permanente decide o quão forte é a parada.

E falsos positivos? Vereditos vêm com descobertas específicas e a matemática, então são auditáveis em segundos — você nunca é pedido a confiar em uma pontuação nua.

Segurança e privacidade

• Requisições são autenticadas com seu token pessoal; chaves são de usuário único e com rate limit, com detecção de compartilhamento de chave.
• O código é processado para produzir o veredito e não é usado para treinar modelos.
• initialize/tools/list são públicos (para clientes e diretórios poderem fazer introspecção); toda tools/call exige sua chave.

Preços

Teste gratuito de 30 dias, depois USD $30/mês (oferta de lançamento: 50% de desconto por 3 meses). Preços para volume e acadêmicos: info@verificate.ai.

Guias

• Como pegar código alucinado por IA antes de lançar
• Adicione um portão de revisão de código ao Claude Code em 5 minutos
• Por que assistentes de IA perdem bugs profundos de desempenho
• Use modelos de codificação de IA menores e mais baratos — com segurança
• Todo Bob precisa de uma Wendy (Comunidade IBM)

Sobre

Construído pela Verificate Pty Ltd (Sydney, Austrália) — um IBM Business Partner. A Verificate constrói infraestrutura soberana de IA: o motor de inferência HELIX (pontuações de confiança calibradas em cada resposta), o Decision Transformer determinístico, e este servidor de validação MCP. Página do produto: https://verificate.ai/mcp · Registro oficial: ai.verificate/mcp

Licenciamento

Este repositório (a ponte stdio, configurações de cliente e exemplos de CI) é MIT — use livremente. O motor de validação Verificate e o gateway hospedado com o qual ele fala são um serviço comercial (teste gratuito de 30 dias, depois assinatura): os 17 portões de proteção e a revisão de modelo de fronteira rodam no lado do servidor e não fazem parte deste repositório.

Glama

---

🌐 Não fala inglês? Instruções de instalação em हिन्दी · Português · Bahasa Indonesia · Español · 中文 · Tiếng Việt → INSTALL.md