One answer, four ways to cite it

TL;DR: TokenPath adds citations to an existing AI answer without rewriting it. On LongBench-Cite, it scored 0.815, compared with 0.812 for Anthropic's Citations API, 0.851 for GPT-5.5, and 0.622 for embedding retrieval. Compared with GPT-5.5, TokenPath was 6× faster and 7× cheaper.

Three ways you get citations today

Today, citations usually come from one of three workflows:

1. Prompt an LLM to cite. Hand a model the document, the question, and the answer, and ask it to attach supporting quotes — an "add-citations" pass.
2. Regenerate through a citations API. Anthropic's Citations API rewrites the answer while emitting citations inline.
3. Retrieve. Embed the answer's sentences and search the source for similar passages.

Each has a catch: the first two spend a frontier-LLM call per query, the second generates a new answer, and the third can struggle when the answer uses different wording from the source.

TokenPath does a fourth thing: it takes an existing answer and uses a separate open model to find the source text behind each claim. It does not rewrite the answer, and it works regardless of which model wrote it. We compared it with the three workflows above on a benchmark we did not write.

The setup: one answer, four ways to cite it

We use LongBench-Cite (THUDM), a citation-quality benchmark over long documents. We take the English subset — gov_report, hotpotqa, longbench-chat, multifieldqa_en. The main results cover 480 examples.

The design choice that makes the comparison fair is a shared answer:

1. The Anthropic Citations API answers each question normally (document + question → a cited answer from Claude Sonnet 5). A real, naturally generated answer — no artificial "reproduce this text" prompting.
2. TokenPath, GPT-5.5, and embedding retrieval then add citations to that same answer text.

This keeps the answer fixed when we compare citation quality. The workflows are not identical: Anthropic generates the answer with citations, while TokenPath and GPT-5.5 add citations to an existing answer. GPT-5.5 is therefore the closest comparison for speed and cost.

Scoring

One judge (gemini-2.5-flash) scored every method using LongCite's recall, precision, and F1 prompts. We ran 480 examples across four datasets. Following LongCite's convention, the headline F1 averages three of them; multifieldqa_en appears in the per-dataset results below but not in the headline average.

Results

All four methods ran on the same 480 answers. The headline scores use LongCite's three-dataset average:

Embedding is the only method with a separate one-time indexing cost: every document sentence must be embedded before queries can be cited.

Three things stand out.

TokenPath matched Anthropic's citation quality. TokenPath scored 0.815, compared with 0.812 for the Citations API and 0.851 for GPT-5.5. Its precision of 0.938 was the highest of the four methods.

It was 6× faster and 7× cheaper than GPT-5.5. The speed comparison uses the same full-answer citation workload. TokenPath costs $1 per 1M attributed tokens, regardless of which model wrote the answer.

It doesn't touch your answer. The Citations API regenerates: its citations are clean, but it ships a different answer than the one you validated. TokenPath, prompted, and embedding all cite the exact answer you already have.

The cost/quality frontier

GPT-5.5 scored 0.036 higher than TokenPath, but cost about 7× more. TokenPath offers nearly the same citation quality at much lower cost.

Where each method is strong

TokenPath is strongest on extractive QA — on hotpotqa it ties the prompted frontier LLM and beats the Citations API by 0.08 — and weakest on abstractive tasks.

Where attention beats retrieval

The aggregate gap over embedding retrieval (0.815 vs 0.622) has a face, and it's usually the same face: coreference. The fact you need lives in a sentence that refers to the entity by a pronoun or short-form name — "the mascot", "she", "Roth". The sentence most lexically similar to the answer is the entity's naming sentence, which doesn't contain the fact. Embedding retrieval is pulled to the name. TokenPath can connect the pronoun or short name to the sentence that contains the fact.

Three real examples from hotpotqa — same Sonnet-5 answer, same judge. TokenPath's citation was judged fully supported, embedding's was not:

These examples show a common retrieval failure: the name-bearing sentence is more similar to the answer, but the fact lives somewhere else. Across the benchmark there are 279 statements where TokenPath's citation was judged fully supported and embedding's was not (raw records).

The honest limitations

We'd rather state these than have you find them.

1. A prompted frontier LLM is still ahead on raw quality. TokenPath (0.815) trails prompted GPT-5.5 (0.851) by 0.036, and the gap is entirely recall: 0.735 vs 0.840. TokenPath is strongest on extractive QA (hotpotqa, 0.811 — tied with the prompted pass) and weakest on abstractive chat (longbench-chat, 0.736), where it trails both LLM methods.

2. The benchmark's granularity works against TokenPath. LongBench-Cite requires attributing whole statements at sentence level. TokenPath is at its best attributing short phrases and specific facts — numbers, dates, names — which is what products usually need to ground.

When to use what

If you need the single highest-quality citations and don't mind a second frontier-LLM call per query, a prompted add-citations pass still wins by a few points of F1 — on recall. If you want good citations on any model's output, cheaply, fast, without regenerating the answer or standing up a retrieval index, TokenPath offers similar citation quality at much lower cost than GPT-5.5.

For how the attribution itself works, see the method post.

Reproducibility

The benchmark harness, prompts, and aggregation code live in the benchmarking harness in our cookbook repo.

• Shared answer generator + Citations API: claude-sonnet-5 · prompted citer: openai/gpt-5.5 · judge: google/gemini-2.5-flash · embedding: text-embedding-3-large + BAAI/bge-reranker-base
• TokenPath aggregation: {threshold: 0.30, row_norm: true, merge_adjacent: true}
• TokenPath model for this run: Qwen3.5-9B

Questions, or a workload where you'd like to see these numbers reproduced? support@tokenpath.ai.