How it works

From a crawled page to an answer you can replay.

Six steps. A model does the reading; our code does the checking. Every step below says which is which, and what has really run.

The pipeline

The model proposes. Our code checks.

Each stage is one command. Where a model is involved, its output is a proposal that our code verifies against the stored page before anything is kept.

  1. 01Our code

    Crawl

    Public pages are fetched into a dated snapshot, and each page’s bytes are hashed. A timeout is recorded as unknown and retried later, never counted as a failure.

    Ran live: 132 pages of the OpenServ and Reppo docs, 0 errors.

    currant crawl
  2. 02Model, then our code

    Extract claims

    A model reads each page and proposes factual claims, each with a supporting quote. Our code stores a claim only if it finds that quote word for word in the page.

    Ran live: 1,011 claims stored of 1,160 proposed.

    currant extract
  3. 03Model, then our code

    Find what replaced what

    A model proposes pairs of claims that conflict. Our code re-checks every quote and decides which is newer only from evidence it finds word for word: a line that says one value replaced the other, or a different date printed on each page. Without that, the pair is CONTESTED.

    currant relate
  4. 04Our code

    Ground the context

    Before the model answers, the superseded sentence is cut (a span, not the page), its replacement and the ordering quote are pulled in, and contested values are marked with both quotes.

    currant ground
  5. 05Model

    Answer

    The model answers from the grounded context, either from the command line or through a proxy your agent already speaks to.

    currant serve
  6. 06Our code

    Receipt and replay

    The receipt records the hash of the exact context, the snapshot, the models and prompt versions, and every quote used. Replay recomputes the hash with no key and no network.

    currant replay

Use it

Three ways in, from no key at all to your own docs.

Every command needs uv. Only the third path needs an API key, and it costs model credits.

No key, no network

Replay the demo

The demo is built from invented pages and hand-written claims, so anyone can reproduce it end to end and get the same receipt id.

uv sync
uv run currant replay examples/demo/receipt.json \
    --db examples/demo/store.db
uv run pytest            # the full suite, offline

Change one URL

Put it in front of your agent

An OpenAI-compatible proxy. Point your client’s base_url at it: each question is grounded from the store first, then forwarded to SERV under your own key. If it cannot ground, it fails closed with a 503 and sends nothing upstream.

uv run currant serve --extract-run 1 --relate-run 2
# the receipt viewer, with no key:
uv run currant serve --db examples/demo/store.db \
    --extract-run 1 --relate-run 2 \
    --receipts examples/demo/receipts

Tested offline; run live against SERV twice.

Needs SERV_API_KEY

Run it on your own docs

Any site that serves markdown or an llms.txt index; HTML pages are refused. Check the site’s robots.txt and terms first, and tell the maintainers before publishing anything it finds.

uv run currant crawl --config my-docs.toml \
    --out data/mine --corpus mine
uv run currant extract --snapshot data/mine/<date> \
    --db data/mine.db
uv run currant relate --db data/mine.db --extract-run 1
uv run currant drift-report --db data/mine.db \
    --extract-run 1 --relate-run 2 --out mine.md

What a receipt holds

The demo’s receipt, field by field.

Read from the committed examples/demo/receipt.json when this page loads, so it shows exactly what Currant writes. Hashes are shortened here.

Actions: each one cites verbatim quotes, with where they sit in the stored page

    The receipt is not signed. Replaying it proves the context matches what was recorded; it does not prove who recorded it.

    Built on

    One sponsor does the reading. The other does the judging.

    Not built yet

    What Currant does not do today.

    The full list is in LIMITATIONS.md and THREAT_MODEL.md.

    • Retrieval is not wired in. Page retrieval is built and tested, but currant ground still takes the pages you name.
    • Receipts are unsigned. They prove the context, not who produced it.
    • One model for the held-out result. Every measured effect on answers is with gpt-6-luna, on synthetic items. A second detector (claude-haiku-4.5) was tried on dev items only, and it made 2 wrong cuts that the verbatim checks cannot catch.
    • A contested answer named neither value. That cost us points in the Reppo audit. Fixed afterwards in answer-v2, which lists each value the notice quotes; it has not been re-audited yet.
    • Crawl-to-crawl diffs are small. currant crawl-diff and currant as-of work across three snapshots but found one verified change so far, and they do not feed ground yet.
    • Not built at all: a paid x402 endpoint.
    • HTML pages are refused. The crawler reads markdown and llms.txt indexes only.

    Questions

    What people ask first.

    Why not just trust the newest page?

    Pages rarely carry a reliable date, and a page that looks newer can still be the stale one: Reppo’s main docs site describes an API that its own agents.md has replaced. Currant only orders two claims when the pages themselves say which came first: a line such as “this replaces the previous value”, or a date printed on each page. Otherwise it says CONTESTED.

    What happens when it cannot tell which claim is current?

    It marks both as CONTESTED in the context, with both quotes, and never guesses a winner. Today the model’s answer then says the documentation is contested without naming either value, which Reppo’s judges marked as incomplete.

    Does it delete whole pages?

    No. It cuts the superseded sentence only. A page that says “previously 60, now 120” keeps its history.

    Why should I trust what the model proposes?

    You don’t have to. Nothing is cut, annotated or pulled unless our own code found the supporting quote word for word in the stored page, and the claim store itself refuses an unverified quote. The model can miss things; it cannot make Currant act on text that isn’t there.

    How good is it?

    On 93 held-out synthetic items, scored once after a public freeze: precision 0.857 and recall 0.828. When only the stale page was retrieved, answers were right 84.2% of the time with Currant and 0% without. When both pages were retrieved, the model was already right and Currant added nothing. On three real conflicts, Reppo’s judges scored it below the baseline. Details are on the overview.

    Does it work on documentation other than Reppo’s?

    It ran with no code change on a second vendor’s public docs and verified 463 of 611 proposed claims. It found nothing worth reporting there, so that shows it runs elsewhere, not that it works there.

    Can a crawled page tell the model what to do?

    It shouldn’t be able to. Crawled text is treated as data: it reaches the model only behind SERV’s prompt guard, and because that guard can fail open, every decision that matters is re-checked in our own code against the stored page.

    Where does my data go?

    Replaying the demo is entirely offline. Running the pipeline sends pages and questions to SERV under your key. Nothing goes to Reppo unless you submit a file you reviewed, and Reppo evaluations are public.

    Who built it?

    It was built from scratch for the OpenServ and Reppo hackathon, with Claude Code. The code and docs are MIT licensed.

    Replay a receipt before you believe one.

    The demo needs no key and no network, and gives the same receipt every time.

    terminal
    # no key, no network
    uv sync
    uv run currant replay examples/demo/receipt.json \
        --db examples/demo/store.db