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
groundedandconfidenceso 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.
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.