🤖 AI

Argus: A General-Purpose Agentic Runtime for Long-Horizon Reasoning

Argus is een algemene, fixed-weight agentische runtime die superieure prestaties levert bij langetermijnredeneren over diverse benchmarks door gebruik te maken van een persistente, zelf evoluerende staat die wordt beheerd door gespecialiseerde rollen om autonoom missietrajecten te verifiëren, te herstellen en te verfijnen.

Oorspronkelijke auteurs: Boxiu Li, Zimo Wen, Yijia Fan, Junxiang Lei, Sufeng Guo, Jiaao Wu, Ruize Tang, Mukai Li, Yifei Shen, Xiaoyu Chen, Wanbo Zhang, Runjing Gu, Yifei Gao, Yuheng Wu, Xuyao Huang, Zelong Zhao, Jiachen Zhang

Gepubliceerd 2026-08-06

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Boxiu Li, Zimo Wen, Yijia Fan, Junxiang Lei, Sufeng Guo, Jiaao Wu, Ruize Tang, Mukai Li, Yifei Shen, Xiaoyu Chen, Wanbo Zhang, Runjing Gu, Yifei Gao, Yuheng Wu, Xuyao Huang, Zelong Zhao, Jiachen Zhang, Shibo Hu, Hangxi Guo, Yilin Chen, Yuzhe Zhang, Fan Yang, Chuan Wen, Xian Zhang, Xuanhe Zhou, Zhijie Deng

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

De Detective voor de Lange Adem: Waarom AI een Geheugen en een Coach Nodig Heeft

Stel je voor dat je een enorme, meerdaagse mysteries probeert op te lossen, zoals het uitzoeken hoe je vanaf nul een werkende robot bouwt of het schrijven van een roman die ook echt logisch is. Als je een computerprogramma uit een paar jaar geleden zou zijn, had je misschien geprobeerd het op te lossen door de instructies te lezen, een gokje te wagen, en vervolgens direct alles wat je zojuist had gedaan te vergeten voordat je het opnieuw probeerde. Dit is hoe veel vroege AI-"agents" werkten: ze waren als een detective die één aanwijzing oplost, en dan last krijgt van totale amnesie, en telkens wanneer ze tegen een doodlopende weg aanlopen, de hele investigatie weer helemaal opnieuw moet beginnen. Ze waren snel in lezen, maar erg slecht in het leren van hun eigen fouten over een langere periode.

Het vakgebied van "long-horizon reasoning" (redeneren over een lange horizon) gaat over het oplossen van dit probleem. Het vraagt: Hoe kan een AI een plan dagen of wekenlang volhouden, onthouden wat hij gisteren heeft geprobeen, en zijn strategie aanpassen wanneer hij beseft dat hij de verkeerde kant op gaat? Het kernidee hier is dat slim zijn niet alleen gaat over het hebben van een groot brein (een krachtig model); het gaat over het hebben van een goed notitieblok (persistent geheugen) en een strenge coach (verificatie) die je stopt wanneer je jezelf voorliegt als je vastloopt. Dit artikel behandelt het probleem van hoe je een AI-systeem bouwt dat niet alleen in cirkels rondjes draait, maar ook daadwerkelijk zijn eigen methoden door de tijd heen evolueert, waardoor het beter wordt in het oplossen van moeilijke problemen zonder dat het vanaf de basis opnieuw getraind hoeft te worden.

Maak kennis met Argus: De AI die leert bij te sturen

Maak kennis met Argus, een nieuw soort AI-"runtime" (denk aan de besturingssoftware of de motor die het brein van de AI aanstuurt). De onderzoekers achter Argus, een team van Microsoft en verschillende topuniversiteiten, realiseerden zich dat voor een AI om echt moeilijke, langetermijnprojecten aan te kunnen, deze niet zoma lập de weg blindelings kan volgen. Als de AI probeert een bug te repareren in een gigantische softwarecodebase of een complex wiskundig stelling te bewijzen, kan het urenlang een pad volgen dat een doodlopende weg blijkt te zijn. Een normale AI zou gewoon door blijven duwen en tijd en energie verspillen. Argus is anders: het is ontworpen om te pivoteren (bijsturen).

Denk aan Argus als een zeer georganiseerd onderzoeksteam dat werkt in een gedeeld kantoor, in plaats van één persoon die alleen werkt. Dit team heeft vier duidelijke rollen, en ze halen hun taken nooit door elkaar:

