Customized User Plane Processing via Code Generating AI Agents for Next Generation Mobile Networks

This paper investigates the use of generative AI agents to create on-demand, customized user plane processing blocks for 6G networks based on natural language requests, demonstrating that factors like model selection and prompt design significantly influence the accuracy of generating functional code for specific application needs.

The Gist

Imagine the mobile network (the internet in your pocket) as a massive, high-speed train system. In the past, the train cars (the data packets) could only do what the engineers built them to do: carry passengers, maybe stop at a few stations, and follow a fixed schedule. If a company wanted the train to do something new—like "sort passengers by their favorite color" or "deliver a special package only when it's raining"—they had to stop the whole system, call in a team of engineers, and physically rebuild the train cars. This takes time, money, and is very rigid.

This paper proposes a futuristic idea for 6G (the next generation of mobile networks): What if the train cars could rewrite their own instructions on the fly just by listening to a request?

Here is the breakdown of how the authors think this will work, using simple analogies:

1. The "Magic Chef" (The AI Agent)

In this new system, there is a special AI agent acting like a super-chef.

• The Order: A restaurant owner (a third-party app, like a video game or a smart factory) sends a text message to the chef: "I need a special sauce that only gets poured on spicy dishes, but only if the kitchen is busy."
• The Magic: Instead of the chef just guessing, they use a Generative AI. This AI doesn't just talk; it can write the actual recipe code (the instructions for the train car) instantly.
• The Result: The AI writes a new computer program (a "Customized Processing Block") that tells the network exactly how to handle that specific data.

2. The "Recipe Book" and "Examples" (Baseline Code & Prompts)

The authors tested how well this "Magic Chef" works. They found that the chef needs two things to get it right, especially for complex orders:

• The Recipe Book (Baseline Code): Imagine asking a chef to make a soufflé. If you give them a blank piece of paper, they might forget how to whisk eggs. But if you give them a "skeleton" recipe (a basic structure of how to make a soufflé), they just have to fill in the specific flavor. The paper found that giving the AI a code template (a skeleton) made it much less likely to make mistakes.
• The Examples (In-Context Learning): Sometimes, just giving a recipe isn't enough. You also need to show the chef, "Look, here is how we handled a similar order last Tuesday." The paper showed that providing examples of how to handle specific data packets helped the AI understand the logic better.

3. The "Test Kitchen" (The Experiment)

The researchers didn't just ask the AI to write code and hope for the best. They built a test kitchen:

• They gave the AI three different "orders" (protocols) ranging from simple to complex:
  1. Simple: "Sort packages by priority."
  2. Medium: "Sort packages by priority, but only if the network is crowded."
  3. Complex: "A subscription service where people can join or leave groups, and the system must remember who is in which group."
• They let the AI write the code, then ran the code with real data packets flying through it.
• They checked: Did the train stop at the right station? Did it drop the wrong package? Did it crash?

4. The Findings: "It Works, But You Need the Right Tools"

The results were exciting but had a catch:

• The Perfect Storm: When they used the smartest AI model available, gave it a recipe skeleton, and showed it examples, it got 100% of the orders right, even for the complex ones.
• The Slip-ups: When they removed the "recipe skeleton" or the "examples," or used a slightly older/slower AI model, the code started making mistakes.
  • Analogy: It's like asking a smart student to solve a math problem. If you give them the formula (skeleton) and a similar solved problem (example), they ace it. If you just say "solve this," they might forget a step or mix up the numbers.
• The Errors: The mistakes weren't usually "I don't know what a network is." They were small, specific errors like "I put the salt in before the flour" (wrong order of operations) or "I forgot to add the sugar" (missing a line of code).

Why Does This Matter?

Currently, if a new app needs a special feature (like a video game that needs ultra-low latency or a factory robot that needs a specific security check), the network is too rigid to adapt quickly.

This paper suggests that in the future (6G), networks will be like LEGO sets.

• A company says, "I need a block that does X."
• The AI instantly builds that specific block of code.
• The network snaps it into place, and suddenly, the network can do something it never did before, all without human engineers needing to rebuild the whole system.

In short: The paper proves that AI can write the "software instructions" for mobile networks on demand, but to make it reliable, we need to give the AI the right tools (templates and examples) and the smartest brain (the latest AI model) to do the job.

Technical Summary

1. Problem Statement

The paper addresses the challenge of achieving on-demand customization in next-generation (6G) mobile networks. Traditional networks rely on pre-defined, static processing blocks. However, vertical applications (e.g., industrial IoT, extended reality) often require unique, dynamic user-plane behaviors that standard network functions cannot natively support.

The core problem is how to translate human-readable service requests (describing custom protocols and logic) into executable network code that can be deployed immediately on user-plane nodes. While Large Language Models (LLMs) have shown promise in general code generation, their ability to generate functional, correct, and safe networking code for specific, complex protocol implementations has not been rigorously evaluated in a realistic deployment scenario. Existing evaluations often rely on semantic similarity to reference code, which fails to capture functional errors in packet processing.

