Jev vs. Six LLMs on Citation Matching: 5× Faster, 6–440× Cheaper, and What It Gives Up in Accuracy

An experiment report. Every number below comes from 2,520 API calls made from one machine in one session on 20 September 2026; the task, dataset composition, prompts, decision rule, model identifiers and price sources are given in full so the study can be repeated.

Abstract

Jev is TypeSafe’s decision model: instead of generating text it answers typed questions with calibrated probabilities, in a fraction of the time and at a fraction of the price of a large language model (TypeSafe, 2026; System One docs). We wanted to know what that buys, and what it costs, on the one decision every citation checker has to make: given a reference as the author wrote it and a handful of records that a scholarly search returned, is one of those records the cited work? We put Jev up against six general-purpose LLMs (Gemini 3.1 Flash Lite, Claude Sonnet 5, Claude Opus 5, Claude Fable 5.1, GPT-5.4 and GPT-6 Astra) on 60 deliberately difficult cases from real verification traffic (40 genuine matches, 20 non-matches; 40 English, 20 Chinese), with the same criteria, the same candidates and a JSON-only prompt. Each system judged every case three times, with and without publication years.

Jev answered in a median of 0.15 s over a warm connection, against 0.79 s for the fastest LLM measured the same way and 1.2–3.2 s for the six LLMs in the main run, and cost $0.04 per 1,000 judgments against $0.23 for the cheapest LLM and $17.34 for the most expensive: roughly five times faster than the fastest LLM, six times cheaper than the cheapest, and 70 to 440 times cheaper than the frontier models. It gave up accuracy for that. Jev got 42.7 of 60 right; five of the six LLMs scored between 51.7 and 56.3, with Claude Sonnet 5 best, and GPT-6 Astra tied with Jev at 43.0. The gap comes almost entirely from candidate titles the search engine had truncated and from the Chinese subset. Jev’s errors were also one-sided: in 60 judgments over the 20 non-matches it never accepted a wrong record, and every one of its mistakes was a genuine match it declined to accept. On speed and cost Jev wins by a wide margin; on accuracy it is respectable but clearly behind, and the shape of its mistakes matters as much as their count.

1. Background

Language models fabricate references. Walters and Wilder asked ChatGPT for literature reviews on 42 topics and found that 55% of the references produced by GPT-3.5 and 18% of those produced by GPT-4 did not exist, and that many of the real ones contained substantive errors; Alkaissi and McFarlane documented the same failure in a clinical-writing setting. A citation checker exists to catch this, and its job decomposes into two very different problems. The first is retrieval: querying bibliographic databases and search engines with whatever the author wrote. The second is judgment: looking at the records that came back and deciding whether one of them is the work the author meant. Retrieval is an engineering problem. Judgment is where the model goes.

The obvious model for the judgment step is a large language model used as a judge, an approach that Zheng et al. showed can agree with human raters about as often as humans agree with each other. It works, and it is what we ran for a long time. It also has two costs that grow linearly with traffic: seconds of latency per decision and dollars per thousand decisions, both of which are set by the price of generating text when what we actually want is a yes, a no, or a calibrated maybe.

In September 2026 TypeSafe released Jev, the first of what it calls System One models, after Kahneman’s name for fast, automatic judgment. A System One model does not generate text. It takes a JSON state and a set of typed questions (a choice among options, a score, or a true/false probability) and returns answers with calibrated probabilities (System One docs), at a quoted 70–500 ms end to end and $0.042 per million input tokens with no charge for output (launch post). Independent write-ups by DataCamp and MarkTechPost repeat those figures and note that the vendor’s own benchmark puts its accuracy near mid-tier LLMs rather than at the frontier. That is exactly the trade we wanted to measure on our own task rather than take on faith.

This report asks one question: on real citation-matching decisions, how much accuracy does Jev give up for its speed and cost, and where?

2. The task

An item consists of:

• a citation as the author wrote it, either a reference-list entry (Author, A. (2019). Title. Journal, 12(3), 45–67.) or an in-text mention (Smith and colleagues (2021) showed that …), and
• between one and three candidate records returned by a scholarly search for that citation, each with a title, an author list, a year and a URL, exactly as the search returned them, including truncated titles and missing fields.

The system must either accept one candidate as the cited work or reject all of them. A case is scored correct when a genuine match is accepted or when a non-match is rejected. There is no partial credit and no “unsure”: a checker has to commit, and a system that abstains on a genuine match has, for the user, failed to verify it.

3. Dataset