De Manager: De baas die het grote plaatje in beeld houdt. Zij zorgen ervoor dat het team gefocust blijft op het oorspronkelijke doel (zoals "bouw een robot"), zelfs als het dagelijkse plan verandert.
De Planner: De strateeg die het grote doel opbreekt in kleine, uitvoerbare taken voor de dag.
De Engineer: De bouwer die daadwerkelijk de code schrijft, de experimenten uitvoert of de wiskunde doet.
De Reviewer: De strenge kwaliteitscontroleur. Hun taak is om te kijken naar wat de Engineer gebouwd heeft en te zeggen: "Dit is goed," "Dit moet worden gecorrigeerd," of "Stop, dit pad is een doodlopende weg."

De magie van Argus is dat het falen behandelt als data. Wanneer de Engineer een methode probeert en deze faalt, zegt de Reviewer niet alleen "oeps". Ze leggen precies vast waarom het misging. Dit verslag wordt opgeslagen in een permanente "projectstatus" (het gedeelde notitieblok van het team). Later, als het team diezelfde doodlopende weg weer probeert te bewandelen, herinnert het systeem zich: "Hé, dit hebben we gisteren geprobeerd en het werkte niet," en schakelt het over naar een nieuw idee. Dit wordt verification-guided persistence genoemd. Het systeem "leert" (werkt zijn geheugen bij) alleen als de Reviewer verifieert dat de nieuwe informatie daadwerkelijk waar en nuttig is.

Wat ze vonden: Beter in het repareren van code en het schrijven van papers

Het team testte Argus op enkele ongelooflijk moeilijke uitdagingen om te zien of deze "team met een geheugen"-aanpak daadwerkelijk werkt.

1. De Code-reparatietest (SWE-Bench Pro)
Ze gaven Argus 731 echte softwarebugs om te repareren. Dit is alsof je een programmeur een rommelige, kapotte codebase geeft en vraagt om deze te repareren zonder menselijke hulp.

Het resultaat: Argus repareerde succesvol ongeveer 78% van de bugs.
De vergelijking: Een standaard AI-tool (Direct Copilot) slaagde er slechts in om 59% van de bugs te repareren.
De kosten: Argus gebruikte ongeveer 1,41 keer meer computer-"tokens" (de basisunits van denken) dan de standaard tool.
De les: Argus was aanzienlijk nauwkeuriger, ook al dacht hij iets langer na. Het bewees dat de tijd nemen om werk te controleren en fouten uit het verleden te onthouden, de moeite waard is.

2. De "Slimmer Worden"-test (Self-Evolution)
Dit is het coolste deel. De onderzoekers observeerden Argus gedurende een bepaalde tijd. Ze hebben het AI-brein niet veranderd (de modelgewichten bleven exact hetzelfde). In plaats daarvan lieten ze het systeem simpelweg zijn "notitieblok" van vaardigheden en herinneringen opbouwen.

Het resultaat: Naarmate het systeem meer taken uitvoerde en zijn notitieblok vulde met geverifieerde vaardigheden, werd het sneller en goedkoper. In de latere stadia van de test gebruikte Argus 21% minder tokens en 15% minder tijd per taak vergeleken met het begin.
De betekenis: De AI hoefde niet opnieuw getraind te worden om beter te worden; het hoefde alleen maar te onthouden wat het geleerd had. Het evolueerde zijn eigen "runtime state", waardoor het een efficiëntere werker werd zonder zijn fundamentele brein te veranderen.

3. De "Lieg niet tegen jezelf"-test (Reviewer Interventie)
Het team hield bij hoe vaak de Reviewer ingreep. Van de 731 taken werd de Reviewer in 466 gevallen opgeroepen.

De redding: In 43 gevallen zei de Reviewer: "Dit is nog niet af, probeer het opnieuw." Nadat de Engineer het opnieuw probeerde, waren 34 van die taken succesvol gerepareerd, en 22 waren zo goed gerepareerd dat ze een tweede, strengere controle doorstonden.
De blokkade: De Reviewer voorkwam ook dat het systeem claimde dat het gewonnen had bij 35 taken die eigenlijk onmogelijk of defect waren. Dit is enorm belangrijk: het betekent dat het systeem leerde te zeggen "Ik kan dit niet" in plaats van een nepoplossing te hallucineren.

Voorbij Code: Wiskunde, Chips en Papers

