# What Is Agent-Native Software? Definition & Scorecard

> Agent-native software is software designed so an AI agent is a first-class user: it can discover the product, understand it, act in it, be limited inside it, and verify what happened, without a human translating. It is not a chatbot bolted on, and not a scraper in disguise.

URL: https://agentnative.build/ · By Mark Hinkle · Updated 2026-10-21
Machine-readable index: https://agentnative.build/llms.txt

## What does agent-native mean?

The human is still in the loop, but at the points that matter: approval, oversight, and outcomes. Not at every click.

Cloud-native meant designing for the datacenter you actually run on. Mobile-native meant designing for a thumb and a small screen. Agent-native means designing for a reader that is fast, literal, tireless, token-limited, and has no eyes.

### Three stages

|  | Agent-bolted-on | Agent-ready | Agent-native |
|---|---|---|---|
| Interface | Chat widget over the same UI; agents drive a browser | Public API, partial coverage | Every capability is a tool, API, or CLI call; the UI is one client of many |
| Docs | PDFs, videos, marketing pages | Human docs plus an OpenAPI file | llms.txt, clean Markdown, schemas with examples, tool descriptions written for models |
| Auth | Shared human login, CAPTCHA | API keys, coarse scopes | Delegated, scoped, revocable agent identities with spend and rate limits |
| Errors | HTML pages, “something went wrong” | JSON with a status code | Code, cause, fix, and a retryable flag |
| State changes | Fire and hope | Sometimes idempotent | Idempotency keys, dry-run, receipts |
| Verification | Eyeball it | Logs for engineers | Queryable receipts; actor recorded as human or agent |

## What are the principles of agent-native design?

1. **Parity.** Anything a person can do in the UI, an agent can do through a stable interface. If the only way in is a button, the product is not agent-native.
   - Bolted-on: A “Refund” button with no endpoint behind it.
   - Native: Refund is a tool; the button calls the same tool.
2. **Legibility.** Schemas, examples, and tool descriptions are written so a model can pick the right call without a human reading the docs first.
   - Bolted-on: Docs live in a video and a PDF. The agent guesses.
   - Native: Schemas, examples, and tool descriptions written for models, plus llms.txt.
3. **Idempotent by default.** Writes accept idempotency keys, costly actions offer dry-run, and side effects are stated up front.
   - Bolted-on: A timeout, a retry, and the customer is refunded twice.
   - Native: Idempotency key on every write; dry_run on costly calls.
4. **Errors that teach.** Return a machine-readable code, the cause, a suggested fix, and whether a retry can succeed.
   - Bolted-on: “Something went wrong” in an HTML page.
   - Native: {code, cause, fix, retryable}. The agent corrects itself.
5. **Scoped authority.** Least privilege, delegated tokens, spend caps, and human approval gates for irreversible actions.
   - Bolted-on: The agent borrows the owner’s full-power login.
   - Native: Per-agent identity, narrow scopes, spend caps, approval on irreversible actions.
6. **Verifiable.** Every action returns a receipt and lands in an audit log. Agents can check their own work, and humans can check the agents.
   - Bolted-on: No record of who or what clicked the button.
   - Native: A receipt per action and an audit log that records human vs agent.
7. **Context-thrifty.** Support pagination, field selection, and concise formats. Prefer Markdown to markup soup.
   - Bolted-on: A 4,000-row response and 90% markup.
   - Native: Pagination, field selection, Markdown, and summaries on request.
8. **Composable.** Small primitives with text in and text out (CLIs, files, narrow tools) that agents can chain in ways you did not plan for.
   - Bolted-on: One monolithic “do everything” endpoint.
   - Native: Narrow tools and CLIs with text in, text out, ready to chain.

## Same task, three readers: "refund order #1042"

**A person** (failure risk: Low). Works, because the UI was built for eyes and a mouse.
1. Log in
2. Search orders (type “1042”)
3. Open order #1042
4. Click Refund
5. Choose a reason (dropdown)
6. Confirm amount
7. Confirm again (modal)

**Bolted-on agent** (failure risk: High). Sometimes works. Nobody can say whether it refunded twice.
1. Screenshot the login page
2. Guess the password field selector
3. Dismiss cookie banner
4. CAPTCHA: verify you are human (blocked)
5. Retry from the top
6. Parse the HTML orders table (column order changed)
7. Click Refund (modal not found)
8. Retry click (unknown: did it fire twice?)

