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

Dit artikel onderzoekt hoe generatieve AI-agenten via codegeneratie op maat gemaakte gebruikersplane-verwerkingsblokken kunnen creëren voor verticale applicaties in 6G-netwerken, waarbij de nauwkeurigheid wordt beïnvloed door factoren zoals modelkeuze en promptontwerp.

De kern

Stel je voor dat het mobiele netwerk van de toekomst (6G) niet langer een stijve, starre machine is, maar meer lijkt op een slimme, aanpasbare keuken.

In het huidige netwerk (zoals 5G) zijn de "recepten" voor het verwerken van data al vastgelegd. Als een app een nieuw soort gerecht wil serveren, moet de kok (het netwerk) eerst wachten tot iemand een heel nieuw receptboek schrijft en de keuken volledig verbouwt. Dat duurt lang en is niet flexibel.

Deze paper beschrijft een revolutionaire nieuwe manier: AI-agenten die op het moment zelf nieuwe recepten kunnen schrijven en koken.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Idee: Van "Vaste Menukaart" naar "Op Maat Gekookt"

Stel je voor dat je een restaurant hebt dat gespecialiseerd is in mobiele netwerken. Vroeger kon je alleen bestellen uit een vaste menukaart (standaard protocollen).
Nu, met deze nieuwe technologie, kun je tegen de chef-kok (de AI-agent) zeggen: "Ik wil een gerecht dat eerst de ingrediënten sorteert op kleur, en als het rood is, het direct naar de tafel stuurt, maar als het blauw is, het eerst wast."

In plaats van dat de chef moet zoeken in een boek, schrijft de AI-agent direct het recept (de code) voor dit specifieke gerecht. Hij bouwt een nieuw "kookblok" (een Customized Processing Block) dat precies doet wat jij vraagt, en plaatst dit direct in de keuken (het mobiele netwerk).

2. Hoe werkt dit in de praktijk?

De auteurs van het paper hebben een systeem getest dat er als volgt uitziet:

• De Klant (De App): Een bedrijf of gebruiker stuurt een tekstje: "Verwerk deze data-pakketjes zo..." (bijvoorbeeld: "Doe alleen iets als het netwerk druk is").
• De Chef (De AI-Agent): Deze agent leest het tekstje. Hij kijkt in zijn kookboek (de Code Repository) voor bestaande technieken (zoals hoe je een pakketje opent).
• Het Schrijven van het Recept: De agent schrijft een stukje computercode (in Python) dat precies doet wat de klant vraagt.
• Het Koken (Uitvoering): Dit nieuwe stukje code wordt direct geactiveerd in het netwerk. Het begint nu echt data-pakketjes te verwerken volgens de nieuwe regels.

3. De Proef: Koken met Drie Verschillende Recepten

Om te zien of dit echt werkt, hebben de onderzoekers drie verschillende "recepten" (protocollen) getest:

1. Het Simpele Recept (STP): "Sorteer de pakketjes op prioriteit." (Net als een rij bij de kassa: wie eerst komt, krijgt eerst bediend).
2. Het Drukke Recept (CC): "Als de keuken vol is (congestie), wees streng en gooi minder belangrijke pakketjes weg."
3. Het Complexe Recept (Pub-Sub): Een systeem waar mensen zich kunnen abonneren op nieuws. "Als iemand 'Nieuws' abonneert, stuur alles over dat onderwerp naar hen."

4. Wat leerden ze? (De Resultaten)

De onderzoekers ontdekten dat de AI-agenten heel goed kunnen koken, MAAR alleen als ze de juiste hulpmiddelen hebben. Het was als een kookwedstrijd met vier verschillende scenario's:

• Scenario 1 (De Sterke Chef + Het Receptboek + Voorbeelden):
  De AI kreeg de nieuwste, slimste robot (het model Gemini-2.5), een basisrecept (basiscode) en voorbeelden van hoe het moet.

  • Resultaat: 100% succes. De AI schreef perfecte code die precies deed wat er gevraagd werd.

• Scenario 2 (Geen Receptboek):
  De AI kreeg geen basisrecepten om op te bouwen. Hij moest alles uit het hoofd bedenken.

  • Resultaat: Het ging mis. De AI vergat stappen of deed dingen in de verkeerde volgorde. Zonder basis was het te moeilijk.