We drew 60 items from real verification traffic and hand-adjudicated every one. The set is balanced by design:

	Positives (genuine match)	Negatives (no match)	Total
English	27	13	40
Chinese	13	7	20
Total	40	20	60

Seventeen items are in-text mentions rather than reference-list entries; the rest are full references. Forty-four items come with three candidate records, fifteen with one, and one with two.

The positives were not sampled at random. Random positives are easy (an exact title in the first candidate) and every system gets them right; they tell you nothing. We instead sampled from the failure modes that had actually caused disagreement between systems in earlier rounds of testing, so the positive set is heavy on the cases where judgment is hard:

What makes the positive hard	Items
Exact or near-exact title, but a long author list, a reordered name, or a translated record alongside the original	14
Chinese citations: translated titles, narrative in-text mentions, records in a different script	13
Candidate title truncated by the search engine (an ellipsis in the middle, a [PDF] prefix, the first half missing)	9
Narrative in-text mention with no title at all	2
Citation with only a URL, or a web page with no author and no year	2

The negatives are cases where the search returned only unrelated records: same field, sometimes the same author, never the cited work. They test whether a system will accept a plausible-looking wrong record, which for a citation checker is the more damaging error.

We do not reproduce the citations themselves; they come from users’ documents. Aggregated results and the full protocol are given here, and per-item records (with citations redacted) are available on request.

4. Systems

4.1 Jev

We used TypeSafe’s Jev through its HTTP API; the alias jev-latest resolved to jev-1.13.0 for every call. For each item we posed two questions over the same state (the citation plus the numbered candidates):

1. Which candidate is the same work as the citation, or none? A choice question. The model returns the chosen option, a confidence in that choice, and a probability for every option including none.
2. Does at least one candidate clearly identify the cited work? A true/false probability, asked separately because a single work that appears twice in the candidates (a preprint and the journal version, an English record and a translated mirror) splits the probability of question 1 across two options while question 2 stays high.

Both questions carried the same matching criteria in plain English: the title must clearly match the citation’s title and the authors must align; case, punctuation, abbreviations, partial author lists, transliterated names, traditional versus simplified script and translated titles are acceptable differences; a different paper by the same authors, a sequel, or a same-title paper by other authors is not a match. For in-text mentions, which have no title, one sentence was appended: the candidate must be a work by the mentioned authors whose topic matches what the sentence attributes to it.

The probabilities were converted to a decision with a fixed rule: accept when a candidate is chosen with confidence ≥ 0.80, or with confidence ≥ 0.70 when the any-match probability is also ≥ 0.80; reject when the model chooses none and the any-match probability is ≤ 0.20; anything in between is undecided, which for scoring counts as a rejection. When a choice is undecided only because two candidates share the probability mass (any-match ≥ 0.80, none ≤ 0.10, top two options summing to ≥ 0.80), the protocol allows one follow-up question, whether the two records describe the same work, and merges them when it answers ≥ 0.80. That follow-up is a second API call; on this set it never triggered, so every decision-model figure below is a single call.

4.2 The six LLMs

Model	Vendor	API identifier	List price, input / output per 1M tokens
Gemini 3.1 Flash Lite	Google	google/gemini-3.1-flash-lite-preview	$0.25 / $1.50
Claude Sonnet 5	Anthropic	anthropic/claude-sonnet-5	$2 / $10
Claude Opus 5	Anthropic	anthropic/claude-opus-5	$5 / $25
Claude Fable 5.1	Anthropic	anthropic/claude-fable-5.1	$10 / $50
GPT-5.4	OpenAI	openai/gpt-5.4	$2.50 / $15
GPT-6 Astra	OpenAI	openai/gpt-6-astra	$10 / $50

All six were called through OpenRouter’s OpenAI-compatible API with provider routing set to prefer the lowest-latency provider and temperature 0. Every model received the same system prompt, reproduced here in full:

You are checking whether any candidate search result identifies a given academic citation.

Output ONLY this JSON, no commentary or markdown:
- A candidate clearly identifies the cited paper:
  {"match": true, "note": "one-sentence explanation", "value": {"title": "...", "authors": ["..."], "year": 2017, "url": "..."}}
- No candidate clearly identifies the cited paper:
  {"match": false, "note": "one-sentence explanation"}