Argus stopte niet bij het repareren van code. Het team liet zien dat het ook andere "long-horizon" taken kon aanpakken:

Wiskundig onderzoek: In een campagne om een complexe wiskundige stelling te bewijzen, hield Argus een verslag bij van één pad dat als onjuist werd bewezen (een "falsified route"). In plaats van het te verwijderen, hield het systeem het vast als een "niet binnenkomen"-bordje. Dit hielp het systeem om dat doodlopende pad later te vermijden en slaagde erin de grenzen van de stelling succesvol te versterken.
Papers schrijven: Ze voerden zes verschillende onderzoeksprojecten uit om wetenschappelijke papers te schrijven. Het systeem handelde 254 missies, overleefde 16 grote rollbacks (waarbij het het hele plan moest aanpassen) en slaagde er toch in om alle zes de papers te voltooien. Eén project maakte zelfs van een mislukt idee een succesvolle "negatieve resultaten"-studie, wat bewijst dat het ontdekken van wat niet werkt soms een geldige wetenschappelijke ontdekking is.
Chips ontwerpen: In een spannende test ontwierp Argus een computerchip (ACE-2). Het systeem schreef de code, controleerde de timing, en het uiteindelijke ontwerp voldeed aan alle strikte hardware-eisen. Het systeem wist zelfs precies wat het niet had gecontroleerd (zoals of de chip in de echte wereld zou werken) en vermeldde die beperkingen duidelijk.

De Kernconclusie

Argus laat zien dat voor een AI om echt langdurig werk te verrichten, er meer nodig is dan alleen een groot brein. Het heeft een systeem nodig dat de "baas" scheidt van de "werker", een permanent verslag bijhoudt van wat wel en niet werkte, en een strikte "reviewer" heeft om te voorkomen dat het antwoorden verzint.

Het artikel suggereert dat door deze "verification-gated" aanpak te gebruiken, AI moeilijkere problemen kan oplossen, efficiënter kan worden zonder opnieuw getraind te hoeven worden, en zelfs kan toegeven wanneer het vastloopt. Het is geen toverstaf die alles direct oplost, maar het is een enorme stap richting AI die daadwerkelijk met ons kan samenwerken aan lange, complexe projecten zonder de weg kwijt te raken of te liegen over de voortgang. Zoals de auteurs opmerken, gaat dit niet alleen over een hogere score halen op een test; het gaat over het bouwen van een systeem dat kan volharden, bijsturen en zijn eigen methoden kan evolueren om de rommelige, langdurige uitdagingen van de echte wereld aan te pakken.

Technische Samenvatting: Argus – Een General-Purpose Agentic Runtime voor Long-Horizon Redeneren

1. Probleemstelling

Long-horizon redeneertaken (bijv. softwareherstel, wiskundige bewijsvoering, wetenschappelijke ontdekking) zijn niet louter een race om een vastgesteld plan in meer stappen uit te voeren. In de praktijk blijft de staande gebruikersintentie vaak stabiel, terwijl het operationele doel, de beperkingen en de verificatiecriteria moeten worden verfijnd naarmate er meer bewijs wordt verzameld. Huidige agentsystemen kampen met een kritieke ambiguïteit: een systeem dat zijn gestelde doel verlaat, kan ofwel ontdekt hebben dat het doel foutief gespecificeerd was, of het kan gefaald hebben en de fout hebben gerationaliseerd. Zonder een mechanisme om dit onderscheid te maken, lijden systemen aan "doeldrift" (goal drift), waarbij doelstellingen degraderen naar wat de uitvoerder ook maar kan voltooien.

Bestaande benaderingen verwijderen deze keuze meestal door het doel vast te leggen en de uitvoering daarop te optimaliseren, of ze vertrouwen op sessie-gelimiteerde transcripten die continuïteit verliezen wanneer contexten worden gecomprimeerd. Dit leidt tot drie fouten in langlopende agents:

Continuïteitsfout: Bewijs dat een revisie motiveert, gaat verloren wanneer transcripten worden verwijderd.
Acceptatiefout: De component die het werk uitvoert, verklaart ook de voltooiing, wat een belangenconflict creëert.
Ervaringsfout: Alleen de uiteindelijke artefacten overleven, waardoor weerlegde routes niet kunnen dienen als bewijs voor toekomstige pivots (koerswijzigingen).

2. Methodologie: De Argus Runtime

