How the Discry Score works.

Agents fetch over plain HTTP, without running JavaScript, and they navigate by machine-readable entry points. Discovery measures whether that path exists for your API. Is there an llms.txt that actually routes to your reference? An AGENTS.md that briefs a coding agent? A spec it can parse, or an MCP surface it can wire up? Serving these well earns credit directly.

This is where a striking share of APIs lose outright, well-known ones included. Some documentation renders almost nothing without JavaScript. Some llms.txt files point agents at marketing pages instead of the API reference. When that happens, the profile says so plainly, with the reason and the URLs we tried. A discovery failure is a checkable fact about your public surface, and it is usually the cheapest thing on the page to fix.

Once an agent has your docs, the question turns practical: can it actually operate your API? We answer that with an experiment, not a checklist. Models are quizzed from published task banks. The questions cover the facts an integration depends on (auth, errors, pagination, limits), requests to construct, and traps that ask for things your API does not support. On a trap, the right answer is to refuse, not to invent something with confidence.

Grading is mechanical and grounded. A comprehension task passes only when two things are both true. The answer is correct against ground truth traced to a specific place in your docs. And the model backs that answer with a word-for-word quote, pulled from the documentation we actually fetched and checked against it. An answer with no quote from your pages does not pass, however confident it sounds. Trap tasks, where the correct move is to refuse, do not need a quote.

The corpus is fetched over plain HTTP with no JavaScript execution, because that is how most agents fetch. If your documentation only renders with JavaScript, an agent on a plain fetch sees almost nothing, and we grade what it sees. Serving llms.txt or markdown mirrors is rewarded, because those are exactly the surfaces that make an API legible to agents.

When a docs surface yields essentially nothing readable on plain fetch, the profile publishes as docs-unreachable. That is a rule-based failing grade, and it ships with the specific reason and the URLs we tried, so the result is verifiable and fixable. When an API publishes an llms.txt, that file is treated as its declared agent-facing entry point. If it routes agents to marketing pages instead of the reference, the grade reflects the surface the API itself chose to present.

Frontier models have read a lot of API documentation in training, and for well-known APIs they can answer many questions from memory alone. We measure that directly. Alongside the open-book quiz, every task also runs closed-book: the same questions, with no access to your docs. The rate at which models answer correctly from memory is published as the Familiarity metric.

Familiarity is a disclosure, not part of the score. It tells you how much of your API models already carry from training, and it does not raise or lower the grade. A high Familiarity earns no points, because a graded pass requires a verbatim quote from your live docs, and memory cannot produce one (see below). A low Familiarity costs nothing. In the rare case where a docs surface adds nothing an experiment can measure, the profile publishes as insufficient-coverage instead of being handed an unearned grade.

The score measures your documentation, not your brand, and the mechanism that keeps it that way is the grounding requirement itself. The quiz harness holds your docs, and a graded pass requires the model to quote them verbatim. A model running on memory can often reproduce a fact, but it cannot produce a citation to text it was never shown. So prior knowledge, however deep, does not convert into a passing grade. It can only surface in Familiarity, which is disclosed and kept separate.

The consequence is that every API is scored on the same basis, whether it is a household name or one you have never heard of: what its live documentation lets a model find, understand, and quote. A famous API earns nothing from being famous, and an obscure one loses nothing for being obscure.

Not every agent runs on a frontier model. Routing routine work to lower-cost models is standard industry practice, and the implication for an API producer follows directly: if only frontier models can understand your API from its docs, you are invisible where the volume is.

The capability floor measures the piece of that we can measure: the lowest tested model tier that reliably operates the API from its documentation. Profiles carry a vendor-neutral label: small-model ready, advanced-model required, or frontier required, plus not-agent-ready and indeterminate where coverage cannot support a floor. The exact models and versions tested at each tier are disclosed in each artifact’s provenance.

Errored or aborted runs never fold into a published score, and profiles disclose their invalid-run count. Each profile also reports request-task coverage: how many of its five request-construction tasks produced gradeable capability extractions. When coverage is too thin to support a conclusion, the profile says indeterminate instead of guessing. The closed-book control is held to the same bar: if a majority of a profile’s closed-book runs fail to produce a clean answer, the scan fails loud rather than quietly reporting a score with no Familiarity check behind it.

All published scores are produced in one canonical execution environment, and every artifact is stamped with the exact instrument version and the environment it ran under. We disclose that environment rather than claim scores transfer unchanged to a different one. Equivalence across environments is an open question, and we report it honestly instead of assuming it.

Discry helps teams get agent-ready. That is the business, and we are not neutral about wanting every API on the Index to improve. So the measurement is built to be independent of us. Grading is mechanical, the task banks are versioned and published, every profile carries its receipts, and the same instrument grades every API. That includes this site, which ships its own llms.txt, AGENTS.md, and markdown mirrors to the standard it grades others on. The only thing that moves a grade is the documentation itself, verified by rescan.

We publish everything: methodology, task banks, receipts, and the data itself in machine-readable form. We do it because agent-readiness is an industry-wide problem, and an open benchmark moves it faster than a private one.