The agent-native reference: every technology, what it does, and how to check it

What does an agent-native product look like, piece by piece?

It can be found, understood, used, trusted, and tested by an agent. Each of those five jobs has a small set of technologies behind it, listed below from the most settled to the least.

What is llms.txt?

llms.txt is a Markdown file at the root of your site that lists your most useful pages, one line each, so a model or developer tool can find clean content without crawling your navigation.

• Defined by: a community proposal published at llmstxt.org. It is not an IETF or W3C standard.
• Status: convention. Support from search engines and model providers is not confirmed, so treat it as a low-cost courtesy that some agents and developer tools read.
• Check it: curl -s https://yoursite.com/llms.txt returns Markdown with a title and links, not an HTML page.

What is llms-full.txt?

llms-full.txt is the same idea with the content inline: your whole site (or docs) as one Markdown file, so an agent can load everything in a single request.

• Defined by: community convention, a companion to llms.txt.
• Status: convention. Keep it under the size an agent can reasonably read; split large documentation sets.
• Check it: curl -s https://yoursite.com/llms-full.txt | wc -c returns a plausible size and the text matches what is on the pages.

What are Markdown pages and content negotiation?

Serve a clean Markdown version of each page (for example /pricing.md), and also answer the normal URL with Markdown when the request says Accept: text/markdown. Agents spend fewer tokens on Markdown than on HTML, and they skip the page chrome.

• Defined by: HTTP content negotiation (the Accept header) is a mature web standard. Publishing a .md twin is a convention.
• Status: the negotiation mechanism is mature; how many agents ask for Markdown is not yet widespread.
• Check it: curl -s -H 'Accept: text/markdown' https://yoursite.com/ returns Markdown, and a browser still gets HTML.

What is AGENTS.md?

AGENTS.md is a plain Markdown file at the root of a code repository that tells coding agents how to build, test, and work in the project: the commands to run, the conventions to follow, the things not to touch.

• Defined by: an open format, contributed by OpenAI and one of the founding projects of the Linux Foundation's Agentic AI Foundation, announced December 9, 2025 ^[1].
• Status: widely read by coding agents; a convention rather than a protocol.
• Check it: AGENTS.md exists at the repo root and lists the exact commands that build and test the project.

Do sitemap.xml, robots.txt, and JSON-LD still matter?

Yes. They are how crawlers, including the ones that feed AI answers, discover and understand your pages. They are mature and unglamorous, and they come before any agent-specific file.

• sitemap.xml: the sitemaps.org protocol lists your URLs and last-modified dates.
• robots.txt: the Robots Exclusion Protocol (RFC 9309) says which crawlers may fetch what. AI companies publish their own crawler names, so decide deliberately which to allow; llms.txt does not control crawling ^[2].
• JSON-LD: structured data in the page head, using schema.org types such as Article, FAQPage, and Product. It states facts (who wrote this, when, what the questions are) in a form a machine does not have to guess.
• Check it: /sitemap.xml and /robots.txt resolve, and a structured-data validator shows no errors on your key pages.

What are OpenAPI and JSON Schema, and why do agents need them?

OpenAPI describes your HTTP API (endpoints, parameters, responses) in a machine-readable file. JSON Schema describes the exact shape of a piece of data. Together they let an agent call your product correctly without reading a human manual.

• Defined by: the OpenAPI Initiative (Linux Foundation) and the JSON Schema project ^[3].
• Status: mature. MCP tools and WebMCP tools both describe their inputs with JSON Schema.
• Check it: your API has a published spec file, and every field an agent must send has a type and a description.

What is MCP?

The Model Context Protocol (MCP) is an open protocol that lets AI applications discover and call tools, read resources, and use prompts that a server exposes. Build a capability once as an MCP tool and any compatible agent can use it.

• Defined by: Anthropic introduced it in November 2024. It moved to the Linux Foundation's Agentic AI Foundation on December 9, 2025 ^[1]. The current published specification is 2026-07-28 ^[4].
• Status: open specification with vendor-neutral governance and wide client support.
• Check it: a standard MCP client can connect to your server, list tools, and call one successfully. Details and a live example: the future of interfaces and this site's server.

What are MCP Apps?

MCP Apps is an official extension that lets a tool return an interactive interface, such as a picker, a chart, or an approval card, which the AI client shows inside the conversation.

• Defined by: the MCP project, announced January 26, 2026 ^[5].
• Status: official extension. Client support varies and is changing.
• Check it: your riskiest action returns an approval screen the user can read before confirming. See the future of interfaces.

What is WebMCP?

WebMCP is a proposed browser API that lets a web page register JavaScript functions as tools for the browser's AI agent, running in the user's own signed-in session.