• Scenario 3 (Geen Voorbeelden):
  De AI had het receptboek, maar geen voorbeelden van hoe het eruit moest zien.

  • Resultaat: Ook hier ging het mis, vooral bij de complexere recepten. De AI wist wat er moest gebeuren, maar niet hoe het technisch moest worden uitgevoerd.

• Scenario 4 (De Oude Chef):
  Ze gebruikten een oudere, minder slimme AI (Gemini-2.0).

  • Resultaat: Rampzalig. De oude chef kon de complexe logica niet volgen en maakte overal fouten.

5. De Conclusie in Eén Zin

Als je een slimme AI geeft, voorbeelden van hoe het moet, en een basisstructuur om op te bouwen, dan kan het mobiele netwerk van de toekomst op verzoek nieuwe functies creëren.

Waarom is dit cool?
Stel je voor dat je een nieuwe game lanceert die heel specifieke netwerkeisen heeft. In plaats van jaren te wachten tot telecombedrijven hun hele netwerk updaten, kun je tegen de AI zeggen: "Maak een functie die deze game-pakketjes prioriteit geeft." De AI schrijft het in seconden, en het netwerk past zich direct aan.

Het maakt het mobiele internet niet alleen sneller, maar ook slimmer en aanpasbaar, net als een keuken die zich aanpast aan wat je vandaag wilt eten, in plaats van alleen wat er in de koelkast staat.

Technische samenvatting

Probleemstelling

De zesde generatie (6G) mobiele netwerken vereisen een hoger niveau van autonomie, flexibiliteit en aanpassingsvermogen dan voorgaande generaties. Een centrale uitdaging is het bieden van maatwerk connectiviteitsdiensten voor verticale toepassingen (zoals industriële IoT, XR, etc.). Traditioneel moeten netwerkfuncties vooraf worden geprogrammeerd en geïmplementeerd, wat traag en inflexibel is.

Het paper adresseert het probleem van het op afroep genereren van nieuwe, aangepaste verwerkingsblokken voor het gebruikersvlak (User Plane) op basis van tekstuele service-aanvragen. De kernvraag is of Generatieve AI (specifiek Large Language Models of LLMs) in staat is om correcte, uitvoerbare code te genereren die complexe netwerkprotocollen interpreteert en packetverwerking logisch implementeert, zonder dat deze functionaliteit vooraf in het netwerk is gedefinieerd.

Methodologie

1. Systeemarchitectuur:
De auteurs stellen een framework voor dat bestaat uit drie hoofdcomponenten binnen het mobiele kernnetwerk:

• Code Generation Agent (CGA): Een AI-agent die service-aanvragen van derde partijen (OTT-applicaties) ontvangt, die een menselijk leesbare protocolbeschrijving bevatten. De CGA genereert de benodigde code.
• Code Repository (CR): Een centrale kennisbank met netwerkgerelateerde codefragmenten, modules en voorbeelden die de agent kan ophalen voor "in-context learning".
• Doel-User Plane (UP) Node: Het netwerkknelpunt waar de gegenereerde code wordt gedeployeerd om daadwerkelijke data-pakketten te verwerken.

2. Prompt Design en Input:
De agent ontvangt een prompt die bestaat uit:

• Een protocolbeschrijving in natuurlijke taal (definiërend syntax, semantiek, tijdsvolgorde en acties).
• Baseline code: Bestaande codefragmenten uit de CR die als skelet of referentie dienen.
• Voorbeelden: Specifieke voorbeelden van state-action paren of packet-structuren om het model te helpen de logica te begrijpen.

3. Experimenteel Ontwerp:
De auteurs voeren een case study uit met drie protocolgebruiksscenario's van toenemende complexiteit:

• STP (Simple Transmission Protocol): Een FCFS-wachtrij met prioriteitsschakeling.
• CC (Congestion-Control Protocol): Voegt dynamische congestie-indicatie toe die de prioriteitslogica beïnvloedt.
• Pub-Sub Protocol: Een complexer publish-subscribe broker met subscribe, unsubscribe en publish berichten.

4. Evaluatiemethode:
In tegenstelling tot eerdere werken die zich baseerden op semantische gelijkenis met een referentiecode, gebruiken de auteurs een functionele validatie:

