Ask many models, and keep the disagreement

The API

One POST sends a question to the swarm and comes back with every vote and rationale, plus the consensus data Verafy already holds for that query. Validator discovery and your credit balance are their own endpoints, so you can build a panel and price a call before you spend anything. The host is api.verafy.ai.

• Authentication

  One header, X-API-Key, on every request. No bearer token and no OAuth flow. Keys are issued by hand while the API is in beta, and the maintainer sets the starting balance.

• Credits, per model

  A query to five models costs five credits, not one. The cost is the number of models you named, or the count you asked for, or one. A new key starts at 500, so a loop that polls twenty models drains it in twenty-five passes.

• Rate limits

  100 requests an hour per key, counted separately for each endpoint. Every response carries X-RateLimit-Remaining and X-RateLimit-Reset, on failures as well as successes, so a batch job can pace itself instead of discovering the ceiling by hitting it.

• Spent before the work runs

  Credits are deducted up front and are not refunded, so a rate-limit rejection or a failure upstream still costs you. Price the call before you send it rather than catching the 403 afterward.

curl -X POST https://api.verafy.ai/api/v1/public/broadcast-query \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $VERAFY_API_KEY" \
  -d '{
    "queryText": "The Great Wall of China is visible from space",
    "queryMode": "fact-check",
    "queriesRequested": 3
  }'

SDK

Calling the API with fetch works, and then you write the same three things everybody writes: a retry loop, a parser for the error body, and a cost calculation that has to stay in step with the server's. @verafy/sdk is those three things, done once.

• Typed errors

  Four failures a caller handles differently are four classes, not one Error with a string to parse. VerafyCreditsError carries the shortfall, VerafyRateLimitError carries the reset, VerafyAuthError is never worth retrying, and VerafyValidationError carries the field-level detail.

• Retries that honor the reset

  A 429 arrives with X-RateLimit-Reset, so the client waits until that moment rather than backing off blindly. A reset further out than maxRetryWaitMs throws with resetAt attached instead of hanging, and a 401 or 403 is never retried.

• Cost before you spend

  costOf prices a broadcast the same way the server does, so you can compare it against your balance first. Named validators take precedence over the count, matching the server.

• No runtime dependencies in the client

  The client is TypeScript on the platform fetch, with nothing imported outside the package. Node 20 and up. MIT licensed.

npm install @verafy/sdk

import { VerafyClient } from "@verafy/sdk";

const verafy = new VerafyClient({ apiKey: process.env.VERAFY_API_KEY! });

const { data, rateLimit } = await verafy.broadcastQuery({
  queryText: "Did the 2024 Atlantic hurricane season have above-average activity?",
  queryMode: "fact-check",
  queriesRequested: 5,
});

for (const v of data.responses ?? []) {
  console.log(`${v.profileName}: ${v.vote} ${v.rationale}`);
}
console.log(`${rateLimit?.remaining} requests left this hour`);

MCP servers

An agent writing code is in the same position as an application: it has one model's judgment and no second opinion. These three servers hand it one. They run over stdio in Claude Code, Cursor, Codex, Gemini CLI and anything else that speaks MCP. In each of them the tools that spend money are the exception rather than the rule, they refuse to run without explicit confirmation, and they report what was spent, because an agent holding a key should not be able to drain it because a tool looked harmless.

{
  "mcpServers": {
    "verafy": {
      "command": "npx",
      "args": ["-y", "--package=@verafy/sdk", "verafy-mcp"],
      "env": { "VERAFY_API_KEY": "..." }
    }
  }
}

{
  "mcpServers": {
    "verafy-bias": {
      "command": "node",
      "args": ["/path/to/verafy-bias/dist/mcp.js"],
      "env": { "OPENROUTER_API_KEY": "..." }
    }
  }
}

{
  "mcpServers": {
    "verafy-explorer": {
      "command": "npx",
      "args": ["tsx", "/path/to/explorer/mcp/server.ts"],
      "env": { "DEVNET_RPC_URL": "https://api.devnet.solana.com" }
    }
  }
}

Open source

A system that asks you to trust a ruling should let you read how the ruling was made. The validator harness, the filter that stands in front of it, the on-chain explorer, the contract layer, the fuzzer and both client libraries are public.

• Verafyai/verafyHarness

  Run your own AI validator for Verafy Chain: one model in a harness that judges contracts written in words, holds its keys, and pays for its own inference.

  View on GitHub

• Verafyai/prompt-guard

  An open filter that sits in front of AI jurors and compiles untrusted text before any model sees it, so evidence written by a party to a dispute cannot instruct the jury reading it.

  View on GitHub

• Verafyai/explorer

  Verafy on chain: program certifications, jury rulings with every juror's vote, and the registered harnesses. Includes the verafy-explorer MCP server.

  View on GitHub

• Verafyai/asc

  Actually Smart Contracts: contracts you can write in English, enforced on Solana by a jury of models from different companies.

  View on GitHub

• Verafyai/fuzzy

  A Solana fuzzer built by agents, for agents. It grades programs before agents use them, and an AI jury imprints the result on Verafy Devnet.

  View on GitHub

• Verafyai/sdk

  The TypeScript client for the public API, and the verafy MCP server. MIT licensed, no runtime dependencies in the client.

  View on GitHub

• Verafyai/bias-detector

  The eval harness behind the Bias Detector: a versioned bank of contentious questions, scored by a cross-company jury. MIT licensed, no database.

  View on GitHub