2. Methodology

The authors propose a framework where Agentic AI interacts with the mobile core network to generate and deploy Customized Processing Blocks (CPBs).

A. System Architecture

The proposed framework consists of three main components within the mobile core:

1. Code Generation Agent (CGA): An LLM-powered agent that receives service requests from third-party applications (OTT) containing human-readable protocol descriptions. It generates executable Python code for the CPB.
2. Code Repository (CR): A centralized knowledge base (implemented as an MCP server) storing network-related code snippets, modules, and examples. It serves as a source for "baseline code" and in-context learning.
3. Target User Plane (UP) Node: The network node (e.g., a UPF or custom node) where the generated CPB is deployed to intercept and process data packets between the application server and User Equipment (UE).

B. Experimental Design

The study evaluates the CGA's performance using three distinct custom protocol use cases of increasing complexity:

1. Simple Transmission Protocol (STP): A First-Come-First-Served (FCFS) queue with priority-based admission.
2. Congestion-Control Protocol (CC): Adds dynamic logic where packet admission depends on real-time network congestion status (binary indicator) and priority.
3. Publish-Subscribe Protocol (Pub-Sub): A message broker handling SUBSCRIBE, UNSUBSCRIBE, and PUBLISH packets with state management and acknowledgments.

C. Evaluation Scenarios

The authors tested four scenarios to isolate the impact of different input factors:

• S1 (Baseline): Advanced Model (Gemini-2.5-flash) + Baseline Code + Examples in prompt.
• S2: Advanced Model + No Baseline Code + Examples.
• S3: Advanced Model + Baseline Code + No Examples.
• S4: Older Model (Gemini-2.0-flash) + Baseline Code + Examples.

D. Validation Approach

Instead of using code similarity metrics (e.g., BLEU or ROUGE), the authors employed functional validation:

1. Generated code is deployed on a physical host.
2. Transmitters send actual TCP packets to the CPB.
3. System logs are analyzed to verify if the CPB correctly binds to endpoints, parses packet formats, executes logic (e.g., queueing, discarding), and maintains state.
4. Runs are classified as PASS (100% functional correctness) or FAIL.
5. Errors are categorized using a taxonomy from prior work (e.g., Condition Errors, Reference Errors, Operation/Calculation Errors).

3. Key Contributions

• Novel Evaluation Framework: This is the first work to evaluate LLM code generation in networking based on functional correctness in a realistic deployment (packet transmission and logic execution) rather than static code similarity.
• Agentic AI for Network Automation: Demonstrates a viable architecture for "Network-as-Code," where AI agents dynamically generate and deploy user-plane processing logic based on natural language requests.
• Comprehensive Error Analysis: Provides a detailed taxonomy of failure modes in network code generation, identifying specific error types like "Incorrect Arithmetic Operation" in packet serialization and "Missing Conditions" in logic flows.
• Empirical Insights on Prompt Engineering: Quantifies the critical role of baseline code (structural support) and examples (procedural support) in achieving high-fidelity code generation for complex protocols.

4. Key Results

• Optimal Configuration (S1): Only the configuration using the advanced model (Gemini-2.5-flash) with both baseline code and examples achieved 100% success rate (20/20 passes) across all three protocols.
• Impact of Removing Support:
  • Removing Baseline Code (S2): Performance degraded, particularly for complex protocols (CC and Pub-Sub). Errors included missing statements, incorrect method calls, and wrong variable references.
  • Removing Examples (S3): Performance degraded significantly for complex logic. The model struggled with call sequences and state transitions, leading to missing conditions and arithmetic errors.
  • Model Capability (S4): Using the older model (Gemini-2.0-flash) resulted in widespread failures, primarily due to missing multiple statements and inability to handle multi-step logic.
• Complexity Sensitivity: Simple protocols (STP) were robust even with reduced inputs. However, as protocol complexity increased (CC, Pub-Sub), the system became highly sensitive to the absence of either baseline code or examples.
• Error Types: The most common errors in failure scenarios were Incomplete Code/Missing Statements (IC/MS) and Reference Errors (RE), indicating that without structural guidance, LLMs struggle to maintain the integrity of complex network logic.

5. Significance and Future Work

• Significance: The study validates that AI agents can act as "on-demand network function generators," enabling 6G networks to be highly adaptive and customizable. It proves that with the right prompt engineering (combining baseline code and examples) and model selection, LLMs can generate functional network code that operates correctly in real-world packet flows.
• Future Work: The authors plan to:
  • Fine-tune specialized models (e.g., Code Llama, Qwen3-Coder) on network-specific datasets.
  • Investigate the specific impact of fine-tuning on telecom code generation accuracy.
  • Expand the scope to include more complex network control tasks beyond user-plane processing.

In conclusion, the paper establishes a foundational step toward fully autonomous mobile networks, where the gap between application requirements and network implementation is bridged by code-generating AI agents.