Rules:
- "match": true requires the candidate to clearly be the cited paper. Title plus either authors or year must align. Minor formatting differences (case, punctuation, abbreviation) are OK.
- DO NOT speculate. If you are not confident, output {"match": false}.
- Never produce "unsure" or partial answers.
- Populate "value" from the matching candidate; copy fields verbatim from the input.
- "note" is a brief, neutral one-sentence explanation in English (e.g. "Matched candidate 2 by title + authors + year." or "No candidate matched: titles diverge from the citation."). Keep it factual; this string is shown to the end user.

followed by a user message containing the citation and the numbered candidates (title, URL, year, authors). The first JSON object in the reply was parsed; a reply with no parseable JSON would have been scored as a rejection and counted as malformed. We did not use vendor-specific structured-output modes (Google, Anthropic, OpenAI), so that all six models saw byte-identical requests; at temperature 0 with a short schema this cost nothing, since no model produced a malformed reply in 2,160 calls.

Two differences between the systems are worth stating plainly. The LLM prompt accepts title plus authors or year, while Jev’s criteria require title and authors; the LLM criteria are, if anything, the more permissive. And the LLMs return a free-text note and a copy of the matched record in addition to the verdict, which is what a production checker needs from them; Jev returns only probabilities. Both differences reflect how each system is actually used rather than a handicap imposed for the experiment.

5. Protocol

• Two input conditions. Years included: the citation and candidates exactly as retrieved. Years removed: every stand-alone four-digit year stripped from the citation and from candidate titles, and the year field omitted from candidates (years embedded in DOIs and URLs were left alone). Years are the field most often wrong in a citation, and a system that leans on them will look better on clean data than on real data.
• Three repetitions of every (system, condition, item), in interleaved random order so that no provider was hit with a burst of one model. In total 60 × 7 × 2 × 3 = 2,520 calls.
• One machine, one session (20 September 2026, 05:24–05:35 UTC, ten concurrent requests). Twenty-two calls (0.9%, all to the four most expensive LLMs) were refused by the routing layer with a credit-reservation error caused by our own account’s concurrency limit, not by the models; they were re-run individually six hours later and their results substituted. No call failed on the model side.
• Latency is measured on the client from request to full response. In the main run every call opened a new HTTPS connection, which adds two round trips of handshake to every system; because that overhead is a large fraction of Jev’s total, we also ran a second pass over the 60 items on a single warm connection per system (§6.3). Absolute values will differ from a server in another region; relative values should not.
• Metrics. Correct decisions out of 60, reported as the mean over the three runs with the range; the same split by positives/negatives and by language; the fraction of items on which a system gave the same verdict in all three runs; median and 90th-percentile latency; mean input and output tokens as reported by each API; and cost per 1,000 judgments at each vendor’s published list price on the day of the run (TypeSafe, Google, Anthropic, OpenAI GPT-6 Astra, OpenAI GPT-5.4). Cost uses measured tokens, not estimates.

6. Results

6.1 Accuracy

System	Correct of 60	Positives (40)	Negatives (20)	English (40)	Chinese (20)
Jev	42.7 (42–43)	22.7	20.0	28.7	14.0
Claude Sonnet 5	56.3 (56–57)	37.7	18.7	36.7	19.7
Claude Opus 5	55.7 (55–56)	36.7	19.0	36.7	19.0
Claude Fable 5.1	53.0 (52–54)	33.0	20.0	35.7	17.3
Gemini 3.1 Flash Lite	52.0 (52–52)	33.0	19.0	33.0	19.0
GPT-5.4	51.7 (51–52)	31.7	20.0	37.7	14.0
GPT-6 Astra	43.0 (43–43)	23.0	20.0	31.0	12.0

Mean of three runs, range in parentheses, years included. Positives are genuine matches that should be accepted; negatives should be rejected.

Five of the six LLMs sit within five points of each other, between 51.7 and 56.3; with 60 items and three runs, differences of one or two points between them are noise (§8). Jev is 9 to 14 points below that group and level with GPT-6 Astra. The two are low for different reasons, visible in the split columns: both accepted only 23 of the 40 positives, but Jev’s shortfall is spread across truncated titles and Chinese items, whereas GPT-6 Astra also missed five of the fourteen plain exact-title matches, in each case explaining that the candidate lacked an author list or that the year differed by one and the prompt required authors or year to align. It read the criteria more literally than any other model, including on the Chinese subset, where it scored 12 of 20.

Every system scored 18.7 or better on the 20 negatives. Jev and three LLMs (GPT-5.4, Claude Fable 5.1, GPT-6 Astra) rejected all of them in all three runs. Gemini 3.1 Flash Lite, Claude Sonnet 5 and Claude Opus 5 each accepted the same wrong record on one item: a same-field paper whose title overlapped heavily with the citation. That single item accounts for the whole difference in the negatives column.

