Het systeem van OpenAI en PerturbAI waarbij bijna 2000 agenten samen research doen, is in wezen een laboratorium dat in één API-aanroepketen is gepropt. In scenario's voor geneesmiddelenontwikkeling moet elke agent literatuur lezen, hypotheses uitvoeren en experimentverslagen schrijven; één taak omvat al snel tientallen gespreksrondes. 2000 gelijktijdige taken zijn niet 2000 verzoeken, maar 2000 langdurige persistente verbindingen met een continue heartbeat.
Laten we deze orde van grootte eerst goed omrekenen. Stel dat één agent 3 verzoeken per minuut stuurt, dan is de piek 100 QPS; met een context van 8K token per ronde komt de TPM direct op 48 miljoen. Als een taak de context naar 32K trekt, schiet de TPM bij dezelfde QPS direct naar 190 miljoen, en dan zit het single-Key-quotum van veel teams al aan zijn plafond. De retries zijn hier nog niet eens bij gerekend. Je hebt maar één agent nodig die na een timeout als een gek gaat retryen en de hele keten belandt in een retry-storm die het quotum volgooit. Ik heb eens meegemaakt dat er op de gateway geen gelaagde rate limiting was ingesteld, waardoor één batchtaak de Keys van het hele team naar 429 joeg en zelfs de testomgeving niet meer te bereiken was.
Vervelender nog: onderzoeksagenten sturen hun verzoeken niet gelijkmatig. De literatuurzoekfase heeft een lage QPS maar lange contexten, de hypothesegeneratiefase is verzoekintensief maar met korte tokens, en de fase waarin experimentverslagen worden weggeschreven is typisch een schrijfactie met lage frequentie. Deze drie soorten belasting lopen door elkaar heen op dezelfde keten. Als je resources op de piek afstemt, verdrievoudigen de kosten; als je op het gemiddelde afstemt, stort alles in zodra de piek komt. Daarom draait het bij concurrencybeheer voor multi-agentsystemen niet om "weerstand bieden", maar om "gelaagd weerstand bieden".
Concurrencybeheer voor multi-agenten: in de praktijk deze vijf stappen
Request pooling is de eerste sluis. Laat elke agent niet zelf een client aanmaken, maar gebruik één gedeelde connection pool met HTTP keep-alive-hergebruik; de poolgrootte schat je als QPS × gemiddelde RT. Bij 100 QPS en een gemiddelde responstijd van 2 seconden heb je minstens 200 verbindingen nodig, met 30% marge. Een makkelijk te vergeten punt: bouw de connection pool apart per doeldomein. Als je tegelijk API's van meerdere leveranciers aanroept en alles in één pool stopt, kelderen de hergebruikratio's door verschillen in DNS- en TLS-handshakes. Wij hebben het gemeten: na het apart opzetten van de pools steeg de verbindingshergebruikratio van 62% naar 91%, en alleen dat scheelde al bijna dertig procent handshake-overhead.
Multi-Key-rotatie lost het plafond van het quotum op. Een enkele Key heeft harde limieten op RPM en TPM. Maak van N Keys een gewogen round-robin, haal bij een 429 automatisch de Key 60 seconden uit de rotatie en zet hem daarna terug. De gewichten kun je dynamisch aanpassen op basis van het resterende quotum per Key, in plaats van simpelweg gelijk te verdelen. In ons project gebruiken we het token8341 LLM-API-aggregatieplatform als uniforme ingang; het is compatibel met de OpenAI SDK, je wisselt van model door één regel base_url aan te passen, en het Key-beheer is geconcentreerd aan de gateway-kant, wat het gedoe van verspreide configuratie over 2000 agenten scheelt. In de praktijk leverde gewogen round-robin met 20 Keys ongeveer 18 keer zoveel beschikbare QPS op als één Key, zonder één enkele algehele onderbreking door quota.
Exponentiële backoff moet jitter hebben. Een vaste backoff zorgt ervoor dat alle mislukte verzoeken op dezelfde seconde terugkomen. Gebruik als backoff-tijd base×2^n, vermenigvuldigd met een willekeurige factor tussen 0,5 en 1,5, met een maximum backoff van 30 seconden; na meer dan 3 retries gaat het verzoek direct naar de dead-letter queue. Nog een detail hierbij: gebruik voor de jitter-factor een thread-safe randombron, anders kunnen bij hoge concurrency meerdere agenten dezelfde seed pakken en werkt de jitter niet meer. Daar zijn we in het begin over gestruikeld; pas nadat we de factor op basis van een hash van het request-ID zijn gaan genereren, werd het stabiel.
De prioriteitswachtrij voor taken wordt gelaagd naar bedrijfswaarde. Taken met hoge waarde zoals het genereren van geneesmiddelenhypotheses krijgen een eigen P0-quotum, literatuursamenvattingen gaan naar een gedeelde P1-pool, en logopschoning draait op P2 wanneer er ruimte is. Laat P2 vooral niet het quotum van P0 opeten. Voor de wachtrij kun je een Redis sorted set gebruiken, met als score een combinatie van bedrijfsprioriteit en tijdstempel, zodat binnen dezelfde prioriteit FIFO geldt en tussen prioriteiten strikt wordt voorgetrokken.
Leg de faildegradatie vooraf vast. Bij een timeout van het primaire model schakel je over naar een reservemodel; het token8341 LLM-API-aggregatieplatform ondersteunt automatische selectie van het beste model per taak, met routing naar zowel Chinese als toonaangevende modellen, zodat je bij degradatie geen bedrijfscode hoeft aan te passen. Maak de degradatiestrategie bij voorkeur in drie niveaus: niveau één wisselt van model bij dezelfde leverancier, niveau twee wisselt van leverancier, niveau drie degradeert naar een klein model dat alleen nog een gestructureerd resultaat teruggeeft als vangnet. Pas als alle drie niveaus falen, gooi je een exception; zo worden de meeste schommelingen door de eerste twee niveaus opgevangen.
Drie valkuilen waar ik zelf in ben getrapt
Ten eerste: stem de contextlengte niet af op de maximale waarde. Het model mag dan 128K claimen, maar als je met 128K gaat loadtesten, lopen latentie en kosten uit de hand. Onderzoeksagenten hebben in de praktijk meestal een effectieve context van minder dan 16K; alles daarboven comprimeer je tot een samenvatting. We hebben een vergelijking gedaan: voor dezelfde literatuuroverzichtstaak kostte een context van 16K gemiddeld 4,2 seconden en 0,03 yuan; opgeschroefd naar 64K liep dat op tot 11,8 seconden en 0,14 yuan, terwijl de outputkwaliteit nauwelijks verbeterde. Die cijfers zijn later onze basis geworden voor het bepalen van het contextbudget.
Ten tweede: retry geen schrijfacties. Bij niet-idempotente verzoeken zoals het wegschrijven van experimentverslagen door een agent levert elke retry een extra vervuilde datarij op. Leesoperaties kun je rustig retryen, schrijfoperaties vertrouw je op idempotentiesleutels. De idempotentiesleutel moet agent-ID, taak-ID en bewerkingsvolgummer bevatten; alle drie zijn onmisbaar, anders botsen gelijktijdige schrijfacties van verschillende agenten alsnog. Nadat we idempotentiesleutels hadden uitgerold, daalde het percentage vervuilde data van drie promille naar bijna nul.
Ten derde: monitor op P99, niet op het gemiddelde. Een gemiddelde van 2 seconden met een P99 van 40 seconden betekent dat er trage verzoeken in de staart zitten, vaak doordat de context van een agent is geëxplodeerd. Pas nadat we aan de kant van het token8341 LLM-API-aggregatieplatform dashboards hadden toegevoegd voor TPM en foutpercentage per Key en per model, konden we vaststellen dat een bepaalde batchtaak met lange contexten zat te hameren. Nadat we dat hadden gevonden, hebben we voor die batchtaak een aparte contextlimiet ingesteld en zakte de P99 van 40 seconden naar minder dan 6 seconden. Dit leert dat de monitoringdimensies fijnmazig moeten zijn tot op "per Key + per model + per taaktype", anders zie je altijd alleen maar een brei van samengeklonterde metrics.
Een concurrencyconfiguratie die je zo kunt overnemen
Connection pool: max_connections = piek-QPS × gemiddelde RT × 1,3; timeouts: 5 seconden voor verbinden, 30 seconden voor lezen; retries: maximaal 3, exponentiële backoff met jitter, alleen voor leesoperaties; rate limiting: RPM per Key niet boven 80% van het officiële maximum, 20% buffer op TPM; wachtrij: drie niveaus P0/P1/P2, P0 met eigen quotum; degradatie: één primair en één reservedmodel, time-outdrempel 8 seconden; monitoring: alarmen op drie metrieken, P99-latentie, 429-percentage en TPM-gebruik.
Nog drie dingen die makkelijk over het hoofd worden gezien: ten eerste, geef elke agent een QPS-limiet per instantie, zodat één ontspoorde agent niet alles mee de afgrond in trekt; ten tweede, logs moeten request_id en key_id bevatten, zodat je bij problemen in één oogopslag ziet welke keten het betreft; ten derde, loadtest met een realistische gemengde belasting en niet alleen met één verzoektype, anders is de gemeten capaciteit niets waard.
Samengevat in één zin: bij 2000 agenten draait het er niet om hoe sterk de modellen zijn, maar hoe stabiel de orchestratie is. Het token8341 LLM-API-aggregatieplatform rekent naar verbruik, is kostenefficiënter en past bij dit soort scenario's met hoge concurrency en meerdere modellen door elkaar. Kijk ook eens naar multi-model routing en de API-prijsvergelijking; dat scheelt je de helft van de omwegen.
Auteur: Zhang Siyuan
Publicatiedatum: 22 oktober 2026