Utility Function is All You Need: LLM-based Congestion Control

This paper introduces GenCC, a framework that leverages large language models to automatically design optimized congestion control utility functions, achieving performance improvements of 37% to 142% over state-of-the-art protocols by utilizing generative code evolution or mathematical chain-of-thought strategies.

The Gist

Imagine the internet as a massive, global highway system. For decades, the rule of the road has been "first come, first served," but with a catch: if the highway gets too crowded, everyone slows down together to prevent a total gridlock. This is how traditional Congestion Control works. It's like a traffic cop who tells every driver to slow down equally when traffic gets heavy, hoping everyone gets to their destination eventually.

However, the modern internet isn't just about one type of traffic anymore. It's a chaotic mix of:

• Video calls (which need to be smooth and lag-free, like a limousine).
• 4K movie streams (which need huge amounts of data but can tolerate a slight delay, like a cargo truck).
• IoT sensors (which send tiny bits of data but need to be reliable, like a bicycle messenger).

The problem is that the old "one-size-fits-all" traffic rules don't work well when a limousine, a cargo truck, and a bicycle are all fighting for space on the same road. The current "smart" traffic systems try to solve this by using complex mathematical formulas (called Utility Functions) to decide who gets how much road space. But writing these formulas is incredibly hard. It's like trying to write a single rulebook that perfectly satisfies a Formula 1 racer, a delivery driver, and a tourist, all while the road conditions change from rain to snow to a festival.

The New Solution: GenCC and the "AI Architect"

This paper introduces GenCC, a new framework that uses Large Language Models (LLMs)—the same kind of AI that writes code and answers questions—to act as an AI Architect for these traffic rules.

Instead of human researchers spending years trying to tweak a mathematical formula by hand, GenCC asks the AI: "Here is a specific road scenario with a video stream and a sensor. Please write the perfect traffic rule (code) to make sure everyone gets where they need to go efficiently."

How It Works: The "Try, Test, and Improve" Loop

The researchers didn't just ask the AI once and hope for the best. They built a cycle that works like a video game level designer:

1. The Prompt (The Brief): They tell the AI the specific problem (e.g., "We have a slow satellite connection and a fast video call").
2. The Generation (The Draft): The AI writes a new piece of code (a new traffic rule).
3. The Testbed (The Simulation): They run this new rule in a realistic digital highway simulator. They see what happens: Did the video call freeze? Did the sensor get stuck?
4. The Feedback (The Coach):
   • Zero-Shot: The AI guesses once based on the prompt.
   • One-Shot: The AI looks at an existing "good" rule and tries to copy it.
   • Evolutionary (The Best Approach): The AI looks at the worst part of the previous attempt (e.g., "The video call was still lagging") and tries to fix just that in the next version. It's like a coach saying, "Your defense was great, but your offense is weak. Let's practice offense."
   • Math-CoT (Chain of Thought): The AI is asked to "think step-by-step" about the math before writing the code, ensuring the logic is sound.

The Results: Smarter Traffic, Faster Roads

The researchers tested this on real-world scenarios, including:

• Broadband: Your home internet.
• Cellular: 5G mobile networks.
• Satellite: Slow, high-delay connections (like Starlink or old satellite dishes).

The findings were surprising:

• The AI got it right: In many cases, the AI-generated rules were 37% to 142% better than the best human-designed rules currently in use.
• Less is more: Surprisingly, giving the AI a "reference example" of a good rule (One-Shot) actually made it worse at solving new problems. It was like giving a chef a recipe for soup and asking them to make a cake; they got stuck trying to copy the soup. It was better to just give them the ingredients and let them figure it out (Zero-Shot) or let them iterate based on mistakes (Evolutionary).
• Thinking helps: When the AI was forced to explain its math logic before writing the code (Math-CoT), it produced much more stable and effective rules.

The Big Picture

Think of this paper as the moment we stopped trying to manually tune every radio station on a car and instead gave the car a self-driving AI that learns the perfect settings for every road it drives on.

GenCC proves that we don't need to be the world's best mathematicians to solve internet congestion anymore. We just need to build a system that lets AI write the code, test it, learn from its mistakes, and write it again until it's perfect. This means faster video calls, smoother gaming, and a more reliable internet for everyone, regardless of whether they are on a fiber line or a satellite dish.

Technical Summary

Here is a detailed technical summary of the paper "Utility Function is All You Need: LLM-based Congestion Control" by Neta Rozen-Schiff, Liron Schiff, and Stefan Schmid.

1. Problem Statement

Congestion control (CC) is a fundamental challenge in communication networks, particularly as modern applications demand heterogeneous Quality of Service (QoS) (e.g., low latency for control channels vs. high bandwidth for 4K video).

• Limitations of Current Protocols: Traditional CC protocols (e.g., CUBIC, BBR) and recent online learning approaches (e.g., Proteus, Hercules) rely on utility functions to guide sending rates. These functions map network feedback (loss, latency) to a sending rate strategy.
• The Core Issue: Designing a single utility function that performs optimally across diverse network conditions (satellite, cellular, broadband) and heterogeneous application requirements is extremely difficult. Existing methods often require rigorous mathematical analysis and manual parameter tuning, which limits adaptability. Furthermore, assuming a single utility function fits all scenarios is often suboptimal.
• The Opportunity: Large Language Models (LLMs) have demonstrated strong capabilities in code generation and mathematical reasoning. The authors propose leveraging LLMs to automatically generate the most suitable utility function for specific network scenarios, moving beyond simple parameter tuning to full function synthesis.

