Password managers occupy a unique position in the software ecosystem. They're designed to be gatekeepers—securing credentials while making them accessible when needed. But as AI agents increasingly perform tasks on behalf of users, tools like LastPass face a fundamental design tension: the same security mechanisms that protect human users can block autonomous software from operating effectively.
The question isn't whether password managers should accommodate AI agents—it's how they can do so without compromising their core security mandate. Recent agentability research into LastPass and the broader SaaS landscape reveals where this balance currently stands, and why most products are failing to prepare for agent-mediated workflows.
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 Factor Engineering (AFE) principles. These principles evaluate whether a product's design enables reliable, programmatic interaction beyond traditional APIs—examining everything from how readable the interface is to machines, to whether the product provides adequate operational transparency.
The eight AFE principles are:
- Machine readability: Can agents parse and understand interface elements reliably?
- Transparency: Does the product expose its state, capabilities, and constraints in machine-readable formats?
- Shadow-UI avoidance: Are interactive elements accessible through standard protocols, not just visual rendering?
- Defaults: Do out-of-the-box settings support agent operation?
- Control: Can agents manipulate the interface predictably?
- Chunking: Are complex operations broken into manageable, observable steps?
- Status: Do operations provide clear feedback about progress and completion?
- Clean handoffs: Can agents transfer control to humans smoothly when needed?
For password managers specifically, these principles intersect with security requirements in complex ways. A detailed analysis of LastPass's agentability characteristics illustrates the category's broader challenges.
The State of SaaS Agentability
An audit of the top 100 SaaS products reveals an industry largely unprepared for agent-mediated workflows. The average agentability score sits at just 38.3 out of 100—a grade that would translate to a failing mark in most educational contexts.
The tier distribution shows only 22 products achieving "Agent-Ready" status with scores of 45 or above, while 54 products fall into the "Developing" category (35-44), 17 are "Lagging" (20-34), and 7 are essentially "Agent-Blind" with scores under 20.
Breaking down performance by individual principles reveals where the industry struggles most. Machine readability scores highest with an average of 71, suggesting that basic semantic HTML and accessible markup have gained traction. Control (48), status (47), and chunking (45) cluster in the middle range—products generally allow interaction and provide some feedback, but inconsistently.
The crisis points are transparency and shadow-UI avoidance.
Transparency averages just 5 out of 100, with 83 of the 100 audited products scoring zero on this principle. This means the vast majority of SaaS products provide no machine-readable information about their capabilities, state, or constraints.
Shadow-UI avoidance fares only slightly better at 17, with 80 products scoring under 20. This indicates that most interfaces rely heavily on visual-only cues, dynamic JavaScript interactions, or custom components that standard automation protocols cannot access reliably.
Why Password Managers Face Unique Challenges
Password managers like LastPass confront specific agentability obstacles that amplify the industry-wide patterns. Security requirements naturally push toward opacity—deliberate obscuring of credentials, obfuscation of DOM elements containing sensitive data, and restrictions on programmatic access to prevent malicious automation.
The challenge is distinguishing between legitimate agent access (an AI assistant helping a user log into a service) and unauthorized extraction attempts. Without machine-readable transparency about capabilities and constraints, agents cannot determine what operations are permissible. Without proper shadow-UI avoidance, browser extensions and autofill mechanisms become invisible to agents trying to coordinate multi-step workflows.
Consider a common scenario: an AI agent needs to help a user set up a new SaaS trial. The agent must navigate to the signup page, fill forms, and manage credential storage. If the password manager's extension injects credentials through JavaScript events that aren't exposed through accessibility APIs, the agent cannot detect when autofill has occurred or verify that correct credentials were used. The workflow becomes unreliable, forcing fallback to human intervention.
This isn't a theoretical concern. As organizations adopt AI agents for workflow automation, password manager compatibility will become a critical factor in tool selection. Products that maintain security while providing agent-readable interfaces will have a competitive advantage.
The Transparency and Shadow-UI Crisis
With 83 of 100 products scoring zero on transparency, the SaaS industry has systematically neglected machine-readable capability documentation. Products don't expose what they can do, what states they're in, or what errors mean in formats agents can parse.
This creates brittle integrations. Agents must infer capabilities through trial and error, guess at error conditions, and maintain fragile selectors that break with UI updates. The 80 products scoring under 20 on shadow-UI avoidance compound the problem by hiding interactive elements behind visual-only interfaces.
For password managers, these gaps prevent agents from understanding authentication state, detecting when credentials are needed, or coordinating with the manager to provide them securely. The result is fractured workflows that require constant human supervision—defeating the purpose of agent automation.
Recommendations for Product Teams
Product teams can improve agentability without compromising security or overhauling their architecture. Start with transparency: publish machine-readable capability documents that describe what your product does, what states it can be in, and what operations are available. For password managers, this might include authentication status, vault lock state, and available autofill targets.
Address shadow-UI issues by ensuring interactive elements use semantic HTML and ARIA attributes. Browser extensions should expose their state through standard DOM properties and events that automation tools can observe. This doesn't mean eliminating security obfuscation for credential values—it means making the surrounding context and controls accessible.
Implement better defaults for agent operation. Provide configuration options that allow authenticated agents to perform routine operations without constant user confirmation, while maintaining security boundaries for sensitive actions. Design chunked workflows with clear status feedback at each step.
Most importantly, test your product with automation tools and agent frameworks. Teams can run a free audit to identify specific agentability gaps. The full dataset and methodology are available in the Agentability Index.
The agent era isn't coming—it's here. Products that adapt will enable powerful new workflows while maintaining the security and reliability users expect. Those that don't will become bottlenecks in increasingly automated environments, forcing users to choose between security and productivity. For password managers especially, getting agentability right isn't optional—it's essential to remaining relevant as software interaction evolves.
How agent-ready is your product?
Run a free agentability audit and get a scored, prioritized fix list in minutes.
Run a free audit