AgentServe: Algorithm-System Co-Design for Efficient Agentic AI Serving on a Consumer-Grade GPU

AgentServe is een systeem voor het bedienen van AI-agenten op consumentengpu's dat door middel van co-design van algoritme en systeem de prestaties verbetert door prefills en decodes te isoleren en GPU-bronnen dynamisch te beheren, wat leidt tot aanzienlijk stabielere latenties en hogere doorvoersnelheden.

De kern

Hier is een uitleg van het paper "AgentServe" in eenvoudig Nederlands, met behulp van alledaagse analogieën.

Het Probleem: De Verkeersopstopping in de Keuken

Stel je voor dat je een supermoderne keuken hebt (de GPU) met één chef-kok (de AI). In het verleden kookten mensen alleen lange maaltijden: je gaf een recept, en de kok maakte langzaam een groot gerecht klaar (zoals een chatbot die een lang verhaal schrijft). Dat ging prima.

Maar nu willen we AI-agenten gebruiken. Dit zijn slimme helpers die niet alleen praten, maar ook acties ondernemen. Ze moeten bijvoorbeeld het weer checken, een e-mail schrijven en een boodschappenlijst maken. Dit werkt in korte rondjes:

1. Denken (Prefill): De kok leest een heel lang recept (het systeemrecept) om te weten wat hij moet doen. Dit duurt even en vraagt veel energie.
2. Actie (Decode): De kok schrijft snel een kort antwoord of roept een andere dienst aan (bijv. "Het is zonnig"). Dit moet supersnel gaan.
3. Herhalen: De kok krijgt nieuwe instructies (bijv. het weerbericht), leest dat kort, en schrijft weer een kort antwoord.

Het probleem: Als je meerdere van deze agenten tegelijk op één keuken laat werken, ontstaat er chaos.

• De "lange recepten" (de Cold Prefills) nemen de hele fornuis in beslag.
• De "snelle antwoorden" (de Decodes) moeten wachten.
• Resultaat: De gebruiker ziet een lange stilte voordat het eerste woord verschijnt, en daarna hapert de tekst. Het is alsof de kok een enorme soep moet maken voordat hij een glas water kan inschenken. De klant wordt ongeduldig.

De Oplossing: AgentServe

De auteurs van dit paper hebben AgentServe bedacht. Dit is een slimme besturingssysteem voor die ene keuken, speciaal ontworpen voor consumentencomputers (zoals een krachtige gaming-kaart in je laptop of PC), niet voor enorme datacenters.

Ze gebruiken drie slimme trucs:

1. De Splitsing van Taken (Isolatie)

In plaats van dat alles door elkaar loopt, maakt AgentServe twee aparte zones in de keuken:

• Zone A (De "Kookzone"): Hier worden de lange, zware recepten (Cold Prefills) klaargemaakt.
• Zone B (De "Serveerzone"): Hier worden de snelle antwoorden (Decodes) afgeleverd.
  Deze zones zijn strikt gescheiden. De zware kooktaken kunnen de serveerzone niet blokkeren. Het is alsof je een aparte oven hebt voor het braden van een kalkoen, zodat de kok in de hoofdkeuken gewoon snel een salade kan snijden zonder dat de kalkoen in de weg zit.

2. De Slimme Chef (Dynamic Budgeting)

Soms zijn de "nieuwe instructies" (Resume Prefills) niet heel lang, maar ook niet heel kort. AgentServe heeft een slimme chef die continu kijkt: "Hoe snel gaat het met het serveren?"

• Als de serveerzone (de snelle antwoorden) begint te haperen, zegt de chef: "Stop even met het lezen van nieuwe lange instructies! Geef eerst de snelle antwoorden af."
• Zodra de serveerzone rustig is, mag er weer wat meer tijd worden besteed aan het lezen van nieuwe instructies.
  Dit is als een verkeersregelaar die de groene golf voor de auto's (de snelle antwoorden) prioriteit geeft, zodat ze niet vastlopen in de file van de vrachtwagens (de lange recepten).

3. De Vooraf Gemaakte Sporen (CUDA Green Contexts)

