backBack

Network as Code, AI and the missing layer of trust

As AI grows autonomous, Network as Code turns programmable connectivity into a trusted, policy-aware, commercially viable execution layer for developers.

As AI moves from generating content to taking action across workflows and systems, trust becomes a much more practical question. In the age of agentic AI, it cannot just be taken for granted. It needs to be built into the conditions in which AI operates, with the right controls, visibility and safeguards around it.

Nokia’s Network as Code exposes network capabilities to developers, applications and emerging AI-enabled services, while also opening new monetization opportunities through shared-value service models. Trust in AI will not come only from model quality, it will also depend on the controls, context and assurances around how AI is allowed to operate. As AI services are increasingly packaged around outcomes, workflows and consumption events rather than raw infrastructure, programmable connectivity with clear service assurances can become part of a more valuable enterprise service layer. For developers, then, Network as Code is not just an API model, it can also help turn network capabilities into enterprise-ready services that support AI-enabled use cases and can be packaged, governed and monetized with clearer assurance built in. Exactly what this will look like in practice is still taking shape.

For a long time, telecom infrastructure has been described through things like speed, coverage, latency and capacity. Those still matter, but they no longer tell the whole story. If AI-driven systems are making decisions in real time, the more relevant question is whether the network can respond to context, policy and risk just as dynamically. To make that idea more concrete, I would describe trust here through four dimensions: verifiability, policy control, context awareness, and service assurance. Together, they point to a model where connectivity is not just consumed in the background but shaped dynamically to support more dependable execution through network APIs, service-level agreements and other assurance mechanisms.

From infrastructure to added trusted execution layerheader link

The network is increasingly becoming part of the control and assurance environment around applications and AI-driven workflows. Verifiability means actions can be traced back to trusted network signals, identities or locations when needed. Policy control means the system can express intent in a form the network can understand and act on within defined limits. Context awareness means the network can contribute useful signals to help assess what is happening in real time. And service assurance means performance and reliability can be treated as part of the application promise, not just an invisible dependency.

In practice, that could mean helping autonomous drone operation maintain reliable connectivity with Quality on Demand, strengthening anti-fraud checks and bot screening during a sensitive transactions with security APIs, or giving a critical service session priority when performance matters. There is also a broader commercial opportunity here. If enterprises increasingly want AI services that are easy to buy, easy to govern and backed by clear service expectations, then programmable connectivity can become part of a more valuable enterprise service proposition rather than just a hidden technical component. That means Network as Code can support not only better execution, but also more adoptable AI-era services built around assurance, performance and trust.

Why agentic AI needs governed executionheader link

Trust and assurance become even more important with agentic AI. A system that plans, monitors and acts across workflows creates a different kind of challenge from a chatbot that simply generates text. The question is not only whether the AI gets things right, but whether its actions stay visible, controlled, and open to review. People lose trust quickly when software acts outside the expected scope, cannot explain what happened, or leaves others to piece failures together afterwards.

In such environment trust also becomes an infrastructure and service design question. If AI is going to operate in high-stakes settings, it needs an environment that supports the same four requirements: verifiability, policy control, context awareness and service assurance. It also needs governance around those capabilities, including clear ownership, oversight, and accountability when something goes wrong. Not perfectly, perhaps, but credibly enough for real enterprise adoption.

What next?header link

If the last decade was about connecting more people, devices and services, the next one may be about deciding how those connections should behave when software begins to act with greater autonomy. The question is no longer whether networks will become programmable. They already are. The question is how they can become verifiable, governable, context-aware and dependable enough that enterprises, developers and institutions are willing to build on them at scale. But trust also requires a human layer. AI is powerful, but relying on it without the right human oversight and governance introduces real risks. In the end, trust depends not only on technical safeguards, but also on understanding where AI is strong, where it is vulnerable, and where human judgment still needs to remain in the loop.

To summarize the key takeaway: Network as Code is not only about exposing network functions through APIs. It is also about giving developers and enterprises a more practical way to build trusted, policy-aware and commercially viable digital services on top of programmable connectivity. As this space evolves with AI, Network as Code may become one of the clearest ways to translate network programmability into something enterprises can adopt, govern, scale and ultimately trust.