Your product now has a second reader: an AI agent acting for a person. The Two-User Model and four audit questions show where your product only works because a human is watching.
Agent-ready products work as reliably for an AI agent acting on a person's behalf as they do for the person. In practice that means four things: a machine-readable path next to the screen, safeguards enforced by the system rather than by someone noticing, the same response shape every time, and a named owner when an agent acts on an ambiguous output. The Two-User Model audits each feature against both readers.
Key takeaways
- Software is already a majority reader of the web. Automated traffic passed human traffic for the first time in a decade in 2024, at 51% of all web traffic (Imperva, 2025).
- Agents are a minority habit, but a real one. In the 2025 Stack Overflow survey, 30.9% of respondents used AI agents at work at least occasionally and 14.1% did so daily (Stack Overflow, 2025).
- Products built for humans fail quietly with agents. The agent does exactly what an ambiguous interface told it to do, at machine speed.
- The standards exist. MCP (open-sourced in November 2024 by Anthropic), llms.txt (proposed September 2024), RFC 9457 error formats and idempotency keys each answer one of the four audit questions.
- Start with one workflow, the most repetitive, rule-based one where a person acts for someone else.
Who is the second user of your product?
For twenty years, "who is the user" had one answer: a person looking at a screen and making a decision. That assumption is cracking. A growing share of the reading, clicking and form-filling in software is done by an agent: a model with tools that acts for a human, calls your API, reads your docs and fills in your forms.
The numbers show the direction, not yet the destination:
- Traffic: automated requests made up 51% of web traffic in 2024, and bad bots alone 37% (Imperva, 2025). Most of that is crawlers and attackers, not helpful agents, but it means a large part of whatever reads your product is already software.
- Developers: of 31,877 respondents to the agent question, 14.1% use AI agents at work daily, 9% weekly and 7.8% monthly or less; 37.9% have no plans to (Stack Overflow, 2025).
- Enterprise software: Gartner expects 33% of enterprise software applications to include agentic AI by 2028, up from less than 1% in 2024, with at least 15% of day-to-day work decisions made autonomously (W.Media on Gartner, 2025).
The same Gartner release carries the counterweight: over 40% of agentic AI projects will be cancelled by the end of 2027 (Gartner, 2025), and only about 130 of the thousands of vendors selling "agentic AI" offer the real thing. The shift is real and noisy. Neither fact excuses ignoring it.
The idea now has a name. In January 2025, Mathias Biilmann of Netlify proposed agent experience (AX), the experience an AI agent has as the user of a product, following user experience (Don Norman, 1993) and developer experience (Jeremiah Lee, 2011) (Biilmann, 2025).
Why do products built for humans fail quietly when agents use them?
This shift doesn't show up as an outage. It shows up as a slow loss of trust in your product's outputs. A feature built for human judgment depends on things agents don't parse well: copy that reads fine to a person but has no single correct interpretation, state that lives only in the visual layout, and confirmations that assume someone will notice when a number looks wrong. An agent acting on the same surface doesn't pause to sanity-check. It does exactly what the interface told it to do, at whatever speed it can, whether or not the interface was clear.
That is the failure mode to plan for: not "the agent breaks", but "the agent does precisely what an ambiguous product told it to do, and nobody notices until the result is wrong at scale."
OWASP lists this as a top risk for LLM applications. Excessive Agency (LLM06:2025) is the vulnerability that lets damaging actions happen in response to unexpected, ambiguous or manipulated model outputs, and its root causes are excessive functionality, excessive permissions and excessive autonomy (OWASP, 2025). Ambiguity in your product is one of the inputs.
Heavy AI users already feel this. In the same Stack Overflow survey, 66% of developers said their top frustration was AI output that is nearly right but not quite, and more distrusted AI accuracy (46%) than trusted it (33%) (Stack Overflow, 2025). An agent working against an ambiguous product produces exactly that kind of nearly-right result.
An everyday example: the expense-approval screen
A human approver glances at a total, notices it looks high for that vendor and pauses to check. An agent approving on the same criteria has no "looks unusually high" input. It has whatever field your interface exposes as the approval threshold. If that threshold lives in a tooltip a person would read but an agent's integration never touches, the agent isn't malfunctioning. It is following a spec nobody wrote down, because a human was always assumed to be the reader.
Every workflow where a person supplies judgment the interface never encodes is a place this will surface: quietly, one edge case at a time.
What is the Two-User Model?
Treat every feature as having two possible users reading the same surface, and audit it against both before you ship.
1. The Human Decision-Maker needs to understand why, not just what. They read for context, trade-offs and the confidence to act. Your job here hasn't changed: clarity, hierarchy, the right detail at the right moment.
2. The Agent Operator is a system acting on that human's behalf, executing a task without a human checking every step. It isn't reading for nuance. It needs the interface to be unambiguous, structured and stable: the same input should reliably produce the same kind of output.
| Need | Human Decision-Maker | Agent Operator |
|---|---|---|
| Reads | Rendered pages, charts, tooltips | API responses, schemas, docs, Markdown |
| Catches errors by | Noticing something looks off | Hard validation errors with a reason |
| Tolerates inconsistency | Yes, adapts without noticing | No, each variation breaks an integration |
| Wants explanations as | Prose and context | Structured fields plus the same reasoning |
| Safe default for risky actions | A confirmation dialog | Draft or proposed state, human approval |
Anthropic's guidance on building agents makes the same point from the builder's side: plan to "invest just as much effort in creating good agent-computer interfaces (ACI)" as you do in human-computer interfaces. On its SWE-bench agent, the team spent more time improving tools than the overall prompt (Anthropic, 2024).
How do you audit a feature for agent readiness?
Run four questions against a feature. Each has a concrete "good" answer.
1. Is there a machine-readable path alongside the human-readable one?
If the only way to get information out of your product is a rendered page, an agent acting for that person has no reliable way in. A documented API, a structured export or a predictable data shape is now the second front door.
A permissions setting that exists only as a checkbox on a settings page, with no field in the API response, is invisible to any agent working through that API. It is silently unenforced the moment a human delegates the task.
Good looks like: every fact on the screen is also available as a field, and every action has an API or MCP tool equivalent with a declared output schema. MCP tools can declare an outputSchema and return structuredContent that conforms to it (MCP specification).
2. Does the interface assume a human will catch an error?
Confirmation dialogs, "are you sure" prompts and red warnings all rely on a person noticing that something is off. An agent won't pause unless the check is structural: a hard validation error, not a visual cue. If your only safeguard against a destructive action is a modal with a red button, that safeguard does not exist for anything calling your API directly.
Good looks like: errors a machine can act on. RFC 9457 (July 2023) defines a standard "problem details" format because "non-human consumers of HTTP APIs have difficulty" reading HTML error pages (IETF, 2023). MCP separates protocol errors from tool execution errors, which come back with isError: true and a message the model can use to correct itself and retry. For high-impact actions, OWASP recommends human approval before the action runs.
3. Is the same action guaranteed to produce the same kind of result?
People tolerate a feature that behaves slightly differently depending on account state, load or an edge case. They adapt without noticing. An agent making the same call a thousand times needs the response to be consistent in shape even when the values change: the same fields and the same error format every time. Otherwise every integration breaks in a slightly different way, depending on which edge case it hit first.
Good looks like: stable schemas, versioned changes and safe retries. Stripe's idempotency keys let a client repeat a request after a connection error without performing the operation twice; keys can be up to 255 characters, and v1 keys can be pruned once they are at least 24 hours old (Stripe). MCP offers four tool hints (readOnlyHint, destructiveHint, idempotentHint, openWorldHint), but the schema says they are hints, not guarantees (MCP schema). Enforce the behaviour on the server.
4. Who is accountable when the agent gets it wrong?
This is the question most roadmaps skip. If an agent acts for a person based on your product's output, and that output was ambiguous, the failure traces back to a product decision, not a user error. That is a new category of product risk. It deserves the rigour of any production incident: a named owner, a way to reproduce what happened, and a fix that closes the actual gap rather than the one instance that got noticed.
Good looks like: an audit trail of which agent did what, under whose authority, from which input. The MCP specification says hosts must get explicit user consent before invoking any tool (MCP specification), and that there should always be a human in the loop who can deny a tool call (MCP tools). For deciding which actions an AI may take alone, see the AI handoff contract: ask, act or stop.
Which standards make a product agent-ready in 2026?
None of these is mandatory, and none is enough alone. Each answers a specific audit question.
| Standard | What it is | Origin | Answers |
|---|---|---|---|
| Model Context Protocol (MCP) | Open protocol for connecting AI applications to tools and data, over JSON-RPC 2.0 | Open-sourced by Anthropic, 25 Nov 2024; current spec 2026-07-28 | Q1, Q2, Q4 |
| llms.txt | A Markdown file at your site root that gives agents concise context and links to clean Markdown pages | Proposed by Jeremy Howard, 3 Sep 2024; v2 August 2026 | Q1 |
| OpenAPI description | Machine-readable description of your REST API | Industry standard | Q1, Q3 |
| RFC 9457 problem details | Standard JSON error format for HTTP APIs | IETF, July 2023 (replaces RFC 7807) | Q2, Q3 |
| Idempotency keys | Client-supplied key that makes retries safe | Common API practice (e.g. Stripe) | Q3 |
MCP is now supported by assistants such as Claude and ChatGPT and by tools such as VS Code and Cursor (MCP). Servers expose three kinds of features: resources (context and data), prompts (templates) and tools (functions the model can call) (MCP specification). The llms.txt proposal says thousands of sites now publish the file and that Chrome's Lighthouse checks for one in its agentic-browsing audits (llms.txt). If you care about how AI assistants describe your product, rather than how agents operate it, that is a separate problem covered in AI search visibility.
What does an agent-readiness audit look like? A worked example
Illustrative example. Say a 40-person company runs 600 expense claims a month through your product, and its finance lead wants an agent to approve routine ones. Score each audit question 0 (fails), 1 (partly) or 2 (passes).
| Question | Finding | Score |
|---|---|---|
| 1. Machine-readable path | Claims and totals are in the API; the €2,000 per-vendor threshold lives only in a tooltip | 1 |
| 2. Structural safeguards | Over-threshold approvals trigger a modal; the API accepts them silently | 0 |
| 3. Consistent results | Approval returns a different payload for multi-currency claims; no idempotency key, so a retry after a timeout can approve twice | 0 |
| 4. Accountability | Audit log records the user, not the agent or the rule it applied | 1 |
| Total | 2 / 8 |
The fixes are small: expose the threshold as a field, reject over-threshold approvals in the API with a problem-details error, return one payload shape and accept an idempotency key, and log the acting agent next to the delegating user. Re-scored after those changes, the feature reaches 8/8 without any change to the human screen.
Treat a score below 6 as a reason to keep agents in draft-only mode for that workflow. That cut-off is a starting point, not a benchmark.
Agent-readiness checklist (copy this)
- Every value shown on screen is available as a named field in the API or export.
- Every action has an API endpoint or MCP tool with a declared input and output schema.
- Business rules (limits, thresholds, permissions) are enforced on the server, not in the UI.
- Errors return a machine-readable reason (RFC 9457 or an equivalent stable format).
- Write operations accept an idempotency key or are safe to retry.
- Responses keep the same shape across account states, currencies and edge cases.
- Destructive or high-impact actions require human approval or start as drafts.
- Logs record the agent, the delegating user and the input behind each action.
- Docs exist in clean Markdown, with an llms.txt file pointing to them.
- Each workflow has a named owner for agent incidents.
What this doesn't mean
This isn't an argument to rebuild your product as an API-first platform overnight, or to drop the human interface. Most products will keep a person as the primary audience for years; the shift is additive. Nor is it a reason to chase every agent framework on a launch page. The lesson is narrower: audit your existing surface for assumptions that only work if a human is reading it.
What mistakes do teams make when designing for AI agents?
- Two sources of truth. The dashboard says "3 items need review" while the API returns 4. The products that handle agents well generate the human explanation and the machine data from the same source, so neither reader works from a partial picture.
- Trusting tool hints as controls. A
destructiveHint: falseannotation doesn't stop a destructive call. The MCP specification tells clients to treat annotations as untrusted unless they come from a trusted server. - Granting more than the task needs. OWASP's first mitigations are fewer tools, narrower functions and the minimum OAuth scope. A read-only task should get a read-only token.
- Measuring calls, not outcomes. Agent traffic inflates usage numbers. Check whether delegated tasks were completed correctly, not just how many ran. Agent-heavy usage also strains per-seat pricing; see how to price when your users are AI agents.
- Feeding agents no product context. Coding agents build what they can infer from the codebase. Give them the spec and the reasoning; see how to give an AI coding agent product context.
Where should a product team start?
Pick the one feature where a person currently does the most repetitive, rule-based work for someone else: approving requests, triaging tickets, reconciling records. That is almost always where an agent shows up first, because it is the workflow most worth automating. Run the four questions against it before an agent arrives uninvited, acting on assumptions your interface never stated.
Then review what the agents produce with the same rigour as a teammate's work; a PM's acceptance checklist for agent output covers that half.
The PMs who get ahead of this aren't the ones building agents. They're the ones who make their existing product tell the truth clearly enough that a machine reading it gets the same answer a person would.
Where Specky fits
Specky's own agent surface follows the Two-User Model. Coding agents and assistants connect through an MCP server with OAuth, load the product context and evidence-backed briefs before they plan, and create PRDs, tickets and decisions as drafts. Those drafts land in the PM Inbox for a person to approve, and every claim links back to the source evidence in the Product Graph, so the human and the agent see the same reasoning. Details are on the Specky for agents page.
Frequently asked questions
What is an agent-ready product?
An agent-ready product is one an AI agent can operate on a person's behalf as reliably as the person can. It exposes data and actions through an API or MCP server, enforces rules on the server, returns consistent response shapes and safe-to-retry writes, and logs which agent acted under whose authority.
What is agent experience (AX)?
Agent experience is the experience an AI agent has as the user of a product or platform, by analogy with user experience and developer experience. Mathias Biilmann of Netlify introduced the term in January 2025. Good AX means an agent can get access, understand the product's capabilities and complete tasks without a human translating for it.
Do I need an MCP server to be agent-ready?
No. A well-documented API with stable schemas, clear errors and idempotent writes already answers most of the four audit questions. An MCP server makes your product easier to plug into assistants such as Claude, ChatGPT, VS Code and Cursor, and adds consent and tool-description conventions, so it is worth adding once the API underneath is sound.
Is llms.txt the same as making a product agent-ready?
No. llms.txt, proposed by Jeremy Howard in September 2024, helps agents read your website and documentation by pointing them to concise Markdown. It addresses the first audit question for content. It does nothing for safe actions, consistent responses or accountability, which need API and product changes.
How do you keep a human in the loop when agents act?
Make risky actions start as drafts or proposals that a person approves, and enforce that on the server rather than in a dialog. The MCP specification requires explicit user consent before tool calls, and OWASP recommends human approval for high-impact actions. Log the agent, the delegating user and the input for every action.
Sources
- Imperva — 2025 Bad Bot Report
- Stack Overflow — 2025 Developer Survey: AI
- Gartner — Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027
- W.Media — Over 40 percent of agentic AI projects could face the axe by end of 2027: Gartner
- Mathias Biilmann — Introducing AX: Why Agent Experience Matters
- OWASP Gen AI Security Project — LLM06:2025 Excessive Agency
- Anthropic — Building effective agents
- Model Context Protocol — Tools (specification)
- IETF — RFC 9457: Problem Details for HTTP APIs
- Stripe — Idempotent requests
- Model Context Protocol — Schema reference
- Model Context Protocol — Specification
- Anthropic — Introducing the Model Context Protocol
- Model Context Protocol — What is MCP?
- Jeremy Howard — The /llms.txt file
This story was originally published on 27 July 2026 at https://www.specky.space/blog/agent-ready-products-two-user-model.