> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gildea.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Verification

> If we can't prove it, we don't serve it

For decades, market intelligence sold trust through reputation. You trusted the report because you trusted the name on the cover.

That kind of trust doesn't survive the handoff to a machine. An agent doesn't buy a name; it only trusts what it can verify.

So that's what we built. Gildea follows the AI race as it happens and hands your agents structured intelligence with receipts attached. Every sentence we serve is grounded in its source and verified before it reaches you, giving you intelligence you can build on instead of read and forget.

Gildea is built for teams where one hallucinated claim blows up the deck, the deal, or the trade. We give teams agent speed without the loss of analyst-grade rigor.

## Grounding, then verification

Every unit Gildea serves pairs one claim or sentence with the evidence that backs it. Before that pair is served, two things must be true:

1. **Grounded.** The evidence appears <u>word-for-word</u> in the source.
   * Evidence we can't match verbatim is treated as a hallucinated quote and discarded; the unit survives only if real, verbatim evidence backs it.
2. **Verified.** That pairing runs through a loop built to break the match between the text and the underlying evidence.

```mermaid theme={null}
graph TD
    TU[Text unit] --> V[Verify: ground, score, run checks]
    V --> Q{Clean pass?}
    Q --> |Yes| Served[Served]
    Q --> |Not yet| R[Repair: find better evidence,<br/>then rewrite if needed]
    R --> V
    Q --> |Genuine judgment call| HR[Human review]
    HR --> |Approve| Served
    HR --> |Reject| Dropped[Dropped]

    style TU fill:#000,color:#fff,stroke:#333
    style V fill:#1a1a1a,color:#fff,stroke:#444
    style R fill:#1a1a1a,color:#fff,stroke:#444
    style Served fill:#1a3a1a,color:#fff,stroke:#2a5a2a
    style HR fill:#3a3a1a,color:#fff,stroke:#5a5a2a
    style Dropped fill:#3a1a1a,color:#fff,stroke:#5a2a2a
```

**1. Verify.** Each unit is scored against its evidence: claims to a strict entailment standard, sentences to a faithfulness standard. Then a battery of deterministic checks runs on every pair, regardless of score: contradictions, negation flips, quantity and date mismatches, misquotes, missing entities, and a bidirectional check that catches a claim or sentence quietly *overstating* what its evidence supports. These checks only ever downgrade a pass. They never talk a failure up. When in doubt, the unit doesn't pass.

**2. Repair.** A weak unit isn't dropped on the first try. The system hunts the source for better verbatim evidence and keeps it only if the score actually improves. If better evidence isn't enough, it rewrites the unit and runs it back through the *entire* loop. Repair before rejection.

**3. Triage.** What survives in the gray zone gets adjudicated by two model judges, blind. A unit is only cleared when they fully agree.

**4. Human review.** Only the genuine judgment calls reach a person, never the easy passes. Reviewers can override a verdict, correct the evidence and trigger a re-score, or fix a theme. Every override carries an audit trail.

The result is the contract that matters: **only `verdict=pass` data is served, and presence is the verdict.** If a unit is in the response, it earned its way there.

## Trust contract

What you get back is the verified part of a source, not all of it. The claims and sentences in a [signal](/concepts/signals) are the ones that cleared the loop; the rest were pruned. Read a signal as Gildea's verified view of a source, not a transcript of it.

Thesis and synopsis text is the exception: it's always served whole.

## What the API exposes

By default a unit carries **no** verification block at all. It doesn't need one: being served already means it passed. The block shows up in exactly one case, when a human reviewer signed off.

```json theme={null}
// human-reviewed unit (a flat entry in units[]):
{ "id": "…", "role": "claim", "text": "…", "verification": { "human_reviewed": true } }

// every other (auto-verified) unit: no verification key at all
{ "id": "…", "role": "claim", "text": "…" }
```

That's the whole contract. Raw scores, scoring modes, thresholds, and reason codes stay internal. They're the machinery used to decide pass or fail, not something you need to read. What you get instead is the part that lets you check the work yourself: every unit ships with its `evidence`, and every search result ships with a `citation`.

## Don't trust us. Verify us.

That `evidence` is a short verbatim quote from the source, roughly 100 characters. We keep it short out of respect for the author's work. Gildea points to the original; it doesn't reproduce it.

The evidence snippet acts as a pointer for agents that need more proof before trusting the verdict. Paired with its `citation`, it leads back to the full source, where an agent can confirm Gildea's verification for itself.

You don't have to take our verdict on faith. Check the verifier, then build on it.

<Card title="Recipe: Verify text units" icon="shield-check" href="/guides/verify">
  Follow a unit's evidence and citation back to the source and confirm the verdict yourself.
</Card>