Mplify launches Kylie SDK with MCP integration to accelerate AI-powered service automation
Network automation has always been a massive technical challenge for digital service providers around the world. Connecting different domains, carriers, and platforms into a seamless, intelligent workflow demands far more than simply exposing a handful of programming interfaces. It requires standardization, interoperability, and increasingly, the ability to let artificial intelligence systems act directly on that infrastructure.
Mplify, the global alliance bringing together networking, cloud, cybersecurity, and enterprise technology organizations focused on accelerating the digital economy, just took a very concrete step in that direction with the launch of the Kylie SDK. This new release comes with an addition that makes a real difference in practice: support for MCP, the Model Context Protocol, integrated directly into the platform’s LSO APIs (Lifecycle Service Orchestration APIs).
In practical terms, this means AI agents and large language models — commonly known as LLMs — can now communicate directly with network infrastructure without needing complicated middleware layers custom-built for each scenario.
The result is a much shorter bridge between automated decision-making and the actual execution of services in multi-provider, multi-domain environments. With this, service providers gain the ability to automate, monetize, and scale digital services across globally interconnected ecosystems far more efficiently.
In the following sections, you will learn what changed with this release, what the core features are, why it matters, and where Mplify is heading with all of this. 🚀
What is the Kylie SDK and why it matters right now
The Kylie SDK is the software development kit maintained by Mplify to streamline integration with LSO APIs, the standardized interfaces used to manage network services across different providers and technology domains. These APIs follow Mplify’s own open standards and cover critical functions like provisioning, monitoring, billing, and orchestrating services in complex environments. The SDK exists so developers do not have to build all the communication logic with these interfaces from scratch, speeding up the development of automation solutions on top of this infrastructure.
What makes the new release especially relevant is the addition of native support for MCP, the Model Context Protocol. This protocol, which has been gaining significant attention in the artificial intelligence world, was created to standardize how language models and AI agents connect to external tools and systems. Instead of each integration requiring a custom, one-off solution, MCP provides a common communication layer that any compatible agent can use to interact with APIs, databases, and services. This drastically reduces integration effort and opens the door for AI systems to operate with much greater autonomy within enterprise and telecom environments.
Receive the best innovation content in your email.
All the news, tips, trends, and resources you're looking for, delivered to your inbox.
By subscribing to the newsletter, you agree to receive communications from Método Viral. We are committed to always protecting and respecting your privacy.
As Pascal Menezes, Mplify’s CTO, pointed out, this release marks an important milestone in the alliance’s mission to simplify collaboration across network, cloud, and cybersecurity ecosystems. By combining standardized LSO APIs with MCP support, Mplify enables AI agents and LLMs to interact more directly with network infrastructure, helping providers reduce service complexity, accelerate decision-making, and advance toward autonomous operations.
With the Kylie SDK supporting MCP directly on the LSO APIs, the landscape shifts quite significantly. Developers and systems architects can now connect AI agents to telecom networks using a standardized protocol, without having to create manual bridges or continuously adapt code for each new provider or environment. This is a real step forward in terms of interoperability and development speed — two areas that have historically slowed down the adoption of large-scale automation solutions in the networking sector. 🎯
How MCP transforms the relationship between AI and network infrastructure
To understand the impact of MCP in this context, it helps to take a step back and think about how AI agents work when they need to interact with external systems. Until recently, each integration was essentially a standalone project: you had to map out API endpoints, understand data formats, create specific functions, and make sure the language model knew when and how to use each of those functions. The process worked, but it was slow, expensive, and hard to scale. Every time a new system entered the ecosystem, all that work had to be redone or adapted, creating a significant bottleneck for engineering teams.
The Model Context Protocol was designed to solve exactly this problem. With MCP, any system that implements the protocol automatically becomes accessible to any AI agent that is also MCP-compatible. Think of it as creating a common language between the tools and the models that need to use them, eliminating the need for custom translators for every possible combination. In the telecom and enterprise networking world, where the diversity of providers, technologies, and standards is enormous, this standardization is invaluable for anyone who needs to build solutions that actually work in production.
When Mplify’s Kylie SDK starts offering MCP support on its LSO APIs, it is essentially inviting all MCP-compatible AI agents to interact directly with the network infrastructure managed by these interfaces. An agent could, for example, identify a traffic anomaly, query the monitoring API, decide to adjust a network route, and execute that change — all autonomously, without human intervention at each step. This kind of automated workflow, which previously required a lot of custom engineering, now becomes much more accessible and replicable across different environments and providers. 🤖
Key features of the Kylie SDK release
The launch of the Kylie SDK is not limited to MCP support alone. Mplify introduced a robust set of updates and tools that, together, make this one of the most comprehensive releases the alliance has ever delivered. Packages have been updated across multiple Interface Reference Points (IRPs), ensuring solid support for both business and operational functions.
Among the highlights:
- AI-native LSO APIs: Full MCP support across the entire LSO API portfolio enables direct integration with AI-powered orchestration and diagnostics tools.
- LSO Business APIs: Updated LSO Sonata and Cantata SDKs simplify business processes between providers — such as orders, quotes, and billing — making automated transactions easier in multi-provider ecosystems.
- LSO Operational APIs: Improvements in LSO Allegro, Interlude, and Legato strengthen service provisioning, performance monitoring, and fault management with standardized interfaces.
- Standardized product schemas: Published standards now include IP and Carrier Ethernet, including Subscriber Ethernet and Access E-Line, with support for product, service, and OAM (Operations, Administration, and Maintenance) payloads.
These features are available through the LSO Marketplace, which serves as the centralized access point for all of these capabilities. It provides a unified resource that powers end-to-end MCP-to-LSO conversion, along with access to the latest APIs, payloads, and developer guides.
The LSO API Blending Tool: combining APIs with product payloads
One of the most significant additions in the Kylie SDK release is the LSO API Blending Tool. This tool allows users to combine LSO APIs with specific product payloads, including IP, Carrier Ethernet, and a wide range of pre-standard payloads such as wavelengths, AI data center exchange cross-connects, CAMARA Quality on Demand, and SD-WAN.
The big differentiator of the Blending Tool is its ability to automatically generate Mplify MCP servers with full payload support. This enables end-to-end conversion from MCP commands to LSO APIs in a fully integrated, seamless way. In practice, AI agents can discover and execute complex network tasks across standardized and emerging service types with high precision, while the integration complexity for AI-enabled operations is drastically reduced.
This tool is particularly valuable for organizations working with multiple service types that need the flexibility to combine different payloads without rebuilding integrations from scratch for every new requirement. It is the kind of resource that, in the day-to-day work of engineering teams, saves weeks of effort in scenarios that previously demanded highly customized development. ⚙️
LSO APIs: the backbone of multi-domain automation
LSO APIs, short for Lifecycle Service Orchestration APIs, are a set of open, standardized interfaces developed and maintained by Mplify with the goal of covering the entire lifecycle of network services. This includes everything from quoting and ordering a new service, through provisioning and activation, to continuous monitoring, performance management, and service decommissioning when needed. The core idea behind LSO APIs is to create a common language between different service providers, carriers, and technology partners, allowing distinct systems to communicate and cooperate without each one needing to know the internal details of the others.
The big challenge that LSO APIs address is fragmentation. In multi-provider, multi-domain environments — which are the reality for most large enterprises and telecom operators today — each partner may use different systems, with distinct data formats and proprietary business logic. Without a standardization layer, any attempt at automation turns into a never-ending integration project, full of special cases and exceptions. LSO APIs eliminate much of this complexity by defining clear interface contracts that any participant in the ecosystem can implement and consume, regardless of the internal technology each one uses.
With the Kylie SDK now connecting these APIs to the MCP universe, LSO APIs take on an entirely new dimension. They are no longer just interfaces for traditional OSS and BSS systems — they become tools directly accessible to artificial intelligence agents. This means the same infrastructure that operators already use to manage their services can now be triggered by language models and AI systems in a standardized and secure way. Mplify is essentially making artificial intelligence a first-class citizen within the network automation ecosystem, and that has profound implications for how digital services will be managed in the years ahead. 🌐
What changes in practice for developers and systems architects
For those working day to day building automation solutions for networking and telecom, the launch of the Kylie SDK with MCP support represents a very concrete shift in workflow. Previously, integrating an AI agent with Mplify’s LSO APIs required significant effort in mapping capabilities, creating call functions, and continuously maintaining those integrations as the APIs evolved. With native MCP support, the SDK now automatically exposes LSO API capabilities in a format that protocol-compatible agents can discover and use without extensive manual configuration. This cuts development time from weeks to days in many scenarios.
Beyond reducing integration effort, MCP support in the Kylie SDK brings important gains in terms of maintainability and system evolution. When LSO APIs are updated or new capabilities are added, the SDK can reflect those changes in a way that AI agents discover them automatically, without the need to manually rewrite tool definitions for each update. This is especially relevant in a dynamic ecosystem like telecom, where new standards and requirements emerge frequently and the ability to quickly adapt automation solutions is a real competitive advantage for operators and service providers.
From an architectural standpoint, the integration between the Kylie SDK, MCP, and LSO APIs opens the door to more sophisticated design patterns in network automation solutions. It is possible, for example, to build systems where multiple specialized AI agents collaborate with each other, each responsible for a specific network domain, all of them accessing the underlying infrastructure through the same standardized protocol. This multi-agent approach, which is becoming increasingly common in enterprise AI system development, finds in LSO APIs exposed via MCP a solid and interoperable foundation to run in real production environments with all their reliability and performance requirements.
Next steps: the Lana release and the road toward autonomous networks
The launch of MCP support in the Kylie SDK is not an isolated move. It is part of a broader strategy by Mplify to position its LSO APIs as the central infrastructure for the next generation of network automation — a generation that places artificial intelligence at the core of telecom operations. The alliance has been continuously investing in expanding the scope of LSO APIs, covering new technology domains and new use cases, and adding MCP as an access protocol for AI agents is a clear signal that Mplify is closely tracking trends in the AI industry and positioning itself to stay relevant in this new landscape.
Following the Kylie release, Mplify is already accelerating its roadmap toward fully autonomous networks. The next major milestone is the Lana release, scheduled for late 2026, which will introduce an expanded set of AI-based assets and capabilities across the entire LSO ecosystem. While specific details have not yet been widely disclosed, the expectation is that the Lana release will deepen the integration between intelligent agents and network infrastructure even further, expanding the level of operational autonomy available to service providers.
The direction this initiative points toward is one of increasingly autonomous networks, where human intervention focuses on defining high-level objectives and policies while AI agents handle real-time operational execution. With LSO APIs accessible via MCP through the Kylie SDK, Mplify is creating the technical conditions for this kind of autonomous operation to be viable in real production environments, with all the security, reliability, and auditability requirements that the telecom industry demands. This is not science fiction — it is a natural evolution happening right now, and this launch is a concrete milestone on that path.
For service providers, carriers, and enterprises that depend on complex network infrastructures, keeping an eye on what Mplify is building with the Kylie SDK and MCP is increasingly relevant. The standardization that LSO APIs offer, combined with the accessibility that the Model Context Protocol brings to AI agents, creates an ecosystem where intelligent network automation shifts from being a long-term, hard-to-execute project to something much more achievable in the short and medium term. And honestly, that is a change the industry has been waiting for quite a while. 🚀
