What does the advent and adoption of agentic AI mean for someone whose job it is to think about and lead practices at the convergence of AI, software, cloud-native and platforming at a major Tier One mobile operator?
In January, TMN met Orange’s VP of Software Engineering, Philippe Ensarguet, for a briefing on agentic AI, which it is fair to say is a topic that has been on his mind. Ensarguet leads the operator’s thinking on its targeted transition to a software-driven company; he became an Orange Fellow in 2025, with a mandate to explore emerging frontiers in technology and amplify knowledge-sharing.
Speaking with a drive approaching passion, Ensarguet argues that the current momentum around agentic AI represents a genuine technological inflection point. In his eyes, the move to agentic is not an incremental upgrade to generative AI, but a fundamental change in how digital systems are designed, integrated and operated.
While generative AI has delivered impressive gains in language understanding and content generation, it remains inherently passive. It can explain, summarise, and reason to a degree, but it cannot act. Agentic AI, by contrast, introduces autonomy. And autonomy, he stresses, changes everything.
From Models to Systems
A central point in Ensarguet’s argument is that agentic AI should not be treated as a feature layered onto existing systems. It must be understood as a system in its own right that is designed, tested, deployed, operated, and governed like any other mission-critical infrastructure.
This distinction matters because agentic AI introduces new responsibilities: control, oversight, accountability, and trust. The challenge is no longer just intelligence, but ensuring that autonomous systems behave safely, reliably, and predictably enough to be used in production environments.
In this sense, the shift mirrors earlier technology transitions such as the rise of the web or enterprise digital services, where new architectural and design patterns had to be established before systems could scale industrially.
Why Generative AI Was Not Enough
Ensarguet is clear about the limitations of large language models on their own. By design, LLMs can generate and reason over text, but they lack persistent memory, tools, and feedback loops. They cannot independently perform tasks or drive operations.
To mitigate these limits, the industry introduced techniques such as Retrieval-Augmented Generation (RAG) and fine-tuning, which enable explanation and evaluation. But they still leave AI operating in a passive mode.
Agentic AI adds actors that can reason, select tools, take actions and adapt dynamically based on goals and context. This, he argues, is the true breakthrough.
Autonomy Changes Integration Itself
One of the most significant consequences of agentic AI is how it transforms system integration.
Traditional enterprise integration is API-driven, deterministic, and developer-controlled. Humans design workflows in advance, define contracts, and decide how data and actions flow. The system executes predefined logic.
Agentic AI reverses this model. Instead of humans orchestrating APIs, agents dynamically discover and invoke capabilities based on goals. Workflows are no longer fixed; they are constructed on the fly, guided by context and reasoning. Errors, for example, are no longer just failures. They become signals the agent can use to explore alternative paths toward the same goal.
Take for example, the business model that is building up around network APIs that expose capabilities to developers. Ensarguet frames APIs as the existing, mature integration layer that agentic systems will build on top of. This is a shift from “contract-based” integration to “conversational” integration, from fixed workflows to dynamic orchestration.
Currently, a developer calls an API, knows exactly what comes back, and hard-codes the next step. In an agentic system, instead of an API call from the developer, an agent discovers and calls APIs autonomously, can sequence them dynamically and possibly take different paths for the same request
So network APIs become tools the agent selects, not endpoints a developer accesses manually. For telecom specifically, network APIs that could be exposed as agent tools include SIM swap, device location, geofencing, slicing and quality on demand.
These are exposed via an MCP (Model Context Protocol) layer, which translates APIs into semantic descriptions and injects those descriptions into the model’s context. This lets the agent “understand” what each API does and enables the agent to choose the right one.
So APIs remain essential – they just become machine-consumable capabilities instead of manually coded integrations.
Ensarguet cautions that APIs MCP/agentic integration is very new and security, observability, testing, and governance are not solved yet. Non-determinism is risky for production networks. So his stance isn’t to “replace APIs with agents,” but rather keep APIs as the foundation, and let agents orchestrate them intelligently.
The Role of Model Context Protocol (MCP)
To enable this new integration model, Ensarguet highlights the importance of Model Context Protocol (MCP) – still a new technology that is only just over a year old. MCP acts as an intelligence middleware that semantically exposes system capabilities to AI models.
Rather than hard-coding API usage, MCP allows agents to discover available capabilities and understand them through semantic descriptions. They then decide autonomously which tools to use to achieve a goal.
Ensarguet emphasises that MCP itself is not the value. The real value lies in the capabilities being exposed. MCP is simply a new doorway for connecting systems. Treating the protocol as the product risks missing the business point entirely.
Agents vs. Agentic Systems
Ensarguet draws a clear distinction between individual AI agents and agentic AI systems.
An agent, by design, is narrow in scope. It has a model (the “brain”), a reasoning loop, tools for interacting with its environment, and a specific, goal-oriented task.
An agentic AI system, on the other hand, is an architecture. It consists of multiple specialised agents collaborating through task decomposition, planning, coordination, and shared memory.
Memory, he notes, is both a key enabler and a major risk. Poorly managed memory can consume context, degrade reasoning quality, and undermine system reliability. Designing memory and context management carefully is therefore essential.
A Strong Warning Against Overuse
Despite his enthusiasm, Ensarguet is explicit about restraint.
He introduces what he calls his “golden rule zero”: if a single model call or a deterministic script can solve the problem, do not use agentic AI.
Agentic systems introduce non-determinism, complexity, latency, and operational risk. They are powerful but expensive and difficult to control. Before deploying them, teams must rigorously assess safety, blast radius, observability, containment, SLA impact, cost, and whether real value is being created.
This caution is especially important in production environments, where operators are responsible for systems running 24/7. Non-determinism may be acceptable in research; it is far harder to justify in live operations.
Orange’s Experience So Far
Drawing on Orange’s internal work, Ensarguet explains that the past two years have been largely exploratory. Teams have tested, failed, learned, and iterated across security, network operations, cloud-native runtimes, and agentic architectures.
Some of these explorations have already shown promise, particularly in areas such as 5G security operations using multi-agent systems, observability-driven automation, and lifecycle management augmentation through conversational interfaces. At its OpenTech event in November, TMN saw a demo of a RAN agent running across a hybrid cloud RAN from Nokia and AWS, with AI agents sited on the DU and/or at the CU location monitoring and dynamically optimising network slices.
Following this, Ensarguet believes 2026 may mark the first year of early, real-world deployments – still limited in scope, but concrete enough to demonstrate operational value.
Agentic monitoring to enable dynamic monitoring and control of a network slice in a Cloud RAN setting.
