Verity is an AI platform for organizations in any industry. It gives teams search, chat, agents and automated work over the documents and tools they already use. Every answer is checked against its sources, every agent action is checked before it runs and a record is kept of both.

How does Verity keep AI safe inside a workflow?

Every answer is checked claim by claim against the sources it was built from, with the passage behind each citation. Agents work from a fixed set of tools and attached Indexes; each action is checked against your sources before it runs, logged with its evidence and can be reviewed or rolled back. Verity calls this Grounded Actions.

How is this different from a model that cites its sources?

Most tools rank sources by similarity to the question, which tends to leave out the sources that disagree. Verity keeps them in, counts support and dispute per source, marks the claims that fail the check and shows the exact passage behind each citation.

Does Verity decide what is true?

No. Verity counts which sources support, dispute or do not address each claim and shows you that count with the passages, so the judgment stays with you.

How do teams connect Verity?

Through the portal, as an MCP tool for the assistants you already run or as an API for your own applications. The same checks run on every surface.

The engine behind Verity, as an API.

Add the Verity check to your own product. Pay as you go at $2.50 per 1,000 checks, with the first 1,000 checks free each month for every organization.

Join the waitlist Contact us

POST /verify

Request

$ curl -X POST https://api.veritylabs.io/verify \
  -H "Authorization: Bearer $VERITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"claim": "The vendor has no open enforcement actions.", "index": true}'

Response

{
  "claims": [{
    "claim": "The vendor has no open enforcement actions.",
    "verdict": "corroborated",
    "distinct_sources": { "supports": 4, "neutral": 2, "refutes": 1 },
    "rosters": {
      "supports": [{ "source": "US GPO", "title": "...", "url": "...", "text_preview": "..." }],
      "neutral": [],
      "refutes": []
    }
  }],
  "stages": []
}

The request as the API takes it today and the response trimmed to its field names. Full list below.

What a check does

Claims checked

Send an answer or a claim. Each claim comes back supported, thin support or unverified against the source passages.

A verdict per source

Each source is counted as supporting, refuting or neutral on the claim, with the passage attached. Sources that disagree are surfaced, not dropped.

Up to 100 source passages

A check is one answer checked against up to 100 source passages.

Repeatable

The same question against the same documents gets the same answer and the same verdict.

Pay as you go.

Open an organization account with or without a subscription and pay only for the checks you run.

$2.50 per 1,000 checks

Billed per check as you use it.

First 1,000 checks free

Every organization gets 1,000 free checks each month.

For products and high traffic

The developer API is for external product integrations, custom deployments and high-traffic use.

One engine, two front doors.

The portal is the workspace. The API is the same check with no interface on top, for the products you build yourself.

1
Open an account
Get an organization account and create an API key in the admin console. It works with or without a subscription.
2
Send a claim
Send an answer or a claim to the verify endpoint with your key.
3
Read the verdicts
Take the per-claim and per-source verdicts, with the passages that decide them, into your product.
4
Pay per check
The first 1,000 checks each month are free for every organization. After that, $2.50 per 1,000.

How teams build on it

Four steps from an organization account to a checked answer.

API reference

The four routes as the API worker serves them today: the fields it reads, the fields it returns and the limits in the code. Nothing here is planned.

Authentication

Create an API key in the admin console at admin.veritylabs.io and send it on every request as Authorization: Bearer <key>. A signed-in portal session works the same way from the browser. A request without either gets 401.

Scope

pools names Space ids. A key sees the Spaces of its organization plus the shared example Spaces; naming any other id returns 403. index: true adds the public record to the search.

Limits

No request rate is coded on /verify, /retrieve or /mcp today; every call is metered to the key. /answer allows 30 requests per key in any 5 minute window and returns 429 past that.

Errors

Every error is JSON with one detail string: 400 Send one question or one statement at a time, 401 Sign in to continue, 403 Space not authorized, 404 not found, 405 method not allowed, 429 Too many requests, 500 and 502 That request could not be completed. A 400 reads That check has expired. Ask again. when the retrieval_id is no longer held.

POST /verify

Checks text against evidence and returns a per-source count per statement.

Request fields

