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

📝 Paper Summary

AI-driven Networking Congestion Control Code Generation

GenCC utilizes Large Language Models within an evolutionary feedback loop to automatically generate and refine C++ utility functions for congestion control protocols, optimizing for specific network conditions and application requirements.

Core Problem

Modern applications impose conflicting network requirements (e.g., low latency vs. high bandwidth) that single, fixed utility functions in existing congestion control protocols cannot satisfy without complex, manual parameter tuning.

Why it matters:

Emerging applications like 4K video conferencing require simultaneous high bandwidth and low latency, which traditional TCP-friendly protocols fail to deliver
Current state-of-the-art learning-based protocols (e.g., Proteus, Hercules) rely on carefully engineered utility functions that do not adapt well to dynamic, heterogeneous environments like 5G or satellite links

Concrete Example: In interactive video services, the control channel needs low latency while the video stream needs high bandwidth. A standard CC protocol with a fixed utility function might optimize for throughput, causing lag in the control channel, or optimize for latency, degrading video quality. GenCC generates a function specifically balancing these based on observed performance.

Key Novelty

GenCC (Generative Congestion Control Framework)

Replaces manual mathematical derivation of utility functions with an automated LLM-driven evolutionary process
Closes the loop between code generation and real-world performance by testing generated C++ functions in a network testbed and feeding performance metrics back to the LLM for refinement

Evaluation Highlights

Achieves up to 2.4x (142%) throughput improvement over the state-of-the-art Hercules protocol in broadband scenarios
Outperforms Hercules by 37% in cellular (5G-like) scenarios and 67% in satellite scenarios using the 'Evolve' guidance strategy
Leading strategies (Evolve and Math-CoT) reach near-optimal performance within 10 generation trials per scenario

Breakthrough Assessment

8/10

Significantly outperforms SOTA by treating protocol design as a code-generation search problem. The shift from manual tuning to LLM-driven evolutionary design for core networking components is a strong methodological advance.

⚙️ Technical Details

Problem Definition

Setting: Distributed congestion control where senders must independently adjust rates to maximize a utility function based on local feedback

Inputs: Network feedback statistics: Loss rate (L), RTT, d(RTT)/dt, RTT variance, current sending rate (x), and min/max requirements (a, b)

Outputs: Next interval sending rate r_{t+1} (computed via the gradient of the generated utility function)

Pipeline Flow

Guidance Module (Prompt Engineering)
Function Generator (LLM Inference)
Protocol Compiler (C++ Integration)
Network Testbed (Performance Eval)

System Modules

Guidance Module

Constructs prompts based on strategy (Zero-shot, One-shot, Math-CoT) and evolutionary feedback

Model or implementation: N/A (Logic component)

Function Generator

Generates the C++ implementation of the utility function

Model or implementation: GPT-5

Protocol Compiler

Integrates generated utility function into the Hercules/Proteus client codebase and compiles binaries

Model or implementation: C++ Compiler (implied)

Network Testbed

Executes the binary under constrained network conditions to measure performance

Model or implementation: Linux tc (Traffic Control)

Novel Architectural Elements

Feedback loop where physical network testbed performance directly modifies the subsequent LLM prompt (Evolutionary Prompting)
Modular decoupling of the mathematical utility function from the CC protocol logic to allow hot-swapping of LLM-generated logic

Modeling

Base Model: GPT-5

Training Method: Inference-only with evolutionary selection (no gradient updates to LLM)

Key Hyperparameters:

generations_per_experiment: 10-20
repetitions_per_test: 10
test_duration_seconds: 30

Comparison to Prior Work

vs. Hercules: Hercules uses a fixed, manually engineered utility function; GenCC generates scenario-specific functions automatically via LLM
vs. Proteus: GenCC extends Proteus's architecture but replaces the fixed utility logic with an evolving code-generation pipeline
vs. PCC Vivace: Vivace uses a fixed objective function (throughput minus penalty for latency/loss); GenCC discovers new objective functions mathematically defined in C++ code [not cited in paper]

Limitations

Dependency on external LLM APIs (GPT-5) for code generation
Compilation failures can occur (approx 1-2% for GPT-5, up to 80% for smaller models like GPT-OSS-20B)
Requires a realistic network testbed or accurate simulator in the loop to evaluate and evolve functions
One-shot strategy was unstable and sometimes performed worse than zero-shot

📊 Experiments & Results

Evaluation Setup

Constrained network scenarios using Akamai Cloud instances (Sender: Chicago, Receiver: Atlanta) and local machines

Benchmarks:

Satellite Scenario (10Mbps capacity, 60ms RTT) [New]
Cellular Scenario (20Mbps capacity, 40ms RTT) [New]
Broadband Scenario (50Mbps capacity, 20ms RTT) [New]

Metrics:

Satisfaction Ratio (Average sending rate / Minimum requirement)
Worst-case Satisfaction Ratio (Minimum satisfaction across all connections)
Statistical methodology: Results averaged over 10 repetitions per test.

Main Takeaways

GenCC with 'Evolve' or 'Math-CoT' strategies significantly outperforms the fixed Hercules utility function, with gains up to 142% in broadband settings.
Providing a reference implementation (One-shot) often degraded performance compared to Zero-shot or Math-CoT, suggesting it biased the LLM toward suboptimal local minima.
Smaller open-source models (GPT-OSS-20B) are currently unsuitable for this task due to an 80% code compilation failure rate.
Generated functions showed good generalization: the best functions from one scenario achieved ~90% of optimal performance when transferred to other scenarios.

📚 Prerequisite Knowledge

Prerequisites

Fundamentals of Transport Layer networking (TCP/IP)
Gradient descent optimization
Basic understanding of Prompt Engineering and Code Generation

Key Terms

CC: Congestion Control—algorithms that manage the rate of data transmission to prevent network overload

Utility Function: A mathematical function that quantifies the 'benefit' a sender gets from a certain sending rate, used to guide rate adjustments

RTT: Round Trip Time—the duration from sending a packet to receiving its acknowledgment

SACK: Selective Acknowledgment—feedback from receiver indicating exactly which packets arrived

Math-CoT: Mathematical Chain-of-Thought—a prompting strategy asking the LLM to explain mathematical reasoning before generating code

Zero-shot: Prompting the model to generate a solution without providing any prior examples

Hercules: A state-of-the-art learning-based congestion control protocol used as the primary baseline

Proteus: A precursor protocol to Hercules; GenCC extends its implementation infrastructure

GPT-5: The specific Large Language Model version cited by the paper as the code generator

QoS: Quality of Service—metrics like bandwidth, latency, and jitter that determine connection performance