• De gegenereerde Python-code wordt uitgevoerd op een fysieke host.
• Er worden daadwerkelijke TCP-pakketten verzonden en ontvangen.
• Logs worden geanalyseerd om te controleren of de code succesvol draait, correcte endpoints bindt, pakketten in het juiste formaat uitwisselt en de protocollogica correct uitvoert.
• Resultaten worden geclassificeerd als PASS (volledige overlap met verwachte gedrag) of FAIL.
• Fouten worden gecategoriseerd volgens een bestaande taxonomie (bijv. Condition Errors, Constant Value Errors, Operation Errors).

5. Variabelen:
Vier scenario's worden getest om de impact van verschillende factoren te isoleren:

• S1: Model (Gemini-2.5-flash) + Baseline code + Voorbeelden.
• S2: Geen baseline code.
• S3: Geen voorbeelden in de prompt.
• S4: Oudere model (Gemini-2.0-flash) + Baseline + Voorbeelden.

Belangrijkste Resultaten

• Optimale Configuratie (S1): Alleen de configuratie met het nieuwste model (Gemini-2.5-flash), inclusief zowel baseline code als voorbeelden, leverde 100% succes (20/20 passes) voor alle drie de protocollen.
• Impact van Baseline Code: Het verwijderen van de baseline code (S2) leidde tot een significante daling in prestaties, vooral bij complexere protocollen (CC en Pub-Sub). De fouten bestonden voornamelijk uit ontbrekende statements en verkeerde methoderoepingen.
• Impact van Voorbeelden: Het verwijderen van voorbeelden (S3) resulteerde ook in meer fouten, met name bij het begrijpen van call-sequenties en state-transities (bijv. verkeerde arithmetische operaties of ontbrekende voorwaarden).
• Impact van Modelcapaciteit: Het gebruik van een minder geavanceerd model (Gemini-2.0-flash in S4) leidde tot wijdverspreide mislukkingen, vooral bij complexe protocollen. Dit toont aan dat het vermogen tot meervoudige logische redenering cruciaal is.
• Foutpatronen:
  • Bij het simpele STP-protocol waren fouten beperkt en lokaal.
  • Bij complexere protocollen (Pub-Sub) zonder ondersteuning (baseline/voorbeelden) of met een zwakker model, ontstonden fundamentele fouten zoals ontbrekende codeblokken, verkeerde variabelen en incorrecte serialisatie van pakketvelden.

Bijdragen

1. Eerste Functionele Evaluatie: Dit is, naar weten van de auteurs, het eerste werk dat de prestaties van LLMs voor netwerktaken evalueert op basis van functionele correctheid in een realistische deployment-scenario, in plaats van alleen code-gelijkenis.
2. Framework voor Op-Afroep Netwerkverwerking: Het paper introduceert een werkend architectuurconcept waarbij AI-agenten dynamisch verwerkingsblokken genereren voor het gebruikersvlak op basis van natuurlijke taal.
3. Inzicht in Prompt Engineering voor Netwerken: De studie identificeert dat voor complexe netwerktaken zowel structuur (baseline code) als procedurale kennis (voorbeelden in de prompt) noodzakelijk zijn voor succesvolle codegeneratie.
4. Fouttaxonomie: Het biedt een gedetailleerde analyse van de typen fouten die LLMs maken bij het genereren van netwerkcode (bijv. verkeerde packet-serialisatie, ontbrekende state-management).

Betekenis en Toekomstperspectief

De bevindingen suggereren dat AI-agenten, onder de juiste omstandigheden (goed modelkeuze, zorgvuldig prompt-design met voorbeelden en baselines), in staat zijn om nieuwe netwerkcapaciteiten op afroep te genereren. Dit is een fundamentele stap richting autonome en zelfoptimaliserende 6G-netwerken.

De auteurs concluderen dat dit onderzoek een nieuw niveau van maatwerk mogelijk maakt, waarbij verticale toepassingen hun eigen netwerkgedrag kunnen definiëren zonder handmatige programmering door netwerkoperatoren. Voor de toekomst plannen de auteurs het fine-tunen van specifieke coderingsmodellen (zoals Code Llama of Qwen3-Coder) op netwerkspecifieke datasets om de nauwkeurigheid verder te verhogen en de afhankelijkheid van handmatige prompts te verminderen.