When we look back at the last decade of network transformation, the telecom industry has plenty to celebrate. We have made significant progress shifting from monolithic hardware appliances toward disaggregated, cloud-native software. Along the way, we championed closed-loop automation, proving that data-driven loops could monitor infrastructure and trigger automated workflows to handle massive volumes of faults without human intervention.

But as networks grow increasingly hyper-distributed, multi-cloud, and dynamic, traditional closed loops are hitting an operational wall. They are fundamentally reactive and deterministic. If an anomaly occurs that does not match a pre-programmed rule, the closed loop stalls, and human operators must step in.

To achieve true autonomous networking, we must take the next logical step: moving from rigid closed loops to Agentic AI.

Traditional automation follows a strict “if-this-then-that” playbook. Agentic AI, by contrast, introduces autonomous reasoning and goal-oriented action. Instead of hard-coding the exact steps to fix a specific network fault, we provide an AI agent with a high-level operational objective. For example, an operator might instruct an agent to optimize radio resource efficiency in a highly congested sector while maintaining strict carrier-grade reliability. The agent then autonomously evaluates the data and figures out the optimal sequence of actions to achieve that outcome.

Network AI agents do not just passively monitor. They predict capacity bottlenecks before they hit, coordinate with neighboring localized agents, and dynamically rewrite configurations in real time.

Moving from a localized proof-of-concept (PoC) to full production deployment is notoriously difficult. We cannot have unvalidated AI agents executing unpredictable commands on critical telco infrastructure. Trying to pack all of this logic into a single project goes against every cloud-native principle we have spent years establishing.

Instead, the Linux Foundation and LFN are fostering a specialized ecosystem where distinct open source building blocks collaborate to make agentic infrastructure safe, predictable, and production-ready:

• The Application & Pipeline Layer (Essedum): An agent needs a structured environment to handle domain-specific data and pipelines. Essedum’s 1.0 release provides exactly this, acting as a specialized integration framework that orchestrates existing ML platforms rather than trying to replace them, rapidly decreasing development time for network teams.
• The Intent & Orchestration Layer (Nephio & ONAP): AI agents thrive on declarative commands rather than rigid manual scripting. Frameworks like Nephio and ONAP leverage GitOps based automation to manage complex network functions, allowing agents to push high-level intent down to the infrastructure safely.
• The Context & Interoperability Layer (Read the CAMARA & MCP whitepaper here): For an agent to make smart decisions, it must be network-aware. By combining CAMARA network APIs with emerging frameworks like the Model Context Protocol (MCP), open source allows agents to pull real-time under-the-hood network context directly into their reasoning engines.
• The Guardrail Layer (Salus): Trust is the ultimate currency in telecom. This is where the Salus project comes into play, acting as the essential validation framework to enforce responsible AI guardrails, verify data privacy, and validate agent outputs to prevent hallucinations in live operations.

As exciting as autonomous agents are, a word of caution is necessary. We should not treat Large Language Models (LLMs) and agents as the default silver bullet for every single networking problem. Many network use cases are still better served by simpler, highly predictable, classical machine learning approaches. The real discipline lies in matching the operational challenge to the right technology, rather than forcing every system into an autonomous loop.

For years, the telecom sector viewed fully autonomous networking through a lens of wide-eyed observation. Today, we are firmly in the phase of proof. By avoiding monolithic silos and focusing on a standard, interoperable open-source ecosystem, we can build an intelligent network fabric that is resilient enough to self-heal and adapt entirely on its own.