**Agent-native** (failure risk: Low). Deterministic, previewed, retry-safe, and verified.
1. Read tool schema (refund_order(order_id, amount, reason, dry_run, idempotency_key))
2. refund_order(dry_run: true) (preview: refund 80.00 to card ••4242)
3. refund_order(idempotency_key: "a1f9…") (receipt: {refund_id: "rf_77", status: "succeeded"})
4. get_refund("rf_77") (verified: succeeded, actor: agent)

Illustrative example, not a benchmark.

## What does an agent-native product look like?

1. **Discover**: llms.txt · AGENTS.md · Markdown pages · clean sitemap
2. **Describe**: OpenAPI · JSON Schema · MCP tool definitions written for models
3. **Act**: API · CLI · MCP server · packaged skills, with UI parity
4. **Authorize**: Narrow scopes · per-agent identity · spend limits · approval gates
5. **Verify**: Receipts · audit log · actor attribution · evals in CI

Example llms.txt:

```
# Acme Payments
> Payments API. Refunds, charges, disputes.
> Start with /docs/quickstart.md

## Docs
- [Quickstart](/docs/quickstart.md): first charge in 5 calls
- [Errors](/docs/errors.md): every code and its fix

## Optional
- [Changelog](/changelog.md)
```

Example error an agent can act on:

```json
{
  "error": {
    "code": "refund_exceeds_balance",
    "message": "Refund 120.00 exceeds refundable 80.00.",
    "fix": "Retry with amount <= 80.00.",
    "retryable": false
  }
}
```

## How agent-native is your product? A 12-question scorecard

One point per yes. 0-3: Agent-hostile; 4-6: Agent-tolerant; 7-9: Agent-ready; 10-12: Agent-native.

1. Everything a user can do in the UI is available through an API, CLI, or tool interface.
2. Interfaces are described machine-readably (OpenAPI, JSON Schema, MCP).
3. There is an llms.txt or equivalent, and docs are available as clean Markdown.
4. Write operations accept idempotency keys.
5. Destructive or costly actions support dry-run or preview.
6. Errors are structured, with a code, cause, and suggested fix.
7. Agents can get scoped credentials without a human clicking through each session.
8. Spend, rate, and permission limits can be set per agent identity.
9. Every action returns a receipt or lands in an audit log an agent can query.
10. Responses support pagination, field selection, and concise formats.
11. You can tell whether a human or an agent performed an action.
12. Agents are tested against the product (evals or CI), not just humans.

## Agent-washing: what to avoid

- **The corner chatbot** that no other agent can call.
- **CAPTCHA walls** in front of a legitimate workflow with no API behind them.
- **Docs as PDFs or video,** or pages that only exist after JavaScript runs.
- **Errors as HTML** pages.
- **OAuth that needs a human click** on every call.
- **Infinite scroll** as the only way to get a list.
- **The human’s full-power login** handed to the agent “to keep it simple”.

## How we got here

- **2023.** Function calling and plugins let models call developer-defined tools.
- **2024.** llms.txt is proposed as a model-readable site index; Anthropic introduces the Model Context Protocol.
- **2025.** AGENTS.md and agent skills spread as ways to hand agents project and procedural context; coding agents make “agent as user” routine.
- **Now.** Products get judged on how well agents can use them, not just people.

## Go deeper

- [The future of interfaces: MCP, MCP Apps, WebMCP, conversational UI](https://agentnative.build/future)
- [Examples: ConferenceOS, Agent Kontrol, Cortex](https://agentnative.build/examples)

## Questions

**Is agent-native just having an API?** An API is necessary, not sufficient. Agent-native adds self-description, safe retries, teaching errors, scoped delegated authority, and verification.

**Do humans get worse software when it is agent-native?** No. Clear errors, undo, audit trails, and least privilege make products better for people too.

**What is the difference between agent-native and AI-native?** AI-native usually describes products that use AI inside the experience. Agent-native describes products that AI agents can operate: discoverable, callable, limited, and verifiable. A product can be either, neither, or both.

**Where do I start making a product agent-native?** Take the scorecard, pick the lowest-scoring principle, and fix it for your single most-used workflow.