6.2 With and without years

System	Years included	Years removed	Δ	Identical verdicts in all 3 runs	Malformed replies
Jev	42.7	40.3	−2.3	58 / 60	0 of 360
Claude Sonnet 5	56.3	54.3	−2.0	58 / 60	0 of 360
Claude Opus 5	55.7	55.0	−0.7	59 / 60	0 of 360
Claude Fable 5.1	53.0	50.0	−3.0	56 / 60	0 of 360
Gemini 3.1 Flash Lite	52.0	56.0	+4.0	60 / 60	0 of 360
GPT-5.4	51.7	48.7	−3.0	59 / 60	0 of 360
GPT-6 Astra	43.0	36.0	−7.0	60 / 60	0 of 360

Removing years moved most systems by two or three points, in the expected direction: a year is one more field that can confirm a match, and without it a few borderline positives fall below every system’s bar. Two results stand out. GPT-6 Astra lost seven points, consistent with how often its rejections cited a year that did not line up; it is the system most dependent on the field authors most often get wrong. Gemini 3.1 Flash Lite gained four, all on positives, and its behaviour on the affected items suggests that a year one off between an online-first and a print version had been talking it out of matches that the title and authors supported.

6.3 Latency

System	p50	p90	Mean	Input tokens	Output tokens
Jev	0.87 s	0.95 s	0.88 s	940	59
Gemini 3.1 Flash Lite	1.22 s	1.41 s	1.22 s	477	73
GPT-5.4	1.73 s	2.16 s	1.80 s	446	69
Claude Sonnet 5	2.17 s	3.33 s	2.35 s	684	147
Claude Fable 5.1	3.14 s	7.81 s	4.17 s	686	210
GPT-6 Astra	3.15 s	5.25 s	6.38 s	446	89
Claude Opus 5	3.21 s	7.60 s	4.24 s	684	223

Main run: one fresh HTTPS connection per call, ten concurrent requests, 180 calls per system, years included. Tokens as reported by each API.

The main-run figures understate Jev’s advantage, because a new TLS connection costs the same two round trips whether the server then spends 0.1 s or 3 s. On a single warm connection, Jev answered the 60 items in a median of 0.15 s (90th percentile 0.22 s, fastest 0.10 s), against 0.79 s for Gemini 3.1 Flash Lite and 1.74 s for Claude Sonnet 5 measured the same way. That is the regime a production service runs in, and there Jev is 5× faster than the fastest LLM and 12× faster than the most accurate one. The tail is where the LLMs hurt most: Jev’s 90th percentile is within 0.1 s of its median in both passes, while three of the LLMs have a 90th percentile above five seconds.

The token columns explain part of the cost gap below. Jev reads more input per judgment (the two questions and their criteria are sent as structured fields) but emits only probabilities; every LLM spent 69 to 223 output tokens writing a note and copying the matched record, and output tokens are priced at five to six times input.

6.4 Cost

System	Cost per 1,000 judgments	Relative to Jev
Jev	$0.040	1×
Gemini 3.1 Flash Lite	$0.230	5.8×
GPT-5.4	$2.15	54×
Claude Sonnet 5	$2.84	72×
GPT-6 Astra	$8.93	226×
Claude Opus 5	$8.99	227×
Claude Fable 5.1	$17.34	439×

Measured mean tokens per judgment × list prices on 20 September 2026 (TypeSafe, Google, Anthropic, OpenAI).

A thousand judgments cost four cents with Jev. The cheapest LLM is six times that; the most accurate, Claude Sonnet 5, seventy times; the frontier models two to four hundred times. The ratio is driven by two things at once: Jev’s input price is a hundredth of the cheapest LLM’s, and it bills nothing for output.

6.5 Where the errors are

Category	Items	Jev	Gemini 3.1 Flash Lite	Claude Sonnet 5	GPT-5.4	Claude Fable 5.1	GPT-6 Astra	Claude Opus 5
Exact or near-exact title (positive)	14	12	13	14	13	13	9	14
Chinese, hand-adjudicated (positive)	14	10	14	14	9	13	9	13
Not among the candidates (negative)	13	13	12	12	13	13	13	12
Title truncated by the search engine (positive)	5	0	3	5	4	3	2	5

Correct decisions per category, majority verdict over three runs, years included. Categories with one or two items are omitted from the table but included in every total.

