Unlock business value with agents
The emergence of AI agents marks a key step in the recent evolution of artificial intelligence: after the era of language models perceived as conversational assistants, we are witnessing the rise of systems capable of reasoning, planning, and acting autonomously beyond a question-and-answer exchange. This shift can be explained as much by the maturity of large models as by the progressive standardization of the tooling ecosystem that surrounds them: knowledge retrieval engines, long-term memories, execution services, and orchestration protocols. All of this creates fertile ground for integrating "agency" into business processes; yet, this promise raises as many technical as organizational challenges, and this is often where companies hesitate to take the plunge.
It all starts with the idea of connecting an LLM to its environment. As long as a model remains isolated, it suffers from contextual amnesia: it ignores the company's private data, cannot perform any concrete action, and mechanically reproduces biases from its training corpus. By plugging in document retrieval modules and a vector memory cache, it is given the means to "see" updated facts and recall previous conversations. This contextual enrichment limits hallucinations and opens the way to higher-value scenarios, such as enriched customer support or augmented contract analysis. This is the fundamental stage of the "augmented LLM," where the priority remains the reliability of the response rather than the autonomy of the decision.
Next comes the notion of agentic workflow: instead of manually chaining prompts, we define execution graphs that orchestrate multiple calls to the model and, possibly, conditional branches. Four strategies are typically distinguished. Prompt chaining, simple but not very flexible, is suitable when an objective is broken down into sequential subtasks. Routing, or dispatch, delegates to an LLM "router" the choice of the best expert to process a request. The orchestrator-worker architecture, on the other hand, capitalizes on a central controller that delegates sub-objectives to specialized executors. Finally, parallelization exploits multiple models or simultaneous runs to reduce overall latency. These schemes are not mutually exclusive; a mature system often combines routing to classify the request, orchestrator-workers to distribute the work, and a closed-loop evaluator to judge the final quality.
When we go beyond simple orchestration to give the system planning capabilities, we enter the realm of AI agents. An agent is defined by three inseparable components: the model (or set of models) that handles reasoning and text generation, the orchestration engine that breaks down objectives into atomic actions, and the catalog of authorized tools. These tools can be internal APIs, a secure shell, an SQL query engine, or even a headless browser; the broader the range, the greater the agent's capacity for action, but the larger the potential error area. The difficulty therefore lies in the dosage: an overly restricted agent remains a chatbot on steroids; an all-powerful agent becomes ungovernable if no safeguards are introduced.
To decide whether the agent is worth the investment, three criteria must be considered: the complexity of the business need, the potential cost of error, and technical feasibility. The cases where the agent excels combine high complexity (extensive documentation, multiple systems to interface) and low tolerance for human failure (software development, regulatory monitoring). Conversely, a trivial or low-stakes objective is satisfied with a classic augmented LLM. Between the two lies a gray area where the question of marginal value arises: if the return on investment is uncertain, it is better to experiment on a small scale before spreading the technology.
Standardization plays a key role in moving a prototype to the industrial stage. The MCP protocol, for example, proposes to decouple the agent from its environment by means of explicit interfaces; this avoids tight coupling and facilitates supervision. In the same vein, A2A-type interactions emerge: a "developer" agent communicates with an "analyst" agent to exchange tasks, each respecting an API contract. This service-oriented thinking opens the door to composable architectures: an agent can be updated or replaced without disrupting the rest of the system, provided that the exchange protocol is respected.
In terms of governance, the major challenge is risk management. Even an agent equipped with a self-assessment loop is not immune to reasoned hallucinations; it can convince, argue, and yet be mistaken in good faith. Imposing a human validation step ("human in the loop") remains the best protection as long as robustness metrics are not standard. Moreover, the transparency of decisions becomes critical when the agent touches on regulated aspects: the ability to replay reasoning, log API calls, version prompts and models. Without these safeguards, the productivity gain is quickly paid for in compliance debt.
From a technical perspective, the success of an agent project depends on a clean and accessible data base. Initiatives often fail not because of the model, but because of a lack of a well-structured internal corpus or a reliable ETL pipeline. The knowledge collection and alignment phase (RAG, vector memories, feature cache) represents half of the real effort, even if it is less visible. In addition, continuous monitoring of the agent's behavior requires capturing detailed metrics: objective success rate, average planning time, frequency of use of the self-correction loop. These indicators fuel a vital cycle of continuous improvement, because a stagnant agent becomes obsolete as the context evolves.
Once the foundations are laid, integration into the information system requires consideration of security. Authorizing an agent to trigger business actions means granting write rights to target applications. Best practices are moving toward minimally privileged technical roles, systematic auditing of outgoing calls, and the use of managed secret vaults. Similarly, the issue of sandboxing execution environments arises: running dynamically generated code requires strict oversight (timeouts, disk access limitations, network control). Finally, GDPR compliance dictates the blurring or pseudonymization of sensitive data before any processing, whether for learning or inference.
The tools market is evolving rapidly: no-code platforms for chaining together blocks of actions, prompt engineering IDEs focused on versioning, multi-agent simulation frameworks for testing complex scenarios. While these building blocks promise faster startups, they don't replace understanding the underlying logic: drag-and-drop remains a prisoner of the abstractions it offers. Sooner or later, the most ambitious projects end up writing their own orchestration layer to implement specific business rules or optimize performance for high volumes.
The key to success lies less in algorithmic sophistication than in the alignment between business objectives and the agent's ability to act. A development assistant who writes pull requests brings measurable gains if they are connected to the CI/CD pipeline and adhere to the coding charter. A customer support agent becomes decisive if they know how to draw up up-to-date answers from a freshly populated knowledge base. In both cases, industrialization requires prompt governance—the modern equivalent of code refactoring—which prevents functional drift and secures scalability.
In the longer term, agency is expected to reshape the boundary between software and artificial intelligence. Where once deterministic scripts were designed, we are moving toward adaptive systems capable of exploring multiple paths to achieve a goal. This transition is reminiscent of the web's transformation with the arrival of reactive applications: we no longer simply display a page; we constantly negotiate a state with the user and the server. The agent, in the same way, negotiates a plan with its environment and reevaluates its strategy with each new piece of information.
For organizations, the main risk isn't technological, but cultural: accepting that a system can take initiatives changes work habits and redistributes responsibility. A progressive approach, combining design workshops, targeted proof-of-concepts, and transparent sharing of metrics, helps defuse fears. Businesses must remain at the heart of the loop: it's by establishing clear success criteria—time saved, errors avoided, user satisfaction—that we transform an experiment into a competitive advantage.
Ultimately, the issue isn't whether AI agents will replace certain tasks, but how they will reconfigure them. The parallel with industrial automation is clear: freeing humans from repetitive steps only makes sense if we value their ability to arbitrate, control, and steer the system. Successful projects are those where the agent becomes a co-pilot, not a substitute; they propose, verify, and control, but leave the final decision up to them when it affects reputation or compliance. Conversely, trying to eliminate all human intervention quickly runs up against the limits of legal liability and social acceptability.
As models advance, the window of opportunity to industrialize agents widens: new out-of-the-box capabilities reduce the cost of entry, while competition drives innovation. However, it would be unrealistic to rely on the breakthrough of a miracle algorithm: value creation comes mainly from context engineering, data quality, and the finesse of orchestration processes. In other words, the AI agent is not a magic wand but an amplifier; it multiplies tenfold the structure we offer it and the safeguards we impose on it.
In conclusion, integrating agency into an information system requires a subtle balance between ambition and caution. It requires a robust technical foundation, informed governance, and an iterative, usage-centric approach. Successful organizations are not necessarily those that invest earliest, but those that learn fastest, leveraging a continuous feedback loop between prototypes, metrics, and adjustments. From then on, the AI agent becomes not only possible, but desirable: a trusted partner for navigating the growing complexity of data and processes our businesses face every day.
To go further: how prioritize use cases for agentic AI, innovate without restraint thanks to the agentic model et GPT-5 and agents.