AI Agent: why the product builder must learn to collaborate
Partner in ai and product management at Converteo, David Spire assists organizations in transforming their product strategy in the age of ai and data. A specialist in product build ai and agentic ai, he develops concrete, performance-oriented solutions to make ai a lever for sustainable growth.
Key takeaways
- The more an autonomous ai agent is able to act alone, the more its creator must collaborate—this is the agentic paradox.
- The shift from SaaS to “service-as-a-software” changes the very nature of work: we no longer design interfaces, we design behaviors.
- The autonomy matrix allows the product builder to choose the right working mode according to the complexity of the prototype and the IT stack.
Intuitively, one might think that a more powerful autonomous ai agent would make its creator more independent. The reality is the exact opposite. The more agentic a product becomes—capable of executing complex tasks without human intervention—the more critical its connection to the company’s ecosystem becomes.
This connection requires structured collaboration with engineering and IT teams. The product builder who yesterday could act solo must now learn to become an orchestrator. This is the agentic paradox: the gain in autonomy of the machine imposes a loss of autonomy for the one who builds it, in favor of more rigorous collaboration.
The fundamental break: from SaaS to “service-as-a-software”
To understand this paradox, one must grasp a change in the nature of software itself. We are leaving the era of “software-as-a-service” to enter that of service-as-a-software.
In a classic SaaS model, the work consists of designing interfaces: screens, buttons, menus. The software is a tool; the user remains in command. A simple conversational chatbot, even an intelligent one, can be built in near-autonomy on this model.
In the new world of the autonomous ai agent, the work consists of designing behaviors. The agent no longer just presents information—it makes decisions, interacts with APIs, modifies data. An agent that accesses the CRM to qualify a complaint, queries the logistics database to check stock, then triggers a refund via a financial API is no longer a simple tool. It becomes an active gateway to the heart of the company’s information system.
When the autonomous ai agent meets the reality of the information system
As soon as an agent touches the company’s critical systems—CRM, ERP, finance—the stakes change dimensionally. Security, data governance, scalability, and reliability become non-negotiable.
The role of the product builder then shifts from “solo builder” to “orchestrator of a hybrid team”. Trying to build a complex agent in a vacuum is the shortest path to the pilot project purgatory: a prototype that is impressive in a demo, but impossible to industrialize because it has never faced the real constraints of the company’s systems.
The autonomy matrix: which working mode for which autonomous ai agent?
To position themselves effectively, the product builder can rely on a matrix crossing two axes:
- The complexity of the prototype: simple Q&A or a multi-agent system with planning?
- The complexity of the IT stack: connection to sensitive or legacy systems, or an isolated environment?
Quadrant 1 — Autonomy (simple stack / simple prototype)
The domain of rapid experimentation. The product builder can design, build, and deploy without depending on IT.
Example: an internal FAQ chatbot based on public content.
Quadrant 2 — Innovation and de-risking (complex stack / simple prototype)
The challenge is to prove the value of a connection to a sensitive system. The builder works in a “sandbox”, with anonymized data or pre-production APIs provided by IT. Their role: to de-risk the value of the interaction before any broader commitment.
Example: an assistant that analyzes an anonymized export of 100 contracts.
Quadrant 3 — Co-engineering (complex stack / complex prototype)
The quadrant of strategic and transformative projects. Autonomy is no longer an option. The product builder — engineer duo becomes the production unit: one brings the product vision, the other the expertise in architecture and security.
Example: a multi-agent system automating the end-to-end processing of a complaint.
Quadrant 4 — The danger zone (simple stack / complex prototype)
The classic trap. The builder creates a very ambitious autonomous ai agent on an isolated stack, without anticipating integration constraints. The prototype will never become a production product.
The future of ai development does not belong to solitary builders, but to product builders who can orchestrate this complex collaboration. An organization’s maturity will be measured by its ability to master this fundamental paradox: requiring more human rigor to enable more machine autonomy.