Software Agents Taking the Long View: UI/UX Roadblocks
From User Experience and Interface to Agent Experience and Interface
Hi, I’m Clement. The Big Picture is a newsletter for founders and investors who want to make sense of what is happening in the SaaS industry.
This is a series of articles where I articulate my current thesis about software agents and how they will impact the broader B2B software industry over the next decade.
Part 1: Overcoming the roadblocks - Challenges for software agents to succeed
Part 2: Removing the roadblocks
Part 3: A twelve-question framework to assess software agents
Overcoming the roadblocks: UI/UX Roadblocks
Last week I wrote about data roadblocks and the solutions emerging to solve them. This week let’s dive into the UI roadblocks that currently limit software agents.
Roadblock #1: More natural language and zero-interface interactions in SaaS products
Roadblocks: Most SaaS interfaces rely heavily on dashboards for visualisation, buttons for actions, and input forms to collect data, offering human users a mostly visual way to interact with software. However, this model is not necessarily the best suited for autonomous software agents, which need to operate without manual input to perform their tasks. Instead, software agents benefit from conversational interfaces (chat or voice based) to interact with humans and from API driven interfaces to execute actions autonomously in the background. And of course notification interfaces to notify users when necessary. This will probably require software providers to adapt their existing interfaces to accommodate agents.
Emerging Solutions:
Embedded conversational interfaces: Rich chat-based UI components are likely to become more widespread in B2B software. Think of the ChatGPT interface, in which interactions with AI occur through a polished chat interface where long answers are streamed and interactive tools like code interpreters or embedded graphs and table visualization enable interactive content.
Real-time notification systems for agents: Since most agents are designed to perform tasks autonomously in the background, real-time notification systems will be essential to keep human users informed about the progress of these tasks or any actions they need to take.
Agent overview and orchestration dashboards: These dashboards will provide users with a high-level overview of all agents currently running, the tasks they are working on, and their progress. Users can monitor performance, adjust priorities, or intervene when needed. Basically an “agent management” interface/dashboard.
Roadblock #2: Building agent-oriented APIs versus human-oriented APIs
Roadblocks: Today most APIs are designed with human developers as the primary users. They prioritize simplicity, readability, and ease of debugging, often using human-readable formats like JSON and XML. While this works well for human users, it is probably not the best design for autonomous agents. APIs that enable self-discovery (to find and use available functionalities autonomously), self-debugging (to resolve issues without manual intervention), and adaptability (to dynamically adjust to new contexts or requirements) are better suited for software agents.
Emerging Solutions:
AI-Specific APIs: APIs explicitly tailored for AI use cases would allow greater autonomy and control for agents. For instance, OpenAI’s “Function Calling” feature enables agents to call specific API functions (like file search or code interpreter) based on natural language instructions and to combine them to complete tasks. Another example might include APIs that allow agents to fine-tune their behavior based on real-time inputs or changing contexts.
Semantically rich APIs: Tools like GraphQL can be upgraded with smarter data structures that help agents understand the connections between different pieces of information, making it easier for them to ask complex questions and make sense of the data. For example, an agent interacting with a GraphQL API for a logistics software could not only retrieve package tracking details but also infer potential delivery delays by analyzing contextual data, such as weather or traffic conditions.
APIs designed for flexibility and self-adaption: To support autonomous agents, APIs could incorporate features like clear versioning standards, machine-readable metadata, detailed structured error messages for autonomous troubleshooting, and negotiation mechanisms. The aim is to provide an API design that enables agents to adapt to API changes by themselves.
Roadblock #3: Human-oriented authentication vs. agent-oriented authentication
Roadblocks: Traditional authentication models, such as signup/login flows, API keys, and OAuth, were originally designed with human users or static applications in mind. These authentication systems rely on mechanisms like passwords, email verification, and access control based on predefined human roles (e.g., "Admin" or "Editor"). And once again, if these models work mostly fine for humans, it is a different story for software agents. As agents proliferate, we need authentication frameworks that enable them to access software and tools in a secure and manageable way:
Agent identity & access control: Establishing who the agent is and proving its legitimacy in a secure way.
Agent behavior: Continuously verifying that agents are acting within expected norms, preventing malicious or rogue behavior.
Emerging solutions:
Agent identity & access control: Authentication & authorization systems for agents need to securely confirm who they are and what they are allowed to do. This means giving each agent a digital identity and making sure they can only access the parts of the system or perform actions they’re authorized for. Many auth providers are already working on such features.
Behavior scoring systems: It’s possible that we’ll need systems that evaluate an agent’s actions in real time, and give him a "score" based on how well it follows expected behavior. If an agent starts acting strangely or in a harmful way, the system can flag it or stop it. For example, if an agent suddenly starts making transactions far beyond its usual pattern, the system can detect this anomaly and raise a red flag.
Roadblock #4: Enabling multi-agent collaboration
Roadblocks:One of the key innovations of SaaS products was to enable collaboration between humans with features like shared workspaces, chat, or document editing. These features are designed to help people work together. But when it comes to collaboration between multiple autonomous agents, we’re still far from having similar features (since we barely have working agents :-)). Agents probably won’t have the same communication or decision-making frameworks as humans, and will probably need new methods to resolve conflicts, share resources, and synchronize actions.
Emerging Solutions:
Inter-agent protocols: There could be protocols that allow agents to negotiate and coordinate with each other. For example, if two agents are trying to perform the same task, the protocol helps them decide how to divide the work or take turns without stepping on each other’s toes.
Agent orchestration tools: Platforms like LangChain help manage and organize how multiple agents work together. These tools act as a command center, ensuring that a series of agents can collaborate effectively to achieve bigger goals. For instance, one agent could gather data, while another processes it, and a third takes action based on the results.
Of the four challenges, this is probably the one where we’re the least advanced
See you next week for the deep dive on the human roadblocks.
The Big Picture
Data points and market trends
Last week I was discussing hiring with a founder and stumbled upon this graph shared by Jason Lemkin.
About half of startup employees leave within three years (!). It’s wild to think that over 50% of startup employees don’t stick around beyond the first three years.
Specialists vs. generalists. I think part of the explanation is that at early stage it makes a ton of sense to hire generalists whether it’s for marketing, sales, support or even developers. But as your startup grows, you start to need specialists. And often the generalists you hired don’t fit anymore and tend to leave (some will go the specialization path). So the fact that startups evolve quickly the first couple of years is part of the explanation I think (but not the only factor).
Set expectations based on a three-year horizon. At early stage, there’s often the question of hiring the first head of marketing, sales, operations, etc. When I see these numbers, I think that a good approach is to plan on a three-year horizon instead of thinking too long term. It’s not necessarily the person with the most experience who makes the most sense, but the one who can deliver what you need over the next three years.