Normaal gesproken kost het een computer veel tijd om te schakelen tussen verschillende taken (zoals het wisselen van gereedschap). AgentServe gebruikt een speciale techniek (CUDA Green Contexts) waarbij de "sporen" voor de taken al klaarliggen voordat ze nodig zijn.

• Analogie: In plaats van dat de kok elke keer een nieuwe schort moet aantrekken en de keuken moet schoonmaken voordat hij begint, heeft hij al drie schorten en werkplekken klaarstaan. Hij kan direct van de ene naar de andere plek springen zonder tijd te verliezen. Dit zorgt voor een soepele, ononderbroken stroom.

Waarom is dit belangrijk?

Vroeger dachten mensen: "Als je AI lokaal wilt draaien (op je eigen computer, voor privacy), moet je een hele dure server kopen."

AgentServe laat zien dat je met een gewone, krachtige consumentencomputer (zoals een RTX-kaart) al meerdere slimme agenten stabiel kunt laten werken.

• Resultaat: De AI reageert veel sneller (tot 2,8x sneller voor het eerste woord).
• Stabiliteit: De tekst stroomt soepel uit, zonder haperingen, zelfs als je drie of vier agenten tegelijk laat werken.
• Efficiëntie: De computer wordt niet overbelast; hij doet precies wat nodig is, op het juiste moment.

Samenvatting in één zin

AgentServe is als een slimme verkeersregelaar voor je computer die zorgt dat de "snelle antwoorden" van je AI-agenten nooit vastlopen in de file van de "lange gedachten", zodat alles soepel en snel blijft werken, zelfs op een gewone thuiscomputer.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "AgentServe: Algorithm-System Co-Design for Efficient Agentic AI Serving on a Consumer-Grade GPU", geschreven in het Nederlands.

Probleemstelling

