As enterprises race to integrate AI agents into their workflows, customer relationship management platforms face mounting pressure to support programmatic access that goes beyond traditional APIs. A recent audit of 100 leading SaaS products reveals where Zoho CRM stands in this transition—and highlights the systemic challenges facing the entire software industry.
Agentability measures how well software products support AI agent operation across eight Agent Factors Engineering (AFE) principles. Unlike API availability or webhook support, agentability evaluates the complete surface area that agents need: machine-readable interfaces, transparent state exposure, predictable interaction patterns, sensible defaults, user control mechanisms, task decomposition support, status visibility, and clean interaction boundaries.
The Landscape: A Struggling Transition
The audit examined homepage implementations across 100 major SaaS products, scoring each on a 0-100 scale. The results paint a sobering picture of an industry still in early stages of agent readiness.
The average agentability score across all audited products is just 38.3 out of 100, indicating that most enterprise software remains poorly optimized for AI agent interaction.
Products fall into four tiers based on their scores:
- Agent-Ready (45+): 22 products
- Developing (35-44): 54 products
- Lagging (20-34): 17 products
- Agent-Blind (under 20): 7 products
Zoho CRM falls within the Developing tier, placing it alongside the majority of audited products. While not in the bottom quartile, this positioning indicates substantial room for improvement in supporting autonomous agent workflows.
Breaking Down the Eight Principles
The AFE framework evaluates products across eight distinct principles, each addressing a specific dimension of agent-software interaction. Understanding performance across these principles reveals where the industry succeeds—and where it consistently fails.
Machine Readability: The Relative Bright Spot
At an average of 71 out of 100, machine readability represents the strongest area of performance. This principle measures whether interface elements expose semantic information that agents can parse: proper HTML structure, ARIA labels, consistent selectors, and predictable DOM patterns. Most products achieve baseline competence here, largely because accessibility standards developed for screen readers provide overlapping benefits for AI agents.
Transparency: A Near-Universal Failure
A staggering 83 of 100 products score zero on transparency, revealing a fundamental gap in how software exposes its internal state to external observers.
Transparency measures whether agents can understand application state without performing actions: Can an agent determine what data is loaded? What operations are in progress? What errors exist? Most products treat their internal state as opaque, forcing agents to infer conditions through trial and error—a pattern that leads to brittle, unreliable automation.
Shadow-UI Avoidance: Hidden Complexity
Shadow-UI refers to interface patterns that exist outside the standard DOM: canvas-rendered controls, custom gesture systems, tooltips containing critical information, and visual-only feedback. These patterns create blind spots for agents that rely on structured markup.
With 80 of 100 products scoring under 20 on shadow-UI avoidance, this represents the second-most problematic principle after transparency.
The proliferation of JavaScript frameworks and custom component libraries has accelerated shadow-UI adoption, often in the name of richer user experiences. The cost: interfaces that appear sophisticated to humans but opaque to programmatic observers.
The Middle Ground: Control, Chunking, and Status
Three principles cluster in the mid-range of performance:
- Control (average: 48/100) measures whether users can govern agent behavior through preferences, permissions, and constraints
- Chunking (average: 45/100) evaluates how well products break complex workflows into discrete, resumable steps
- Status (average: 47/100) assesses visibility into operation progress and completion states
These middling scores suggest that products implement these capabilities inconsistently—present in some workflows, absent in others, often without systematic design consideration for agent use cases.
Defaults and Clean Handoffs: Room for Growth
Defaults (average: 35/100) measures whether products ship with sensible configurations that work out-of-the-box for common agent scenarios. The below-average performance indicates that most products require significant customization before agents can operate effectively.
Clean handoffs (average: 40/100) evaluates transition points where control passes between user and agent, or between different system components. Poor performance here manifests as unclear boundaries, ambiguous state ownership, and race conditions when multiple actors interact with the same resources.
What This Means for Product Teams
The data reveals that agentability gaps are not isolated failures but systematic blind spots in how products are designed, built, and evolved. For teams working on CRM platforms like Zoho, or any complex SaaS product, several concrete opportunities emerge.
First, expose state deliberately. Agents need to read current conditions—loaded records, filter states, validation errors, operation progress—without triggering actions. Consider dedicated state endpoints, comprehensive ARIA live regions, or structured metadata in data attributes.
Second, audit your interface for shadow-UI patterns. Canvas-rendered tables, custom dropdowns, and tooltip-based critical information all create agent blind spots. Where these patterns are necessary, provide parallel machine-readable alternatives: structured data attributes, programmatic query interfaces, or semantic HTML fallbacks.
Third, design for composability. Break monolithic workflows into discrete steps with clear entry points, exit conditions, and state preservation. An agent should be able to start a task, pause for human input, and resume without losing context.
Fourth, make control explicit. Users need granular ways to specify what agents can and cannot do: which fields they can edit, which workflows they can trigger, what thresholds require human approval. Embed these controls in your permission systems from the start.
The transition to agent-ready software will not happen through API additions alone. It requires rethinking interface architecture to serve both human and machine observers, exposing state as a first-class concern, and designing interaction patterns that support decomposition and delegation.
For teams ready to benchmark their own products, run a free audit to see how your implementation performs across the eight AFE principles. The full dataset and methodology are available in the Agentability Index.
Zoho CRM's position in the Developing tier reflects neither excellence nor failure, but rather the current state of an industry in transition. The question for every product team is not where you stand today, but how quickly you can close the gaps that separate adequate software from agent-ready infrastructure.
How agent-ready is your product?
Run a free agentability audit and get a scored, prioritized fix list in minutes.
Run a free audit