Jev’s gap has a shape. On the five positives whose candidate title was cut off by the search engine it scored zero: told that the title must clearly match, and shown half a title, it did what it was told and withheld confidence, while Claude Sonnet 5 and Claude Opus 5 read the URL and the author list and inferred the rest. On the Chinese positives it scored 10 of 14 against 13 or 14 for the Anthropic and Google models; translated titles and narrative in-text mentions in Chinese are where its calibration is weakest. On the plain exact-title positives it is within two items of the best LLMs, and on the negatives it is perfect.

Its misses were abstentions, not wrong picks. Of its 46 undecided judgments on positives (out of 120), it had singled out a candidate in 40, at a confidence between 0.10 and 0.79 with a median of 0.49; in the remaining six it leaned towards none without reaching the rejection threshold. It never crossed the acceptance line on a wrong record.

6.6 Agreement between systems

Taking each system’s majority verdict over its three runs: 35 of the 60 items were decided correctly by all seven systems, and one item, a citation consisting solely of a URL with no title, author or year, was missed by all seven. Five items were missed by Jev alone: a truncated title, a missing subtitle, a very long author list that the candidate abbreviated, an in-text mention of a truncated web page, and one Chinese record whose title matched exactly but whose author string was formatted differently. Seven items were decided correctly by Jev but missed by at least one LLM: the negative that Gemini 3.1 Flash Lite, Claude Sonnet 5 and Claude Opus 5 all accepted; a Chinese in-text mention that GPT-5.4, Claude Fable 5.1, GPT-6 Astra and Claude Opus 5 all rejected; and five items that only GPT-6 Astra missed. GPT-5.4 and GPT-6 Astra were the two systems weakest on Chinese input (14 and 12 of 20), below Jev’s 14.

7. Discussion

Jev’s speed and cost advantage is not close. Over a warm connection Jev returned a judgment in about 0.15 s; the fastest LLM took 0.79 s and the frontier models three seconds or more, with tails past seven. At list prices a thousand judgments cost $0.04 with Jev, $0.23 with the cheapest LLM and $17.34 with the most expensive. Those are the same orders of magnitude TypeSafe quotes for its own benchmarks, reproduced here on a task the vendor has never seen.

Jev’s accuracy gap is real and it has a shape. Five LLMs scored between 51.7 and 56.3 of 60; Jev scored 42.7. Almost all of the difference lies in two places: candidate titles that the search engine had truncated, prefixed or reordered, and the Chinese subset. On plain cases all seven systems agree. This is consistent with what the vendor says about the model class, that it is built for fast, typed decisions and calibrated to say so when it is unsure, and with the broader finding that calibration and accuracy are different properties that can be traded against each other (Kadavath et al., 2022; Guo et al., 2017).

Jev’s errors are one-sided, and that is the most useful finding. In 60 judgments over the 20 negatives Jev accepted a wrong record zero times, while three of the six LLMs accepted one. Its failures on positives were abstentions at a confidence below the line. For a citation checker the two error types are not symmetric. A missed match sends the user to look at a reference that turns out to be fine; a false acceptance tells them a fabricated reference is real. A system whose mistakes are almost all of the first kind can be backed by a slower, more expensive one on exactly the cases it declines to decide, which on this set was one judgment in four. Letting a decision model commit on the three quarters where its confidence clears the bar, at a hundredth of the cost, and escalating the rest to an LLM captures most of the LLM’s accuracy for a fraction of its latency and cost. That is the natural way to use a model like this, and it is the design the numbers point to.

Years matter less than folklore says, except to one model. Removing them moved most systems by two or three points. GPT-6 Astra lost seven, and its notes show why: it treated a year mismatch as disqualifying. Jev lost 2.3, in line with the LLMs.

Determinism. At temperature 0 the LLMs gave the same verdict in all three runs on 56 to 60 of the 60 items; Jev on 58, with both disagreements on items whose confidence lay within a few hundredths of the acceptance threshold, which is what a calibrated probabilistic output should do near a threshold. No system produced a malformed reply in this experiment; the only failed calls were the 22 refused by our own account limit, all recovered.

8. Limitations