Grote Taalmodellen (LLM's) worden steeds vaker ingezet als AI-agenten die werken in korte redeneer-actie-lussen, waarbij modelberekeningen worden afgewisseld met externe tool-aanroepen. Dit verschilt fundamenteel van traditionele chattoepassingen.

• Werklast-ongelijkheid: Agent-werklasten worden gekenmerkt door lange "cold prefills" (verwerking van systemprompten), frequente "resume prefills" (toevoegen van tool-output aan de context) en zeer korte, maar latentie-gevoelige "decodes" (generatie van functionele calls of routing tokens).
• Head-of-Line (HoL) Blocking: Wanneer deze heterogene verzoeken op een enkele consumentengpu (zoals een NVIDIA RTX-serie) overlappen, monopoliseren de zware prefills de rekenkracht en het geheugenbandbreedte. Hierdoor worden de korte decodes vertraagd, wat leidt tot onstabiele token-emissie en een verslechterde gebruikerservaring.
• Beperkingen van bestaande systemen: Bestaande frameworks (zoals vLLM, SGLang) zijn vaak geoptimaliseerd voor doorvoer in chat-scenario's of vereisen gedistribueerde GPU-sets. Op een enkele GPU leiden hun benaderingen (zoals chunked prefill of procesgescheiden PD-disaggregatie) tot te veel overhead of onvoldoende isolatie om de strikte latentie-eisen van agenten te waarborgen.

Methodologie: AgentServe

AgentServe is een single-GPU dienstsysteem dat een co-design van algoritmen en systeemarchitectuur hanteert om de bovenstaande problemen op te lossen. Het systeem is opgebouwd uit drie lagen:

1. Architectuur:

   • Application Layer: Interactie met agent-frameworks (bijv. LangChain, AutoGen).
   • Orchestration Layer (CPU): Bevat een Request Manager die verzoeken classificeert in cold prefill, resume prefill of decode. Een Resource-Aware Scheduler (TPOT-gedreven) regelt dynamisch de toewijzing van resources.
   • Execution Layer (GPU): Voert de isolatie uit via CUDA Green Contexts. In plaats van processen te scheiden, worden vooraf gedefinieerde CUDA-contexten gebruikt die specifieke sets van Streaming Multiprocessors (SM's) reserveren. Dit voorkomt de overhead van inter-process communicatie en KV-cache-overdrachten.

2. Algoritme: Resource-Aware Scheduling:

   • Het systeem gebruikt een feedback-loop gebaseerd op TPOT (Time Per Output Token).
   • Dynamische Budgettering: Als de TPOT te hoog wordt (wat aangeeft dat decodes vertragen), verkleint de scheduler het token-budget voor resume prefills en verhoogt hij de minimale reservering van SM's voor decodes.
   • Isolatie: Cold prefills worden in een aparte wachtrij geplaatst. Resume prefills worden alleen toegelaten als ze binnen een dynamisch budget vallen; anders worden ze vertraagd. Decodes krijgen altijd prioriteit en een gegarandeerde "veiligheidsmarge" aan SM's.

3. Systeemimplementatie:

   • CUDA Green Contexts: Er worden bij het opstarten tien discrete contexten gemaakt (van 10% tot 100% SM's). Tijdens runtime kan de scheduler de decode-thread snel herbinden aan een geschikte context zonder de hoge kosten van het aanmaken van nieuwe contexten.
   • Gedeeld Geheugen: Prefill- en decode-threads delen dezelfde GPU-geheugenpool. Een Memory Manager zorgt voor synchronisatie (via mutexes en cudaEvents) zodat KV-caches veilig worden hergebruikt zonder race-conditions.

Belangrijkste Bijdragen

1. Algoritme: Een resource-bewust schedulingsalgoritme dat request-isolatie combineert met TPOT-gedreven adaptatie. Het biedt een theoretische analyse (competitieve ratio) die aantoont dat het systeem de prefill-doorvoer beperkt tot een constante factor ten opzichte van een optimaal offline schema, terwijl het de decode-SLO's (Service Level Objectives) respecteert.
2. Systeemontwerp: Een mechanisme voor resource-beheer dat gebruikmaakt van vooraf ingestelde CUDA Green Contexts en lichte shared-memory-coördinatie. Dit maakt efficiënte partitie van resources binnen één engine mogelijk met minimale runtime-overhead.
3. AgentServe Implementatie: Een volledig werkend single-GPU systeem voor gelijktijdige tool-augmented SLM-agenten. Het is specifiek ontworpen voor lokale, gestructureerde agent-workflows op consumentenhardware.

Resultaten

De evaluatie is uitgevoerd op twee hardwareplatforms (NVIDIA RTX A5000 en RTX 5090) met modellen zoals Qwen2.5-3B/7B en LLaMA-3-8B, onder werklasten zoals ReAct en Plan-and-Execute.

• Latentieverbetering:
  • TTFT (Time To First Token): AgentServe levert tot 2,8x verbetering ten opzichte van state-of-the-art baselines (zoals vLLM en SGLang).
  • TPOT (Time Per Output Token): Er is tot 2,7x verbetering in de stabiliteit van token-emissie, wat cruciaal is voor de vloeiendheid van interactie.
• Doorvoer: Het systeem behoudt een concurrerende doorvoer (tot 2,2x beter dan llama.cpp) terwijl het de latentie-stabiliteit garandeert.
• SLO-Opneming: AgentServe behaalt een hogere percentage van sessies dat voldoet aan zowel TTFT- als TPOT-eisen, zelfs bij hoge concurrentie (6 gelijktijdige agenten), waar baselines vaak falen.
• Ablatie-studie: Het verwijderen van de dynamische scheduling of de Green Context-isolatie leidt tot een significante verslechtering van de tail-latentie, wat aantoont dat beide componenten essentieel zijn.

Significantie

Dit paper adresseert een kritieke kloof in de AI-infrastructuur: het efficiënt draaien van complexe, tool-gebaseerde agenten op lokale, consumentengpu's.

• Het bewijst dat lokale implementaties van Small Language Models (SLM's) voor privacy en kostenredenen haalbaar en stabiel kunnen zijn, mits het systeem specifiek is ontworpen voor de unieke werklastpatronen van agenten (korte decodes, lange prefills).
• Het introduceert een nieuwe paradigma voor single-GPU serving: in plaats van brute kracht of gedistribueerde clusters, biedt fine-grained, fase-bewuste isolatie binnen één engine de oplossing voor head-of-line blocking.
• De resultaten zijn relevant voor de opkomst van edge computing, robotica en enterprise-systemen waar data-residentie en lage kosten prioriteit hebben boven cloud-schaalbaarheid.