Machine-readable, but not agent-ready: what 100 SaaS audits reveal

The modern web is machine-readable. Semantic HTML, ARIA labels, and structured data have brought accessibility and SEO to the forefront of product development. But a comprehensive audit of the top 100 SaaS products reveals a stark reality: machine readability is not the same as agent readiness.

According to data from The Agentability Project, these 100 leading SaaS homepages achieve an average score of 71 out of 100 for machine readability—a solid indication that today's products have invested in semantic markup and parseable interfaces. Yet the overall agentability score sits at just 38.3 out of 100, revealing that products optimized for human users and search engines fall dramatically short on the principles that would allow AI agents to verify outcomes and take action.

What agentability measures

Agentability is a measure of how well software can be operated by AI agents, scored from 0 to 100 across eight Agent Factors Engineering (AFE) principles. These principles go beyond whether a page can be parsed. They assess whether an agent can reliably understand state, execute actions, confirm outcomes, and recover from errors—the fundamental capabilities required for autonomous operation.

The eight principles evaluated are:

• Machine readability: Whether content and structure are parseable by automated systems
• Transparency: Whether the system exposes what it did in response to agent actions
• Shadow-UI avoidance: Whether machine-accessible surfaces exist alongside visual interfaces
• Defaults: Whether sensible starting states reduce decision complexity
• Control: Whether agents have mechanisms to direct system behavior
• Chunking: Whether complex operations break into manageable steps
• Status: Whether current system state is explicitly communicated
• Clean handoffs: Whether transitions between agent and human control are well-defined

The audit assessed homepages of the top 100 SaaS products using version 0 of the agentability rubric. While homepage scores provide only a partial view of a product's overall agent-readiness, they serve as a meaningful proxy for how product teams think about machine interaction at the most visible layer of their application.

The transparency crisis

The most striking finding is the near-complete absence of transparency. With an average score of just 5 out of 100, and 83 products scoring zero, transparency represents the single largest gap between current product design and agent-era requirements.

Transparency in the AFE framework refers to a system's ability to explicitly communicate what occurred in response to an agent action. When a human clicks a button, visual feedback—a loading spinner, a success message, a page transition—confirms the outcome. Agents require similar confirmation, but through structured, programmatic signals rather than visual cues.

Without transparency, an agent that submits a form or triggers an action has no reliable way to verify success or detect failure. It must resort to brittle heuristics: scraping for specific text, waiting arbitrary time periods, or comparing before-and-after snapshots. Each approach introduces fragility and increases the risk of silent failures where the agent proceeds incorrectly because it cannot confirm what actually happened.

The shadow-UI gap

Shadow-UI refers to the phenomenon where the only way to interact with a product is through interfaces designed for visual, human operation—browser DOMs rendered for clicking and typing, with no parallel machine surface. The term captures the problem: agents are forced to operate in the shadows, puppeteering human interfaces rather than using purpose-built interaction layers.

Products with good shadow-UI avoidance provide APIs, webhooks, structured endpoints, or other machine-native surfaces that let agents accomplish tasks without simulating human behavior. A low score indicates that even if an agent can parse a page's contents, it has no clear path to action beyond manipulating UI elements designed for mouse and keyboard.

The combination of poor transparency and poor shadow-UI avoidance creates a compounding problem. Not only must agents interact through fragile UI automation, but they also receive no reliable confirmation that their actions succeeded.

Where products do better

The audit results are not uniformly poor. Machine readability averages 71 out of 100, indicating that the accessibility and semantic markup investments of the past decade have paid dividends. Control (48), status (47), and chunking (45) also score in the mid-range, suggesting that some product design patterns naturally align with agent needs even when not explicitly designed for autonomous operation.

The tier distribution offers additional nuance:

• 22 products qualify as Agent-Ready with scores of 45 or above
• 54 fall into the Developing tier (35-44)
• 17 are categorized as Lagging (20-34)
• 7 score under 20, classified as Agent-Blind

This distribution indicates that while the average is low, a meaningful subset of products has already adopted practices that improve agentability, whether intentionally or as a side effect of API-first design, strong developer tooling, or robust state management.

What this means for product teams

The gap between machine readability and agent readiness is not a failure of current products. These tools were designed for human users, and they succeed at that goal. But as AI agents become a primary mode of software interaction, products that remain optimized only for human operation risk being left behind.

Product and engineering teams should consider the following priorities:

Instrument transparency

Add structured response signals to user actions. When a form submits, an account setting changes, or a resource is created, expose that outcome in a machine-readable format—whether through response headers, data attributes, structured JSON endpoints, or event streams. Agents need to know not just what they can do, but what actually happened.

Provide a machine surface

Invest in API coverage that mirrors core user workflows. If a human can perform a task through your UI, an agent should be able to accomplish the same task through a programmatic surface. This doesn't mean abandoning the visual interface—it means offering an alternative path that doesn't require DOM manipulation.

Audit your own agentability

Measure where you stand. The Agentability Project provides run a free audit to assess your product against the eight AFE principles. Understanding your current baseline is the first step toward systematic improvement.

Design for verification

Build interfaces—both visual and programmatic—that make state explicit. Expose status, confirm actions, and provide clear signals when operations complete or fail. This benefits not only agents but also improves testability, observability, and debugging for human developers.

The road ahead

The audit data shows that the industry has mastered one era of machine interaction—the era of parsing, scraping, and reading. The next era requires products that agents can not only read but also operate, verify, and recover from. The 22 products already scoring in the Agent-Ready tier demonstrate that this is achievable with current technology and design practices.

For teams serious about preparing for agentic interaction, the Agentability Index offers a benchmark and a roadmap. The path from machine-readable to agent-ready is not about abandoning existing interfaces—it's about augmenting them with the transparency and machine surfaces that autonomous operation requires.