2. Methodology: The GenCC Framework

The authors introduce GenCC, a framework that integrates LLMs with a realistic network testbed to generate, compile, and evaluate congestion control utility functions.

A. Architecture

GenCC operates via a cyclic pipeline:

1. Guidance Module: Formulates prompts for the LLM based on specific strategies (detailed below).
2. Function Generator: Invokes an LLM (GPT-5 in experiments) to generate C++ code for the utility function. The function takes inputs like current rate ($x$), loss rate ($L$), RTT gradient, and variance.
3. Protocol Compiler: Integrates the generated function into an existing CC protocol stack (based on the Proteus implementation). The utility function is treated as a modular "black box," allowing rapid replacement without altering the core protocol logic.
4. Network Testbed: Executes the compiled protocol in controlled environments (cloud instances and "in-the-wild" connections) to measure performance metrics (throughput, latency, loss).
5. Feedback Loop: Performance data is fed back to the Guidance module to refine the next generation of prompts or select the best function.

B. Guidance Strategies

The paper evaluates four distinct prompting strategies to guide the LLM:

1. Zero-shot: A simple prompt requesting a utility function for congestion control without examples.
2. One-shot: Provides the state-of-the-art Hercules utility function as a reference example for the LLM to improve upon.
3. Math-CoT (Chain-of-Thought): Extends the zero-shot prompt by explicitly asking the LLM to elaborate on the mathematical properties and analytical steps of the desired function (e.g., defining variable meanings and gradients).
4. Evolve (Evolutionary): An iterative process where the LLM is provided with the best-performing function found so far and its specific performance metrics (specifically the "least satisfied" connection requirement). The LLM is tasked with improving this specific function to address its weaknesses.

3. Key Contributions

1. Novel Framework (GenCC): A system that combines LLM code generation with network simulation to automatically design utility-based CC protocols tailored to specific scenarios.
2. Guidance Strategy Analysis: A comparative study of different LLM prompting techniques (Zero-shot, One-shot, Math-CoT, Evolve) to determine which yields the most stable and performant protocols.
3. Open Infrastructure: The release of GenCC as an open-source benchmark for evaluating LLMs in networking tasks, supporting both local and cloud-based testing.
4. Performance Validation: Demonstration that LLM-generated protocols can significantly outperform state-of-the-art human-designed protocols in heterogeneous environments.

4. Experimental Results

The evaluation was conducted across three network scenarios (Satellite, Cellular, Broadband) and an "in-the-wild" scenario, using five heterogeneous connections with varying bandwidth requirements.

• Performance Gains:
  • The Evolve and Math-CoT strategies significantly outperformed the state-of-the-art Hercules protocol.
  • Improvements: 142% in Broadband, 67% in Satellite, and 37% in Cellular scenarios.
  • Overall, LLM-guided protocols improved throughput by 37% to 142% depending on the scenario.
• Strategy Comparison:
  • Best Performers: Evolve and Math-CoT consistently achieved the highest performance and stability.
  • Worst Performer: Surprisingly, the One-shot strategy (providing a reference function) performed the worst, often underperforming even the Zero-shot approach. This suggests that providing a fixed reference can lead to "overfitting" or instability in the generated code.
  • Convergence: The best-performing strategies reached their peak performance within 10 trials, whereas One-shot required ~20 generations.
• Code Validity:
  • Under Evolve and Math-CoT, 100% of generated functions were valid and compiled successfully.
  • One-shot and Zero-shot had minor invalidity rates (1–2%).
  • A lightweight open-source model (GPT-OSS-20B) failed to compile ~80% of outputs, highlighting the need for high-capability models.
• Cross-Scenario Generalization:
  • Functions generated for one scenario (e.g., Satellite) retained ~90% of optimal performance when tested on other scenarios (Cellular/Broadband) when using Evolve or Math-CoT, demonstrating good generalizability.
• Fairness: All generated protocols maintained fair bandwidth sharing between connections with identical requirements.

5. Significance and Conclusion

This paper establishes that LLMs are a viable and powerful tool for automating the design of network protocols.

• Paradigm Shift: It moves congestion control design from manual, math-heavy engineering to an automated, data-driven generation process.
• Context Awareness: By generating utility functions specific to network context (latency, loss, application needs), GenCC solves the "one-size-fits-all" limitation of current protocols.
• Critical Insight: The study reveals that more context is not always better. Simply providing a reference function (One-shot) can degrade performance, whereas guiding the LLM with mathematical reasoning (CoT) or evolutionary feedback (Evolve) yields superior results.
• Future Impact: GenCC provides a blueprint for using AI to adapt network protocols dynamically to heterogeneous traffic and changing network conditions, potentially leading to more resilient and efficient internet infrastructure.