claim string. The statement or answer to check.
claims array of strings. Several statements in one call, in place of claim.
retrieval_id string. From /retrieve. Pins the check to that evidence.
cited array of document ids such as r1. The documents the text cited; checked separately as cited_census.
pools array of Space ids.
index boolean. Search the public record.
record boolean. false limits the check to the documents named in cited.

Response fields

claims: one entry per statement with claim, verdict, distinct_sources, distinct_sources_split, rosters and cited_census when cited was sent.
verdict: corroborated, weak or no_grounding, shown as supported, thin support and unverified.
distinct_sources counts supports, neutral and refutes. distinct_sources_split gives the same counts for index and pools.
rosters lists the sources behind each count, each with source, title, url and text_preview.
contested_inputs maps a document id to the title and text_preview of the inputs that conflict with it.
retrieval_id when the engine held one for this check.
stages: the pipeline stages, each with stage (reading, searching, checking or writing) plus queries, distinct_sources and round where set.
When the engine streams, the same payload arrives as text/event-stream with stage, result and error events.

POST /retrieve

Returns the numbered passages a question retrieves, with a retrieval_id you can pass to /verify.

Request fields

question string. What to look up.
queries array of strings. Extra search legs run with the question.
pools array of Space ids.
index boolean. Search the public record.
retrieval_id string. Extends an earlier retrieval instead of starting a new one.

Response fields

retrieval_id for the stored set.
query and queries as the engine ran them.
documents: id, n, title, url, source and text for each passage.

POST /answer

Plans the searches, writes an answer from the retrieved passages and checks it sentence by sentence. Streams as text/event-stream.

Request fields

question string, up to 2000 characters. claim is accepted as an alias.
pools array of up to 32 Space ids.
index boolean. Search the public record.
model string. A Verity-hosted model id. Omit it for the default.
instructions string, up to 2000 characters. Shapes the answer.
model_knowledge boolean. false answers only from the sources. guardrails: { strict: true } means the same.
context array of earlier turns as { question, answer }. The last four are used.

Events

stage: { stage, queries, distinct_sources, round } as the pipeline moves through reading, searching, writing and checking.
keepalive: { t_ms } every eight seconds while the model writes.
result: everything /verify returns plus question, answer, documents, cited, queries and rating.
rating: { score, provisional, components } where score is 0 to 100 or null when nothing was rateable.
error: { detail }.

POST /mcp

The same engine as an MCP server. JSON-RPC 2.0 over POST at https://api.veritylabs.io/mcp with the API key as a bearer token.

Tools

Methods: initialize, ping, tools/list, prompts/list, prompts/get and tools/call. Notifications are accepted with 202.
search: query (required), index (verity, org or both; both is the default) and indexes (specific Space ids). Returns a retrieval_id and up to 20 documents with id, n, title, url, source and text.
verify: content (required), retrieval_id from a prior search, cited as the [n] numbers used, index and indexes. Returns the /verify payload as structuredContent plus a text summary.
search_templates: no arguments. Returns the Spaces and agents the key can use, each with id and name.
A tool failure comes back as a result with isError: true. An unknown tool is -32602, an unknown method -32601 and unreadable JSON -32700. A missing key is a plain 401.

POST /mcp

tools/list

$ curl -X POST https://api.veritylabs.io/mcp \
  -H "Authorization: Bearer $VERITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'

Getting access

Self-serve sign-up for the developer API is not open yet. Join the waitlist or contact us and we will set up your organization.

Pay as you go at $2.50 per 1,000 checks, with the first 1,000 checks free each month for every organization.

Enterprise plans include API access for internal applications at lower limits. Anything external or high-traffic goes through the developer API.

Join the waitlist Contact us

Build on the engine that shows its sources.

Join the waitlist Contact us

The engine behind Verity, as an API.

Claims checked

A verdict per source

Up to 100 source passages

Repeatable

$2.50 per 1,000 checks

First 1,000 checks free

For products and high traffic

One engine, two front doors.

Open an account

Send a claim

Read the verdicts

Pay per check

How teams build on it

Authentication

Scope

Limits

Errors

POST /verify

POST /retrieve

POST /answer

POST /mcp

Getting access

Build on the engine that shows its sources.