TL;DR
Developers now point coding agents like Claude Code, Cursor, and GitHub Copilot at your API before they read a single page themselves. Agents work only with the documentation they can find, fetch, and parse, so gaps in discovery, Markdown support, or page structure turn into incomplete or incorrect integration code. Score your docs with Agent Score to see where yours stand.
AI coding agents like Claude Code, Cursor, and GitHub Copilot are now a normal part of how developers build software. A developer asks an agent to find an API, explain how an endpoint behaves, and write the integration code, without ever opening the developer portal or reading the API reference.
The agent only knows what it can access and interpret. If your docs are hard to discover, parse, or navigate programmatically, the agent misses details and writes code from incomplete information. As more developers build with agents, your documentation has two readers: the people on your developer portal and the agents working on their behalf.
Where docs fall short for agents
A documentation site can look polished to a person and still be hard for an agent to use. Three gaps come up most often.
Agents can't find your documentation. Without a machine-readable index or clear paths to the right resources, an agent struggles to locate the right API reference, authentication guide, or integration tutorial. An llms.txt file points agents to your most important pages, and a well-structured sitemap with stable URLs makes everything else easier to reach.
Agents can't get your content in a usable format. A page that renders well in a browser is often hard to consume programmatically. If your site doesn't serve Markdown versions of its pages or support content negotiation (returning Markdown when a request sends Accept: text/markdown), the agent has to dig through HTML, navigation, and page chrome to extract the part it needs.
Agents can't reliably navigate your content. Broken links, misleading HTTP responses, oversized pages, and differences between the HTML and Markdown versions of a page all make it harder for an agent to retrieve the right information. Even when the page exists, the agent has trouble locating the specific instruction, code example, or configuration detail it needs to finish the integration.
None of these gaps mean your API is broken. They make the path from discovering your API to successfully calling it longer than it needs to be.
For a practitioner's view, our docs lead wrote about how she makes Fern's own documentation agent-friendly, including quickstarts agents can execute, agent-specific context, and cleaner Markdown output.
How your docs compare with everyone else's
Finding these issues by hand takes time, and without a consistent set of criteria there's no way to know how your docs compare with other API providers.
Agent Score makes agent-readiness measurable. It grades a documentation site from 0 to 100 across checks for discoverability, Markdown availability, content structure, page size, URL stability, and other technical characteristics. The public Agent Score directory lists the results for hundreds of API documentation sites, grouped by grade and filterable by category.
The results show real differences. Some sites make their content easy to discover and retrieve, while others have gaps that slow agents down.
- 98
- Claude Code docs, Grade A
- 35
- A major cloud infrastructure docs site, Grade F
Some sites already set a high bar. Claude Code scores 98 out of 100 and earns a Grade A. Its docs publish an llms.txt file for discovery, serve a Markdown version of every page, and support content negotiation so agents request the format they need.
Others have more ground to cover. In one evaluation, a major cloud infrastructure documentation site scored 35 out of 100. The report flagged a missing llms.txt file, no Markdown versions of its pages, and no support for requesting Markdown through content negotiation. It also found that the page's main content started a third of the way down the page, below navigation and other boilerplate.
A score isn't a verdict on the quality of an API, and it doesn't predict whether a given agent succeeds at a given integration. It shows you, check by check, which parts of your documentation make it harder for agents to find, understand, and use your API. Each report also includes a ready-made prompt you hand to a coding agent to fix the failing checks.
Want to see how you compare? Browse the Agent Score directory to look up other companies, inspect the checks behind their scores, and find the improvements that matter most for your own docs.
Your docs are now part of the agent experience
When agents are how developers discover and integrate APIs, documentation has a bigger job. It needs to help an agent find the right resources, retrieve the relevant content, interpret schemas, understand authentication requirements, and generate valid API calls.
Making your docs agent-ready starts with knowing where agents run into friction:
- Make your documentation discoverable with llms.txt and a clean sitemap.
- Serve content in formats agents consume, like Markdown and content negotiation.
- Keep URLs stable so links agents have already learned keep working.
- Put examples and instructions near the top of the page, without unnecessary overhead.
None of this replaces the documentation experience your developers already rely on. It makes that same experience work for the agents they use.
Score your docs with Agent Score to get your grade and a list of fixes in seconds.