Large language models predict the most likely next token, not the most accurate one. When a model tells you a contract clause says something it does not say, or cites a paper that was never written, the model is not malfunctioning. It is doing exactly what it was trained to do: produce fluent, plausible text. The problem is that plausible and true are not the same thing.

For toy projects, this is a curiosity. For production systems — legal tools, financial dashboards, support assistants, internal knowledge bases — it is a dealbreaker. You should not ship an answer to a user unless you can show where it comes from.

You will see vendors promise "zero hallucinations". We don't. Any system that puts a language model in the loop can get something wrong, and a promise that says otherwise is the first thing your users will catch. Our approach is different: answers are built from your sources, checked against them, and come with the evidence — so your application, not the model, decides what reaches the user. Want to try it first? Our tutorial gets you verified answers in 5 minutes.

1. Retrieval that adapts to the question.

A good answer starts with the right passage. And not every question needs the same search. "Q3 revenue" is a keyword lookup. "What were the main themes discussed across all board meetings?" is a question of meaning, often phrased with words your documents never use.

Wauldo combines both kinds of search and picks, per query, how much work to do:

  • Bm25Only — the fast path. When the question's words clearly match your documents, keyword search alone finds the passage. Exact names, dates, numbers and phrases usually land here.
  • Bm25Reranked — the balanced path. Keyword search finds candidates, then a reranker reorders them by meaning, so the passage that actually answers rises above the one that merely repeats the keywords.
  • DenseFull — the thorough path. When the question uses different vocabulary than the documents, semantic search finds passages by meaning, merged with keyword results.

There is nothing to configure. Your application sends a question; the pipeline chooses. The path it took is reported in audit.retrieval_path (cache_hit when the result came from cache).

2. Passages that cover one topic.

Retrieval can only be as precise as the passages it searches. When a document is cut blindly every few hundred words, one passage mixes returns, shipping and warranty — and a question about shipping retrieves all three.

Wauldo indexes documents with headings, such as Markdown, section by section: each passage covers one topic and keeps its heading, so the passage found for a question is about that question. Long sections are split further, and every piece keeps its heading so it never loses its context.

And when a passage clearly answers a simple question, we don't ask a model to rephrase it. The pipeline returns the sentences of the passage that answer the question — word for word, from your source. No generation, nothing to invent, and an answer in a fraction of the time. Everything else goes to the model, and to the checks below.

3. Answers checked against their sources.

When a question does need a language model, retrieval gets the right context in front of it. The model can still add a number that is not in any source, or stretch a conclusion the documents do not support. So the answer is checked after it is written:

  • Grounding check, on every answer — the key terms of the answer must be found in the passages it was built from. If they are not, the response says grounded: false, and you decide: show a warning, ask for review, or hold it back. It is a fast, word-level check: it catches an answer that drifted away from its sources, not a single wrong figure in an otherwise sourced sentence. That is the fact-check's job, below.
  • Not found means not found — when no passage is found, the API says so instead of asking a model to improvise. And when a written answer is both unsupported by its passages and backed by weak evidence, the model's text is replaced by a "not enough evidence" message. A non-answer beats a wrong answer. (Streamed answers go out as they are written; their final event carries grounded and confidence so your app can still act on them.)

For any text — an answer from Wauldo, from another model, or from your own agent — /v1/fact-check goes further, claim by claim. Each claim is matched against your sources, and the checker names what went wrong when something did: a number that does not match (numerical_mismatch), a negation that flips the meaning (negation_conflict), a name or entity that differs (entity_mismatch). Every claim gets a verdict — verified, weak or rejected — and the response an action your code can follow: allow, review or block.

Why not ask the model?LLMs are notoriously bad at knowing when they are wrong. The checker does not ask the model whether it is confident. It looks for the evidence, independently, in your documents.

4. A confidence score you can act on.

The confidence in a Wauldo response is not the model grading itself, and it is not a raw search score. It is a calibrated probability that the passages returned actually answer your question, read by a dedicated relevance model and measured against a labeled benchmark. If that model is momentarily unavailable, a conservative fallback takes over — one that never reports high.

  • High — the passages answer the question. On our benchmark, the large majority of high-labeled answers are answerable from the passages returned.
  • Medium — related passages, weaker evidence. Worth a second look before it drives a decision.
  • Low — the documents probably do not hold the answer. Treat it as "not found".

The confidence_label field (high / medium / low) is built for application logic: show a badge, route medium answers to a human, hide low ones.

One honest limit: relevance is not truth. A passage on the right topic that lacks the specific fact you asked for can still look relevant. That is exactly why the grounding check and the fact-check run separately — three independent signals beat one.

5. The audit trail.

Every response carries a structured audit object. It is not a debug feature: it is a first-class part of the API, designed for logging, dashboards and regression tests.

{
  "audit": {
    "confidence": 0.87,
    "confidence_label": "high",
    "grounded": true,
    "retrieval_path": "Bm25Only",
    "sources_used": 2,
    "sources_evaluated": 12,
    "model": "auto",
    "latency_ms": 1243
  }
}

Add debug: true to a query and you get the retrieval funnel — how many candidate passages were found and how many survived each filtering step:

{
  "audit": {
    "confidence": 0.87,
    "confidence_label": "high",
    "grounded": true,
    "retrieval_path": "Bm25Only",
    "sources_used": 2,
    "sources_evaluated": 12,
    "model": "auto",
    "latency_ms": 1243,
    "candidates_found": 47,
    "candidates_after_tenant": 31,
    "candidates_after_score": 12,
    "query_type": "factual"
  }
}

This is how you diagnose an answer in production without access to our logs. Few candidates after scoring? The question's wording does not match the documents. Low confidence on a question you know is covered? The document may need better structure. Each answer explains itself.

What we promise — and what we don't.

We do not promise that a language model will never be wrong. Nobody can, and you should be wary of anyone who does.

Here is what we do promise:

  • Receipts on every answer — the passages it came from, so anyone can check.
  • A check, not a hope — every answer gets a grounding check against its sources, and claim-by-claim verification is one call away.
  • A number you can act on — a calibrated confidence, not a model's opinion of itself.
  • An honest "not found" — when no passage is found, the API says so instead of guessing; when the evidence is weak, the confidence says so.

Our results are measured, not claimed: our adversarial benchmark runs every Monday, and the benchmarks page publishes each week's results, versioned in git.

If you are building an application where a wrong answer has consequences, that is the pipeline you want behind it. Avoid the 5 most common RAG mistakes that quietly degrade production systems, and see why LangChain plus retrieval alone isn't enough on adversarial prompts.


Try it freePaste any AI answer into our home widget for a numeric support_score. 500 verifications/month free on RapidAPI. See pricing →