Argus is een persistente, zelf evoluerende agentic runtime die is ontworpen om "geverifieerde pivoting" toe te staan en veilig te beheren. Het scheidt de vaste parameters van het model van een mutabele, duurzame runtime-toestand.

2.1 Kernarchitectuur

Het systeem werkt op basis van een duurzame projecttoestand verdeeld in begrensde missies. Het maakt gebruik van vier model-gestuurde rollen met afzonderlijke autoriteiten:

Manager: Verankert de staande gebruikersintentie ( $\iota$ ), de campagne-toestand en de fase-transities. Het staat materiële verfijningen van het operationele contract toe.
Planner: Decomponeert de huidige toestand in begrensde taken en afhankelijkheden.
Engineer: Implementeert taken, roept tools aan en voert experimenten uit. Kan zelf-review uitvoeren op laag-risico, begrensd werk.
Reviewer: Inspecteert onafhankelijk artefacten en executie-records. Het vaardigt voltooiingsverdicten uit (klaar, doorgaan, geblokkeerd) wanneer vereist door beleid of verzoek.

Deze rollen opereren over drie vlakken: Control (planning), Execution (werk) en Records (onveranderlijke historie).

2.2 Verificatie-gegateerde Persistentie en Zelf-evolutie

Argus introduceert een verificatie-gegateerde admissie (toelatings)mechanisme. De runtime-toestand ( $H_t$ ) bevat geheugen, vaardigheden, tools, verifiers en routing-policies.

Fixed-Model Evolutie: De onderliggende modelgewichten ( $\theta$ ) blijven vast. Evolutie vindt uitsluitend plaats in de persistente toestand en het controlebeleid.
Admissieprotocol: Kandidaat-updates (geheugens, vaardigheden, afgewezen routes) worden pas herbruikbaar na:
1. Generatie door een rol (bijv. Engineer).
2. Review tegen taak-natuurlijk bewijs en artefacten.
3. Commitment door een geautoriseerde eigenaar (bijv. Reviewer of Manager).
Contractverfijning: Het werkende contract wordt gemodelleerd als $K_t = (\iota, o_t, c_t, v_t)$ , wat staande intentie, operationeel doel, beperkingen en verificatiecriteria vertegenwoordigt. Verfijningen worden toegelaten via een ManagerAdmit operator die bewijs ( $e_t$ ) en autoriteit ( $u_t$ ) vereist, om ervoor te zorgen dat pivots te onderscheiden zijn van drift.

2.3 Process-to-Capability Theorie

Het systeem beschouwt het proces-traject als een superverzameling van het uiteindelijke artefact. Het definieert Dense-Intelligence Density ( $\rho_I$ ) als de snelheid van relevante redenering, effectieve actie en geldige verificatie per tijdseenheid. Het stelt dat het behouden van het volledige procesrecord (inclusclusief gefaalde takken) een besluitvormingstheoretisch voordeel biedt (Blackwell informatie-ordening) boven enkel het uiteindelijke artefact, waardoor toekomstige missies doodlopende wegen kunnen vermijden en geverifieerde uitsluitingen kunnen benutten.

3. Belangrijkste Bijdragen

Het paper beschrijft zeven specifieke bijdragen:

Formalisering: Een contractmodel ( $K_t$ ) en ManagerAdmit operator voor geverifieerde pivoting over lange horizonten.
Runtime Design: Een systeem waarbij contractverfijning door een rol wordt beheerd en gelogd, wat de stabiele intentie scheidt van operationele wijzigingen.
Reviewer Routing Metrics: Empirische gegevens die aantonen dat onafhankelijke Reviewers worden opgeroepen voor 63,7% van de SWE-Bench Pro taken, met specifieke herstelpercentages voor revisieverzoeken.
Paper Productie Case Study: Een campagne van zes projecten over 640 uur en 254 missies, die het volledige onderzoekscyclusbeheer demonstreert, inclus inclusief rollbacks en pivots op basis van negatieve resultaten.
Wiskundige Trace: Een rol-opgeloste reconstructie van een wiskundige campagne die één gefalsifieerde route en zes bewijs-onderbouwde updates behoudt.
Benchmark Prestaties: Een verenigde evaluatie over zeven arena's, die een capaciteitsvloer vaststelt zonder de prestaties aan het einde van de taak op te offeren.
Upstream Adoptie: Een Argus-geoptimaliseerde RWKV6-kernel die is samengevoegd met de upstream Flash Linear Attention repository.

4. Resultaten

