Grounding & eval

Grounding & Evaluation

We make language-model output trustworthy: grounded in real sources, checked claim by claim, and measured against a quality gate before anything ships.

Most language-model failures are not bad writing — they are confident fiction. nuvio builds the layer that makes generated output safe to act on: AI grounding that forces every answer back to a real source, a second independent model that re-reads that source and verifies the first, and LLM evaluation harnesses that score accuracy per claim before anything reaches a user. We treat reduce-LLM-hallucination as an engineering problem with measurable inputs — retrieval, verbatim citation, and a hard quality gate — not a prompt you keep tweaking and hoping.

Grounding generation in real evidence, not the model's memory

A model left to free-associate will invent a method name, a column, or a policy that sounds right and isn't. AI grounding closes that gap by making the model read before it writes. We retrieve the exact source material a claim depends on — a code symbol with its body, a contract clause, a paragraph of a standard — and require the generated answer to cite it verbatim rather than paraphrase. For bounded corpora we inline the full source and lean on prompt caching; for larger ones we shortlist candidates with full-text search, then let the model pick from a handful of high-signal passages. The output carries explicit references back to the lines, rows, or paragraphs that produced it, so every conclusion is traceable to evidence.

A second independent agent that verifies the first

The pattern that actually reduces LLM hallucination is adversarial: one model produces, a second judges. We run the verifier in a fresh context that never sees the first model's prompt — it only sees the output plus the same access to the real source. It re-reads the underlying code or documents and issues a per-claim verdict — accurate, mostly accurate, partial, wrong, or unverifiable — with the specific evidence it checked against. In practice this catches things a single pass never would: a fabricated function, the wrong service class, a guard on a column that doesn't exist. Because the verdict is structured per claim, you can triage and regenerate the weak parts instead of discarding the whole answer.

A quality gate that blocks bad output before it ships

Verification only matters if something acts on it. We wire the verifier's verdict into a hard gate: when the judgment is fail, the downstream step is blocked, with an explicit override for the rare case a human overrules it. This is the difference between an eval that produces a dashboard nobody reads and an LLM evaluation that changes what reaches production. The gate sits at the boundary where generated artifacts become real — the moment before a spec is emitted, a finding is surfaced, or a record is written. Everything below the bar is held back automatically, so the system fails closed rather than shipping confident fiction at scale.

Evals that measure accuracy, not vibes

You cannot improve what you cannot score. We build LLM evals as real test harnesses: a fixed set of inputs, a known-good reference, and a per-claim scoring pass that yields an accuracy number you can track release over release. For retrieval-augmented systems we add RAG evaluation specifically — did the right passage get retrieved, did the model cite it, and is the cited text actually load-bearing for the conclusion. Scores are typed, not a single scalar: a low number that means "the source is missing" demands a different fix than one that means "two reasonable readings disagree." That distinction tells you whether to improve retrieval, the prompt, or the human-review path.

Typed confidence and honest uncertainty

A flat percentage hides why the model is unsure, and that's where AI accuracy quietly breaks. We expose the source of uncertainty as a typed signal — incomplete input data, genuine ambiguity in the source, competing valid interpretations, or low-confidence retrieval — so the next actor knows what to do about it. High-stakes or inherently ambiguous cases route to mandatory human review regardless of the computed score; clean, deterministic cases pass automatically. The model's job there is not to guess an answer but to surface the right question with the evidence attached. That framing keeps the system useful on the easy majority while staying honest about the hard cases it should never decide alone.

What this includes

Retrieval that pulls the exact source a claim depends on — code symbols, clauses, paragraphs — with verbatim citation back to it
A second, independent verifier agent in a fresh context that re-reads the source and issues per-claim verdicts
A hard quality gate that blocks downstream steps on a fail verdict, with an auditable override path
Eval harnesses with fixed inputs, reference answers, and per-claim accuracy scoring tracked across releases
RAG evaluation that checks retrieval, citation, and whether the cited text actually supports the conclusion
Typed confidence signals that name the source of uncertainty and route ambiguous cases to human review

What you get

Generated output you can act on, because every claim is grounded in a real source and verified before it ships
A measurable accuracy number per release instead of anecdotes — you can see grounding improve or regress
Fewer production incidents from confident fiction, because the gate fails closed rather than shipping unverified claims

Where it fits

Use cases

Verifying generated artifacts

A pipeline produces summaries, specs, or labels from a codebase or document set. A second independent agent re-reads the source and verdicts each claim, catching fabricated names and wrong references before they propagate downstream.

Grounded findings with citations

An expert-review tool proposes conclusions from regulatory or contract text. Each conclusion cites the verbatim paragraph it applied, so a reviewer defends it to an auditor without re-deriving it from scratch.

Continuous RAG evaluation

A retrieval-augmented assistant drifts as the corpus grows. A scored eval harness flags when the right passage stops being retrieved or cited, turning silent accuracy regressions into a number that fails the build.

FAQ

Common questions

We make it structural. Output is grounded in retrieved source and must cite it verbatim, then an independent second model re-reads that source and verdicts each claim. A hard gate blocks anything that fails. Prompt tuning helps at the margins, but AI grounding plus independent verification is what removes whole classes of fabrication rather than reducing their frequency.

A model that grades its own work shares its blind spots and tends to defend its first answer. We run the verifier in a fresh context that never sees the original prompt — only the output and the real source. That independence is what makes the LLM evaluation honest, and it's how the layer catches fabricated functions and wrong references a self-check would wave through.

With real LLM evals: fixed inputs, reference answers, and per-claim scoring that produces a number we track release over release. For retrieval systems we add RAG evaluation — was the right passage retrieved, cited, and load-bearing. Scores are typed by the source of uncertainty, so you know whether to fix retrieval, the prompt, or the human-review path.

The verifier is a second pass, but you can run it on a smaller, faster model since judging is cheaper than generating. Grounding often uses full-text search and prompt caching rather than heavy vector infrastructure, which keeps cost flat per request. The gate runs before expensive downstream work, so it usually saves more compute than it spends.

Explore more capabilities

04 — Capability

Building something that needs this?

Tell us what you're working on. The first call is always free.

Start a project→All capabilities