The primitive is a numeric support_score between 0 and 1 on every answer, grounded claim-by-claim against the sources you provide. Not a vibe check. Not an LLM-judge. A measurement.
LLMs write fluently whether or not the claim is true. Eval sets pass. Production hallucinates. The gap between "sounds right" and "is supported by the docs you shipped" is where trust dies.
The model fabricates a statistic, a date, an API signature, a citation. It reads as plausible. No grep against your sources will catch it because nothing ties the claim back to any document.
When a customer asks "why did your bot say this", you have no per-claim verdict, no source reference, no score. You have a string. Compliance, support, and debugging all fail at the same wall.
A snippet inside a PDF says "ignore previous instructions". Your agent pivots. Without ground-truth verification against the content you trust, injection attacks look identical to normal output.
Wauldo extracts the atomic claims from an answer, matches each against the source context you provide, and returns a score equal to the fraction of claims supported. Per-claim verdicts travel with the response.
{ "support_score": 0.85, "verdict": "VERIFIED", "hallucination_rate": 0.15, "claims": [ { "text": "Paris is the capital of France", "verdict": "supported", "source_ref": "doc_1:L3" }, { "text": "Paris has 2.1 million residents", "verdict": "supported", "source_ref": "doc_1:L5" }, { "text": "Paris was founded in 2000 BC", "verdict": "unsupported" } ], "mode": "lexical", "latency_ms": 847 }
We decompose the answer into atomic factual statements. Hedged phrasing, adjectives, and opinion are excluded. Only propositions that can be checked against sources are scored.
Each claim is matched against the source_context you pass in the request. Three modes: lexical (fast, <1s), hybrid (multilingual embeddings), semantic (LLM-judge).
support_score = supported / total. The number is deterministic for a given input on lexical mode. Per-claim verdicts and source references let you render the reasoning to a user.
Most AI tooling hides failure modes behind a "confidence threshold". Wauldo ships the rejection explicitly. When the answer drifts below grounding, the verdict is BLOCK and the integer score tells you why.
Query: "Can I combine ibuprofen and warfarin?"
Answer (fabricated): "Yes, it is safe to combine them at standard doses, no interaction is documented."
Source context: empty — no pharmacology documents attached.
Verdict: BLOCK · 1 of 2 claims unsupported · hallucination_rate = 0.50. The answer cannot be grounded against the provided sources, so Wauldo refuses to emit SAFE. Your app decides what to show the user — we hand you the decision, not a laundered hallucination.
Enough claims match the sources to surface the answer. Per-claim verdicts still travel for inline rendering.
Some support, some drift. Your app can choose to show the answer with warnings, or ask for more sources.
The response directly contradicts the source context. Refusal is explicit — never laundered as "I'm not sure".
Other approaches proxy for trust. Wauldo returns a number you can log, threshold, graph, and reason about. The table is not marketing — it's the boundary condition for each tool.
| Approach | Measurable | Auditable | Deterministic | Cost / call |
|---|---|---|---|---|
| Wauldo | yes — numeric 0–1 | yes — per-claim verdicts | yes (lexical mode) | $0.002 |
| LangChain guardrails | binary pass / fail | partial — regex + list | yes | ~free |
| LLM-as-judge | fuzzy — vibe score | chain-of-thought prose | no — varies run to run | $0.02 – $0.10 |
| Naive RAG citation | no | citation markers only | yes | ~free |
// read this row before reacting
A guardrail says no. A judge says maybe. A citation says there exists a doc. None of these tell you how much of the answer is actually supported by the source you shipped. That is the number Wauldo returns. Everything else on this page is plumbing around that one measurement.
Guard mode is the verification primitive wrapped around an LLM call instead of called after it. Same /v1/fact-check endpoint. Different integration point. It pre-screens agent outputs, post-filters RAG answers, and triage-rejects support bot responses before they reach a human. Works on RAG pipelines and AI agents identically.
# same primitive, guard posture: verify before you render curl https://api.wauldo.com/v1/fact-check \ -H "Authorization: Bearer $WAULDO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "text": "Your agent answer to screen", "source_context": "The docs, tickets, or corpus you trust", "mode": "lexical" }' # check the verdict field: SAFE → ship · PARTIAL → your app decides UX # UNVERIFIED / BLOCK → do not render; escalate or refuse.
Your agent drafts an answer. Wauldo scores it. Low score → regenerate with stricter retrieval or refuse.
RAG answer streams back. Buffer, score once full, then emit. Cache writes before emit so disconnects are safe.
Keep the full response. Paint supported claims green, unsupported red, show source references on hover.
Free tier on RapidAPI. 300 verifications per month on the house. No card. Ship today, measure Monday.
$ curl api.wauldo.com/v1/fact-check