• Defined by: the W3C Web Machine Learning Community Group.
• Status: draft proposal. The entry point has changed between drafts, so prototype behind a flag and check the current spec ^[6].
• Check it: open your page in a browser that supports the API and list the registered tools; an agent should be able to complete your main task without clicking through the interface.

What is A2A, and how is it different from MCP?

The Agent2Agent protocol (A2A) lets one AI agent discover and delegate work to another agent, even when they come from different vendors. MCP connects an agent to tools and data; A2A connects agents to each other.

• Defined by: created at Google and contributed to the Linux Foundation in 2025. An agent publishes an Agent Card, a JSON description of what it can do, at a well-known URL ^[7].
• Status: young open protocol with a 1.0 line. Many published agent cards use an older path, so read the current specification before building.
• Do you need it? Most products start with MCP. Reach for A2A when your product is itself an agent that other agents should delegate to.

How should an agent get permission: what are scoped credentials?

Give each agent its own credential that is limited to named actions, can expire, and can be revoked without affecting anyone else. A shared admin key fails this test.

• Defined by: OAuth is the mature standard; MCP's authorization model builds on it. Per-agent keys with named scopes are a common pattern when OAuth is more than a product needs.
• Status: standard plus pattern. Hash credentials at rest and show the secret only once.
• Check it: you can create a key that can read but not write, use it, and revoke it, all without a human logging in as an administrator for each call. Agent Kontrol is building exactly this.

What are idempotency keys?

An idempotency key is a unique token the caller sends with a write. If the same request arrives twice, because an agent retried after a timeout, the server performs it once and returns the original result.

• Defined by: an Idempotency-Key HTTP header, popularized by payment APIs and described in an IETF draft that has been revised several times ^[8].
• Status: widely used pattern; the IETF specification is a draft.
• Check it: send the same write twice with the same key and confirm exactly one change happened.

What is dry-run or preview?

Every costly or irreversible action offers a mode that shows exactly what would happen without doing it. The agent proposes, the human reviews the preview, and only then does the real call run.

• Defined by: a design pattern, not a standard. Common forms are a dry_run flag or a separate preview tool that returns the same change set the real call would apply.
• Check it: the preview and the real call share one code path, and the preview changes nothing.

What does a structured error look like?

A structured error tells an agent what went wrong in a machine-readable code, what to do about it in plain words, and whether trying again can help. A bare status code or a prose message does not.

{
  "error": "title is required",
  "code": "missing_field",
  "fix": "Add the fields listed in fields and send the request again.",
  "retryable": false,
  "fields": { "title": "title is required" }
}

• Defined by: RFC 9457 (Problem Details for HTTP APIs) is the standard shape for HTTP; the code, fix, and retryable fields shown here are a design pattern in the same spirit ^[9].
• Check it: trigger a bad request on purpose and confirm the response says what to change and whether to retry.

What are receipts and audit logs?

After an agent acts, the product records who did it (this person, or this agent acting for them), what changed, and how to undo it, and lets you query that record.

• Defined by: a design pattern. Record the actor type separately from the account, so "a human did this" and "an agent did this" are different facts.
• Check it: pick any change made by an agent last week and find who made it, when, and how to reverse it.

What are pagination, field selection, and concise responses?

Agents pay for every token they read. Let them page through long lists, ask for only the fields they need, and request a short format, so a lookup does not return a whole database.

• Defined by: API design practice. Typical forms are limit and cursor parameters, a fields parameter, and a format=concise option.
• Check it: your biggest list endpoint can return ten rows with only two fields each, and says how to get the next ten.

What are agent limits?

Budgets and rate limits set per agent, not per account: how many calls, how much spend, which actions. They keep one runaway agent from using up everyone's allowance or doing damage.

• Defined by: a design pattern. HTTP 429 with a Retry-After header is the standard way to say slow down.
• Check it: you can cap one agent credential without affecting any other, and you can see its usage.

How do you test that an agent can really use your product?

Run a real agent client against your product in continuous integration, with a task and a pass or fail result. Reading the protocol docs is not a test; an agent completing the task is.

• Defined by: a practice. A minimal version connects the official MCP client to your server, lists the tools, calls them, and fails the build if a call breaks.
• Check it: a pull request that breaks a tool's schema turns CI red.

Where should you start?

1. Publish /llms.txt, clean Markdown for your key pages, and a sitemap.
2. Describe your API with OpenAPI and give every field a type and a description.
3. Expose your most-used workflow as an MCP tool with a schema, a dry-run, and an idempotency key.
4. Return structured errors and keep a receipt for every agent action.
5. Issue scoped, revocable credentials per agent, with limits.
6. Add an agent to CI. Then look at MCP Apps and WebMCP as the interface layer.

See how two real products fare on the examples page, and the product manager guide for how to prioritize this work.