Designing B2B SaaS and AI agents together means accepting that some of your users will no longer go through your screens. A customer’s AI agent reads your documentation, calls your API and proposes actions to a person who decides. Your product therefore has to be readable by a machine, bounded by clear permissions, and keep a visible human approval for anything that commits the customer.
Many software vendors see the topic go by without knowing where to start. Do you need an MCP server, a new API, a full redesign? Here is what really changes, what to decide before writing a line of code, and a method to move forward without rebuilding everything.
B2B SaaS and AI agents: what changes for the vendor?
For a long time, a B2B SaaS was designed for a single kind of user: a person in front of a screen. They look for information, read a table, click a button. All the design work, from the journey to the labels, starts from what they see.
AI agents add a second user. It acts on behalf of a person, across several tools at once, and it has neither eyes nor patience. What it understands about your product comes from what you give it to read.
A new user who never sees your screens
Picture a purchasing manager who asks their assistant to compare three tools and prepare an order. The agent does not look at your home page the way a visitor does. It looks for documentation, terms of use, an API, and reports a summary to someone who may never see your interface.
In an opinion piece published by Maddyness, Jean-Marc Prunet, partner at Cathay Capital, sums up the risk: for a vendor, the danger is not being replaced but being made invisible. Without capabilities of its own, third-party layers capture the relationship and reduce the software to a database queried by other agents.
The same piece points out that agents cannot act in a vacuum. They need structured data, business rules and compliance frameworks. That is exactly what a good B2B SaaS already has, provided it makes them accessible.
What open protocols have already laid down
The technical building blocks exist and are settling. The Model Context Protocol (MCP) describes a standard way to connect an AI application to data sources and tools. An MCP server can expose three things: resources (context and data), message templates, and tools the model can execute.
For communication between agents, the Linux Foundation launched on 23 June 2025 a project around the Agent2Agent (A2A) protocol. Its stated aim is to let agents from different systems work together securely and neutrally.
You do not have to pick a side. These protocols rest on what your product should have anyway: well-named functions, clean data and explicit access rules.
What does not change: the decision stays human
A B2B buyer does not hand their responsibility over to an agent. They delegate research, comparison and preparation.
Signing, paying and deleting data remain acts they want to control.
The MCP specification itself sets this as a principle: the host application must obtain the user’s explicit consent before invoking a tool. It also asks that tool descriptions be treated as untrusted unless they come from a trusted server. The protocol puts the person at the centre; your product should do the same.
How do you make your SaaS readable by an agent?
Making a product readable by a machine is not an artificial intelligence project.
It is a clarity project, one that teams often put off because the human interface makes up for vague spots. An agent makes up for nothing.
An action handed to an agent goes through four steps, and the person steps in before execution.
Public documentation that says what the product does
The first thing an agent reads is what you publish. A page that explains in plain sentences what the product does, for whom and within which limits gives it a starting point. Marketing slogans do not help: it needs facts.
Three questions guide the writing:
- What does the product allow? The possible actions, named the way your customers name them.
- What does it not allow? The limits, the missing integrations, the cases not covered.
- How do you get access? The plans, the conditions, the technical documentation.
This work also serves people and answer engines. We cover it in the article on where AI creates value in a B2B SaaS, which looks at the same product from the inside.
An API that is described, not just available
An open API is not enough. An agent has to understand what each endpoint does, what it expects and what it returns. The OpenAPI Specification exists for this: it defines a standard description of an HTTP API that both people and machines can read, without access to the source code.
What matters most are names and descriptions. A function called “process” says nothing.
A function called “create a draft quote for an existing customer” says what it does, to what, and in which state it leaves the data.
Think about granularity too. A single function that does everything forces the agent to guess the parameters. Smaller functions, each with a precise effect, combine better and are easier to control.
Structured data and errors that explain themselves
An agent reads your responses literally. A date in three different formats, a free-text status typed by hand, an amount with no currency: each ambiguity becomes a possible error in the summary it hands back to the person.
Errors deserve the same care. “Error 400” does not let an agent correct itself. “Customer 1042 has no billing address: add one before creating the quote” lets it propose the right next step.
On the redesign of Bouygues Telecom’s mobile customer area, Victor Michel, founder of the studio, worked with the back-end teams on API design, error states and edge cases. An app is also judged by what it says when data is missing. That is even more true when the reader is an agent.
What can an agent do in your product, and what must it not do?
Opening your product to agents means deciding what you let them do. That decision is a product decision before it is a technical one.
It is made with the people who know what an error costs the customer.
Rank actions by risk
Not all actions are equal. Viewing a dashboard commits no one.
Sending an invoice, changing a contract or deleting an account commits the customer, sometimes irreversibly.
A simple ranking is enough to start:
| Level | Examples | What the agent can do |
|---|---|---|
| Read | view, search, export | alone, within its permissions |
| Prepare | draft quote, suggested reply | alone, with no effect until approved |
| Execute | send, pay, delete | only after human approval |
This table becomes your reference. Every new function exposed to agents gets its row before it is built.
The more an action commits the customer and the harder it is to undo, the more explicit the human approval must be.
Separate permissions for each agent
An agent should not inherit every permission of the person using it. An administrator can do everything; their agent often only needs to read and prepare.
Giving each agent a separate, limited and revocable access keeps a misunderstanding from turning into an administration error.
The GDPR already sets this principle in Article 25: by default, only the data necessary for each purpose should be processed. An agent preparing a quote does not need the payroll history.
On EPItrack, the protective equipment tracking tool designed by the studio, the operator and the administrator share the same data seen from two angles. Adding an agent means adding a third angle, with its own limits, rather than copying the administrator’s.
Human approval as a step in the journey
Approval is not a confirmation box people click without reading. It is a designed step: the person sees what the agent proposes, why, and what will change if they accept. They can edit before approving, or decline.
If the person approves without understanding, the approval protects no one. It must therefore stay rare, focused on actions that commit the customer, and readable in a few seconds.
On Hanny, a studio product that prepares posts for freelancers and small businesses, nothing goes out without approval. The person changes a word, swaps a photo or asks for an opinion before publishing. The principle holds for any agent acting on a customer’s behalf.
A good approval step fits on one screen. It shows the proposed action, the data involved and the consequence, with three clear choices: approve, edit, decline.
How do you keep the human buyer’s trust?
A B2B customer’s trust is built on predictability. They accept an agent working for them if they can understand what happened, reverse it and stop it. These three capabilities are designed from the start.
Added later, they turn into options buried in the settings that nobody finds on the day they need them.
A readable log of what the agent did
Every action an agent takes should leave a trace a person can read: who asked, what was done, on which data, and when. An unreadable technical log is not enough, because the person who needs it is not a developer.
The log also serves the vendor. It shows which functions agents use, where they fail and which errors keep coming back. It is a valuable source for deciding what comes next.
Being able to undo, correct and stop
What can be undone should be easy to undo. What cannot be undone should be flagged beforehand, in plain words.
And the user should be able to cut an agent’s access in one move, without going through support.
Article 14 of the AI Act describes this control for high-risk AI systems. It requires that a person can understand the system’s capacities and limitations, remain aware of the tendency to over-rely on it, disregard or reverse an output, and interrupt the system through a stop button or a similar procedure.
Most B2B SaaS products are not high-risk. But this list makes an excellent design checklist: understand, stay wary, reverse, stop. A product that follows it also reassures customers who never read a regulation.
The rules to keep in mind
Opening your product to agents does not change a vendor’s obligations, but it makes them more visible. Three topics keep coming up in customer questionnaires:
- Personal data: what the agent sees, what is sent to third-party services, where it is hosted.
- Transparency: when content or an answer comes from an AI, say so, as our article on the AI Act and chatbot transparency explains.
- Security: the permissions of each access, revocation, traceability.
For the detail of leakage and injection risks, the article on integrating AI without risk to your data goes through them one by one.
Where do you start without rebuilding everything?
Most vendors do not need a redesign to welcome agents. They need an honest inventory of what is already readable, what is not, and an order of priority.
A four-step method
- List the actions your customers perform most often, and the ones they would like to delegate.
- Rank them by risk level, with the people who know what an error costs.
- Describe the first ones for reading and preparing: documentation, described API, explicit errors, limited permissions.
- Design the approval step and the log before opening any execution action.
Start small.
A single well-designed preparation action, tested with a few customers, will teach you more than a complete MCP server nobody uses.
What real projects show
On Desy, a studio product that audits design systems, the result of an analysis can be exported in a form AI coding agents can read. The aim is simple: that they follow the system instead of working around it. That choice required structuring the data far more than for a report meant for a person.
On the anomaly detection interface Victor Michel designed for Metroscope, a startup born in EDF’s incubator, he had to understand with the data scientists the logic of the algorithms, their confidence intervals and their false positives. You cannot design for an AI without knowing what it does not know. The same principle works the other way round: an agent can only use your product well if you tell it what the product cannot do.
Both projects say the same thing: the effort goes first into clear rules and data. AI comes next, and it only does well what has been made readable for it.
If you are a software vendor in Geneva, Lausanne or the Chablais, our page on our SaaS studio in Geneva explains how we work with product teams in the region. The simplest step is to talk: in 30 minutes, we look together at what your customers would like to hand over to their agents.
Sources
- Model Context Protocol, Specification (version 2025-11-25)
- The Linux Foundation, Linux Foundation Launches the Agent2Agent Protocol Project (23 June 2025)
- OpenAPI Initiative, OpenAPI Specification v3.1.0
- European Commission, AI Act Service Desk, Article 14: Human oversight
- European Union, Regulation (EU) 2016/679 (GDPR), Article 25
- Maddyness, Jean-Marc Prunet, L’IA ne tue pas le SaaS, mais seuls ceux qui se transforment en profiteront (27 March 2026, in French)