As AI agents begin to operate software on behalf of users, a new question emerges for product teams: how well can your product be driven by an autonomous agent? The answer for most SaaS products, including analytics platform Mixpanel, reveals a significant gap between current interface design and the requirements of agent-driven interaction.
A recent audit of the top 100 SaaS product homepages, measured against the Agent Factors Engineering (AFE) framework, provides the first systematic look at this challenge. The results quantify what many developers already suspect: modern web applications are optimized for human users, not programmatic agents.
Understanding Agentability
Agentability measures how well software can be operated by AI agents across eight core principles. These Agent Factors Engineering principles assess whether a product exposes the information and controls agents need to act reliably and autonomously. Scores range from 0 to 100, with higher numbers indicating better support for agent-driven workflows.
The audit examined homepage implementations across four tiers: Agent-Ready (45+), Developing (35-44), Lagging (20-34), and Agent-Blind (under 20). Each product was evaluated on eight AFE principles: machine readability, transparency, shadow-UI avoidance, defaults, control, chunking, status, and clean handoffs.
For product teams wondering where they stand, run a free audit to see how your implementation measures up.
The Mixpanel Picture
Mixpanel's homepage implementation is documented in detail at https://agentability.io/index/mixpanel.html, where the full technical breakdown shows how one of the industry's leading analytics platforms performs across the AFE framework. Like most products in the audit, Mixpanel faces challenges common across the SaaS landscape, particularly in areas where current web development practices have not yet evolved to support agent interaction.
The specific scores reveal where interface conventions that work well for humans create friction for agents attempting to understand and manipulate software programmatically.
Industry-Wide Patterns
Of the 100 products audited, the average agentability score landed at 38.3 out of 100, placing the typical SaaS product squarely in the Developing tier.
The tier distribution tells a nuanced story. While 22 products achieved Agent-Ready status with scores of 45 or above, the majority—54 products—fell into the Developing category with scores between 35 and 44. Another 17 products landed in the Lagging tier (20-34), and 7 scored below 20, earning the Agent-Blind designation.
This distribution suggests the industry is neither ignoring nor effectively addressing agent-readiness. Most products have stumbled into partial support through existing practices, but few have deliberately architected for agent interaction.
The Transparency Crisis
Breaking down the eight AFE principles reveals where the greatest challenges lie. Machine readability scored highest at 71 out of 100, reflecting widespread adoption of semantic HTML and modern framework practices. Control (48), status (47), and chunking (45) fell near the overall average, while clean handoffs scored 40.
The weakest principle by far was transparency, averaging just 5 out of 100. A striking 83 of 100 products scored zero on this dimension.
Transparency in the AFE framework refers to a product's ability to expose its capabilities, valid actions, and state changes in machine-readable formats. Without transparency, agents must rely on brittle heuristics and assumptions rather than ground truth about what actions are possible and what effects they will have.
The near-universal failure on transparency is particularly significant because it represents a capability gap rather than a mere implementation detail. Most products simply do not expose structured metadata about their own functionality. There are no schemas describing available actions, no machine-readable declarations of what parameters are valid, and no programmatic way to discover what operations are possible in a given context.
Shadow-UI: The Hidden Barrier
Shadow-UI avoidance scored only 17 out of 100, with 80 products scoring under 20 on this principle.
Shadow-UI refers to interface elements that are hidden from the accessibility tree or implemented in ways that are invisible to programmatic inspection. Common culprits include CSS-driven interactions, hover-dependent menus, and JavaScript-generated content that doesn't surface through standard DOM APIs.
For human users, these patterns often create polished, dynamic experiences. For agents, they represent dead ends—interactive elements that cannot be discovered or manipulated through standard programmatic interfaces.
The prevalence of shadow-UI is not malicious but architectural. Modern frontend frameworks encourage component-based development where visual polish is the primary success criterion. Programmatic accessibility is rarely part of the design conversation.
Defaults and Control: Mixed Results
Defaults scored 35 out of 100, reflecting inconsistent implementation of sensible starting states and progressive disclosure patterns. Many products assume extensive user configuration or exploration rather than providing agent-friendly defaults that enable immediate productive action.
Control, at 48 out of 100, showed relatively stronger performance. Most products expose basic CRUD operations through forms and buttons accessible to programmatic interaction. However, more advanced workflows—bulk operations, conditional logic, and complex state management—often remain locked behind patterns optimized for human intuition rather than agent capabilities.
What This Means for Product Teams
The data from the Agentability Index points to concrete opportunities for improvement. Product teams need not overhaul their entire architecture to improve agentability. Instead, focused investments in a few high-leverage areas can substantially increase agent-readiness.
Start with Transparency
The uniformly low scores on transparency represent the clearest opportunity. Consider exposing structured metadata about your product's capabilities. This might include JSON schemas for available endpoints, machine-readable documentation of valid actions, or programmatic descriptions of current application state.
Even basic implementations—an OpenAPI specification, a capabilities manifest, or structured action descriptors—would place you ahead of 83% of products in this audit.
Address Shadow-UI Systematically
Audit your interface for interactions that exist only in CSS or require hover states to discover. Ensure critical functionality is exposed through the accessibility tree, not just for compliance but as a programmatic interface for agents.
This work pays dual dividends: improving both agent-readiness and human accessibility.
Rethink Defaults
Design for the zero-configuration use case. What can an agent accomplish immediately upon authentication without requiring extensive setup or exploration? Making this path clear and functional improves both agent experiences and human onboarding.
Measure and Iterate
Agentability is not a one-time achievement but an evolving property of your product. As agents become more sophisticated and widespread, the bar will rise. Establishing baseline measurements now positions your team to track progress and respond to ecosystem changes.
The current state of agentability across the SaaS landscape suggests we are in the early stages of a significant shift. Products like Mixpanel have an opportunity to lead this evolution rather than react to it later under competitive pressure. The question is not whether AI agents will become a primary mode of software interaction, but which products will be ready when they do.
How agent-ready is your product?
Run a free agentability audit and get a scored, prioritized fix list in minutes.
Run a free audit