• Sixty items is enough to see a ten-point gap and to locate it, not to rank six LLMs whose scores differ by one or two items; treat the top five LLMs as a tie.
• The positives were chosen to be hard. On unselected traffic every system scores higher and the gap is smaller; the numbers here describe the difficult tail, which is where a checker earns its keep.
• One task, one prompt, one criteria text. We did not tune prompts per model, and the LLM prompt is the one we had been running in production, not one optimised for this comparison. GPT-6 Astra in particular reads it more literally than its siblings, and a prompt written for it would likely close much of its gap.
• Latency was measured from one location, through a routing layer for the LLMs and directly for Jev; provider routing and time of day both move LLM latency. The ordering was stable across the three runs and the warm-connection pass; absolute values are indicative.
• Costs use list prices on the day of the run (TypeSafe, Google, Anthropic, OpenAI); volume discounts, caching and batch tiers change the absolute numbers, not the ratios.
• Adjudication was done by our team. The Chinese items were judged by native readers; the categories in §6.5 are our labels.
• Models move. jev-latest resolved to jev-1.13.0; the LLM identifiers are given in §4.2. Repeating the experiment later measures different systems.

9. Reproducibility

Everything needed to repeat the experiment is above: the task definition (§2), the composition of the dataset (§3), the two questions and the decision rule for Jev and the verbatim system prompt for the LLMs (§4), the conditions, repetitions and metrics (§5), and the model identifiers and price sources. The sixty citations themselves come from users’ documents and are not published; anonymised per-item records (category, language, label, every system’s verdict and Jev’s probabilities in each run) are available on request.

References

1. Walters, W. H., & Wilder, E. I. (2023). Fabrication and errors in the bibliographic citations generated by ChatGPT. Scientific Reports, 13, 14045. https://doi.org/10.1038/s41598-023-41032-5
2. Alkaissi, H., & McFarlane, S. I. (2023). Artificial hallucinations in ChatGPT: Implications in scientific writing. Cureus, 15(2), e35179. https://doi.org/10.7759/cureus.35179
3. Zheng, L., Chiang, W.-L., Sheng, Y., et al. (2023). Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. arXiv:2306.05685. https://arxiv.org/abs/2306.05685
4. Kadavath, S., Conerly, T., Askell, A., et al. (2022). Language Models (Mostly) Know What They Know. arXiv:2207.05221. https://arxiv.org/abs/2207.05221
5. Guo, C., Pleiss, G., Sun, Y., & Weinberger, K. Q. (2017). On Calibration of Modern Neural Networks. arXiv:1706.04599. https://arxiv.org/abs/1706.04599
6. Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux.
7. TypeSafe AI. (2026, September 15). Introducing System One Models & Jev. TypeSafe AI Blog. https://typesafe.ai/blog/introducing-system-one-models-and-jev
8. TypeSafe AI. (2026). System One — Concepts. TypeSafe AI Documentation. https://docs.typesafe.ai/concepts/system-one
9. Crabtree, M. (2026, September 16). Jev: TypeSafe’s System One Model Explained. DataCamp. https://www.datacamp.com/blog/system-one-models-jev
10. Razzaq, A. (2026, September 19). TypeSafe AI Releases Jev: A System One Model That Returns Typed, Calibrated Decisions Instead of Text. MarkTechPost. https://www.marktechpost.com/2026/09/19/typesafe-ai-releases-jev/
11. Google. (2026). Gemini Developer API pricing. Google AI for Developers. https://ai.google.dev/gemini-api/docs/pricing
12. Google. (2026). Gemini models. Google AI for Developers. https://ai.google.dev/gemini-api/docs/models
13. Google. (2026). Structured outputs. Gemini API documentation. https://ai.google.dev/gemini-api/docs/structured-output
14. Anthropic. (2026). Pricing. Claude Developer Platform documentation. https://platform.claude.com/docs/en/about-claude/pricing
15. Anthropic. (2026). Models overview. Claude Developer Platform documentation. https://platform.claude.com/docs/en/about-claude/models/overview
16. Anthropic. (2026). Increase output consistency. Claude Developer Platform documentation. https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/increase-consistency
17. OpenAI. (2026). GPT-6 Astra — model page. OpenAI API documentation. https://developers.openai.com/api/docs/models/gpt-6-astra
18. OpenAI. (2026). GPT-5.4 — model page. OpenAI API documentation. https://developers.openai.com/api/docs/models/gpt-5.4
19. OpenAI. (2024, August 6). Introducing Structured Outputs in the API. OpenAI. https://openai.com/index/introducing-structured-outputs-in-the-api/
20. OpenRouter. (2026). Provider routing. OpenRouter documentation. https://openrouter.ai/docs/features/provider-routing
21. OpenRouter. (2026). API reference overview. OpenRouter documentation. https://openrouter.ai/docs/api-reference/overview