4.1 Benchmark Prestaties

Argus werd geëvalueerd over zeven heterogene arena's:

SWE-Bench Pro: Behaalde ~78% nauwkeurigheid vergeleken met 59% voor Direct Copilot, met 1,41× geaggregeerde Tokens.
AARRI-Bench: Bereikte 76,8% op research-intern taken (vs. 68,3% referentie).
Math-Reasoning Data Synthese: Bereikte een 28,0 gap (pass@4 - pass@1), waarmee het referenties overtrof (Arbor: 20,83, Claude: 8,33).
GPU & Training: Behaalde concurrerende resultaten op B200/H100 nanochat training (0,9636 BPB vs. menselijk best 0,9646) en nanoGPT speedruns (79,77s vs. mens 80,18s).
MLE-Bench Lite: Verwierf 9 medailles (3 Goud, 3 Zilver, 3 Brons) in competities met externe verificatie.

4.2 Longitudinale Efficiëntie (Zelf-evolutie)

In de SWE-Bench Pro run (731 taken) demonstreerde het systeem verificatie-gegateerde runtime zelf-evolutie:

Mature vs. Startup: Volwassen golven (W19–22) gebruikten 21% minder solve input Tokens en 15% minder actieve workflowtijd per taak vergeleken met startup golven (W1–6).
Reviewer Recovery: Van de 43 taken waarbij de Reviewer een revisie vroeg, passeerden er 34 (79,1%) later de officiële verifier, en 22 (51,2%) voltooiden een strikte review-loop redding.
Niet-monotonie: Het traject was niet monotoon; moeilijke taakgolven (W23–24) vertoonden resource-rebounds, en het systeem registreerde 34 verifier recoveries en 22 strikte reddingen, wat het vermogen van het systeem bewijst om te herstellen van initiële fouten.

4.3 Verticale Case Studies

Wiskundige Campagne: Behield een gefalsifieerde route en zes theorem-frontier updates. Het systeem slaagde erin te pivoteren van een gefaalde reductie naar een bewijs-onderbouwde versterking van de grenswaarden.
Paper Productie: Zes projecten bereikten voltooiing van indiening. Eén campagne pivotteerde van een positieve methode-claim naar een 4.500-rijen tellende negatieve-resultaten diagnostische studie na zeven "no-go" rollbacks.
Hardware (ACE-2): De runtime ontwierp een inference accelerator (Qwen2.5-0.5B W4A8) gecertificeerd voor een specifieke scope (mapped synthesis, static timing) met expliciete uitsluitingen (geen power signoff, geen silicon validatie).
Materiaalwetenschap: De runtime vereenvoudigde een gepubliceerde MOF-generatiemethode door een confound in de oorspronkelijke vergelijking te identificeren en te verwijderen, wat resulteerde in een simpelere, effectievere methode.

5. Betekenis en Claims

Het paper claimt dat Argus een generaal, zelf-evoluerend harnas demonstreert dat in staat is om te reviseren, te herstellen en geverifieerde benaderingen te accumuleren zonder elke long-horizon traject te dwingen tot een succesclaim.

Onderscheid van Drift: Door een bewijs-onderbouwde, door een rol beheerde admissie voor toestandswijzigingen te vereisen, onderscheidt het systeem rationele pivoting van falen-rationalisatie.
Proces als Data: De behouden trajecten vormen gestructureerde data voor toekomstige supervised en reinforcement learning, waarbij modeloutputs worden verbonden aan concrete toestanden, tools en review-beslissingen.
Bescheiden Scope: De auteurs stellen expliciet dat de "zelf-evolutie" fixed-model is (toestand-gebaseerd, niet gewichts-gebaseerd) en dat de resultaten observationeel zijn. Ze beweren niet dat het systeem algemene kunstmatige intelligentie heeft bereikt of dat het menselijke onderzoekers volledig kan vervangen. Het systeem wordt gepresenteerd als een tool die "stopt" wanneer doelstellingen ondergespecificeerd zijn, waardoor beperkingen aan het licht komen die de gebruiker mogelijk over het hoofd heeft gezien, in plaats van blind te optimaliseren naar een potentieel gebrekkig doel.

De rapportage concludeert dat de runtime er succesvol in is geslaagd om brede taakcapaciteit, geverifieerde accumulatie over missies en duurzame onderzoekslevering te combineren, waarbij persistentie en pivoting worden beheerd door middel van verificatie in plaats van vaste planning.