Eén verzoek, een hele taak: zo werkt Mangrove

Op 4 november gaven we een van onze testagents een kleine klus: schrijf het AI-nieuwsoverzicht van vandaag, vijf items, elk met een bron.

Twee minuten en tweeëntwintig seconden later had hij een antwoord. Hij had acht webzoekopdrachten uitgevoerd en een negende geprobeerd, die werd geweigerd. Hij had zes pagina’s geprobeerd, en drie van die websites blokkeerden geautomatiseerde toegang. Toen hij dacht dat hij klaar was, stuurde een controle hem terug aan het werk. En onderaan zijn antwoord stond welke twee items alleen op zoekresultaten rustten, omdat hij de pagina’s erachter nooit te lezen kreeg.

De hele run gebruikte 1,96 Wh aan energie.

Aan die run kunnen we goed uitleggen wat Mangrove is, want bijna alles wat ertoe deed, gebeurde waar je het niet kon zien.

Transcript (vertaald)

Een chatmodel geeft je één antwoord. Het meeste werk is niet één antwoord. Het is zoeken, lezen, vergelijken, controleren en vaak opnieuw beginnen. Mangrove is het orkestratie-endpoint van GreenPT. Je stuurt één verzoek. Het bepaalt wat de taak nodig heeft, gebruikt de juiste tools, controleert zijn eigen antwoord en geeft je het resultaat. Je hoeft geen agentloop te bouwen en geen tools aan te sluiten. Net als de boom doet het zijn werk onder het oppervlak.

Een chatmodel geeft je één antwoord

Een chat completion is één vraag en één antwoord. Het meeste werk ziet er niet zo uit. Het is zoeken, lezen, vergelijken, controleren en vaak genoeg opnieuw beginnen.

Die loop kun je zelf bouwen. Genoeg teams doen dat. Je sluit tools aan, schrijft een loop om het model, voegt hier een retry en daar een limiet toe, en dan ontdek je het dure deel: bepalen wat er gebeurt als een pagina 1,3 miljoen tekens lang is, als het model zegt dat het klaar is en dat niet is, als elke zoekopdracht mislukt en het model een beleefd excuus schrijft dat je systeem als succes vastlegt.

Mangrove is het orkestratie-endpoint van GreenPT. Je stuurt één verzoek, en het voert de hele taak uit: het bepaalt wat de taak nodig heeft, gebruikt de juiste tools, controleert zijn eigen antwoord en geeft je het resultaat.

curl -X POST https://api.greenpt.ai/v1/agents/runs \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{ "question": "Summarise the EU grid carbon intensity news from this week" }'

Je krijgt meteen een agentId terug. Daarna poll je de run, of stream je zijn stappen terwijl ze gebeuren. Je hoeft geen agentloop te bouwen en geen tools aan te sluiten.

De naam is letterlijk bedoeld. Een mangrove doet zijn werk onder het oppervlak: wat je ziet is een boom, en wat alles overeind houdt is een netwerk van wortels dat alle kanten op groeit. Zo denken we over orkestratie. Boven het oppervlak zie je een taak en een resultaat.

Eén onderscheid voordat we verdergaan, want het is belangrijk voor alles wat hierna komt. Mangrove is geen model. Het is het systeem dat er een draait. Het model dat de beslissingen neemt, heeft zijn eigen naam.

Metis beslist. Mangrove doet het werk.

Transcript (vertaald)

Voordat een run start, zijn drie vragen belangrijk. Hoe moeilijk is deze taak? Hoeveel werk is het? En hoeveel bronnen zijn er nodig? Een model dat gokt, geeft te veel uit, of te weinig. Daarom vraagt Mangrove het aan Metis, ons beslismodel. Metis schrijft niets. Het leest de taak één keer en geeft een kans voor elk mogelijk antwoord. Alle drie de vragen in één keer. Zo’n vijfenzestig milliseconden modeltijd, en minder dan vijf duizendste wattuur. Metis beslist. Mangrove doet het werk.

Voordat een run start, zijn drie vragen belangrijk. Hoe moeilijk is deze taak? Hoeveel werk is het? Hoeveel bronnen zijn er nodig?

Zit je daar fout, dan betaal je er hoe dan ook voor. Een agent zonder gevoel voor schaal zet een groot model en een ruim budget in op iets dat je in één regel opzoekt, of geeft echt onderzoek te weinig ruimte om af te komen.

Daarom vraagt Mangrove het aan Metis, ons beslismodel. Metis schrijft niet. Je geeft het een casus en een set vragen, het leest alles één keer en geeft een kans voor elk mogelijk antwoord. Mangrove stuurt alle drie de vragen in één verzoek.

Dit kwam er op 5 november terug voor een echte taak: “Summarise this week’s news on EU grid carbon intensity in five bullets, with a source for each.”

Vraag	Antwoord van Metis	De rest
Hoe moeilijk is het?	standard, 62%	complex 27%, simple 12%
Hoeveel werk is het?	medium, 72%	long 15%, short 13%
Hoeveel bronnen?	several, 71%	many 14%, few 9%, none 6%

Die beslissing kostte 63 ms modeltijd en 0,0041 Wh, en genereerde nul tokens. Die cijfers komen uit het impactrapport dat de API met de response meestuurt.

Waarom vraag je een chatmodel niet gewoon om de taak te classificeren? Dat hebben we geprobeerd. In oktober testten we beide voor chatroutering op 65 met de hand gelabelde beurten. De totale nauwkeurigheid lag dicht bij elkaar: 77% voor Metis tegenover 80% voor een algemeen model dat in JSON antwoordde. Het verschil zat in de fouten en de wachttijd. Het algemene model deed er in de mediaan 2,3 seconden over en schatte in 20% van de gevallen te laag in hoeveel inspanning een beurt nodig had. Metis beantwoordde drie vragen in ongeveer 230 ms en schatte in 2% van de gevallen te laag in. Een orkestrator stelt dit soort vragen constant, en te laag inschatten is de dure fout: de taak krijgt te weinig ruimte en mislukt. Ook de kansen helpen, want dat is een getal waar je logica op kan handelen, zonder iets te hoeven ontleden.

Dat is dus de plek van Metis. Metis oordeelt. Mangrove handelt naar dat oordeel. Een taalmodel redeneert binnen de run; Metis bepaalt van buitenaf de voorwaarden.

Werk op maat

Transcript (vertaald)

Niet elke taak verdient evenveel inspanning. Vraag naar de hoofdstad van Finland, en Metis zegt simple en short. Vraag om een tabel van elk bedrijf op drie beursindices, en het zegt complex en long. Die beoordelingen bepalen de run. Moeilijkheid kiest het model, zodat een makkelijke klus nooit een groot model wakker maakt. Lengte bepaalt de limieten op aanroepen, tokens en tijd. Onderzoeksdiepte bepaalt hoe ver hij mag zoeken. Een nieuwsoverzicht krijgt acht zoekopdrachten, geen zeventien. En komt een beoordeling niet terug, dan houdt de run de limieten waarmee hij begon. Genoeg werk, en niet meer.

Moeilijk en lang zijn twee verschillende dingen. De websites van 250 bedrijven vinden is per item simpel en in totaal lang. Een subtiele deadlock is het omgekeerde. Daarom houdt Mangrove de assen uit elkaar, en elke as stuurt iets anders.

Moeilijkheid kiest het model. Bij een opgeslagen agent gaat een taak die als simple is beoordeeld naar een kleiner model en een taak die als complex is beoordeeld naar een sterker model, zodat een makkelijke klus nooit een groot model wakker maakt. Zet je een model vast op je agent, dan gaat jouw keuze voor.

Lengte bepaalt de limieten. Een taak krijgt een budget aan modelaanroepen, tokens en seconden dat bij zijn omvang past.

Onderzoeksdiepte bepaalt hoe ver hij mag zoeken. Deze komt voort uit een meting. Voordat die er was, kostte een nieuwsoverzicht van vijf items ergens tussen de 8 en 17 webzoekopdrachten en tot 9 gelezen pagina’s, allemaal met verschillende zoektermen, omdat elke zoekopdracht die iets vond uitnodigde tot de volgende. Een run had geen besef van genoeg.

Onderzoeksdiepte	Webzoekopdrachten	Gelezen pagina’s
None	1	1
Few	3	3
Several	8	6
Many	geen limiet	geen limiet

Dat is de negende zoekopdracht die bij ons nieuwsoverzicht werd geweigerd. De run krijgt zijn limiet vooraf te horen, en als hij die bereikt, antwoordt de tool dat het budget op is, met het verzoek op te schrijven wat hij heeft. En de beoordelingen van Metis voor heel verschillende taken verschillen ook echt: “What is the capital of Finland?” kwam terug als simple (98%) en short (96%). Een tabel van elk beursgenoteerd bedrijf in de AEX, AMX en AScX kwam terug als complex (71%) en long (93%).

Komt er helemaal geen beoordeling terug, dan gaat er niets stuk. Een run die niet beoordeeld kan worden, houdt de limieten waarmee hij begon. Een mislukte classifier zegt niets over de taak en mag dus niets inperken.

Eerst plannen, dan doen

Transcript (vertaald)

Een run begint niet met improviseren. Wat vaststaat, komt eerst. Een opname wordt uitgeschreven en een afbeelding bekeken, voordat het model je vraag ooit ziet. Een taak van meer dan één stap krijgt een geschreven plan, van maximaal acht stappen, voordat er werk begint. Dat plan wordt getoetst aan de tools die deze run mag gebruiken. Kan het niet worden uitgevoerd, dan gaat de taak zonder plan verder. Daarna neemt de agentloop het over: tot twintig rondes van tools aanroepen en resultaten lezen, met een takenlijst die je kunt volgen. Vaste stappen voor wat vaststaat. Oordeel voor wat niet vaststaat.

Een run begint niet met improviseren.

Wat vaststaat, komt eerst. Stuur je een opname, dan wordt die uitgeschreven voordat het model je vraag ooit ziet. Stuur je een afbeelding, dan wordt die eerst bekeken. Het model hoeft tot geen van beide te besluiten, en het hoeft nooit een bestand van meerdere megabytes terug te geven als toolargumenten. Dat zou traag en duur zijn, en één verkeerd teken zou het bestand beschadigen.

Een taak die als meer dan één stap is beoordeeld, kan daarna een geschreven plan van maximaal acht stappen krijgen, gemaakt voordat er werk begint. Dat hebben we bewust een aparte aanroep gemaakt. Een plan dat halverwege het werk ontstaat, is een verslag van wat er al gebeurt; een plan dat eerst komt, is een intentieverklaring die je kunt controleren. Het plan wordt getoetst aan de tools die deze run mag gebruiken, en elke stap waarvan de invoer afhangt van een eerder resultaat, wordt aan het oordeel van het model overgelaten. Mislukt het plannen, of valt de taak niet uiteen in stappen die het waard zijn om vooraf vast te leggen, dan ziet de planner ervan af en gaat de run verder zoals hij zonder plan zou doen.

Daarna neemt de agentloop het over: tot twintig rondes van tools aanroepen, resultaten lezen en bepalen wat er volgt, met een takenlijst die je in de stream kunt volgen.

Vaste stappen voor wat vaststaat. Oordeel voor wat niet vaststaat.

Waar het bij kan

Transcript (vertaald)

Een agent is maar zo nuttig als wat hij kan bereiken. Mangrove doorzoekt het web en leest de pagina’s die het vindt. Het ontleedt documenten, bekijkt afbeeldingen en schrijft vergaderingen uit. Het schrijft en draait Python in een geïsoleerde sandbox, voor berekeningen, grafieken en Word-, Excel- en PowerPoint-bestanden. Het bewaart waarden tussen runs, zodat de volgende kan vergelijken. Met jouw toestemming kan het bij je eigen werk: Outlook, OneDrive, SharePoint en elke MCP-server die je koppelt. Het kan een conceptantwoord schrijven in Outlook. Versturen kan het nooit.

Een agent is maar zo nuttig als wat hij kan bereiken. Mangrove kan standaard:

• Het web doorzoeken en pagina’s lezen, en zich daarbij houden aan de passages die ertoe doen voor wat het zoekt.
• Documenten ontleden, zoals pdf’s en Word-bestanden, via een link of een upload.
• Afbeeldingen direct bekijken, zodat grafieken en opmaak als beeld worden gezien en niet als tekst worden uitgelezen.
• Vergaderingen uitschrijven, en daarna werken vanuit het transcript met sprekers, besluiten en actiepunten.
• Python draaien in een geïsoleerde sandbox, voor berekeningen, data-analyse en grafieken, en om echte Word-, Excel-, PowerPoint- en pdf-bestanden te maken.
• Een waarde bewaren tussen runs onder een naam, zodat de run van volgende week kan vergelijken met die van deze week.

Met jouw toestemming kan het ook bij je eigen werk: zoeken en lezen in Outlook, je bestanden in OneDrive en SharePoint, en elke MCP-server die je koppelt. Het kan bestanden terugzetten in OneDrive, en het kan een conceptantwoord schrijven in Outlook.

Versturen kan het niet. Er is geen verzendtool, en het endpoint achter de concepttool kan ook niet versturen. Een antwoord komt in je map Concepten terecht en wacht daar op jou. Die limiet hebben we bewust ingebouwd, en we leggen hem liever uit dan dat we hem weghalen.

Het mag niet zelf bepalen dat het klaar is

Transcript (vertaald)

De meeste agents bepalen zelf wanneer ze klaar zijn. Mangrove laat dat niet aan het model over. Elk plan eindigt met een controle die geen enkel plan kan weghalen. Beantwoordt dit de vraag volledig? Kan een tool die je nog niet hebt gebruikt een gat dichten? Weer aan het werk gaan telt. Alleen de takenlijst afvinken niet. En als een taak niet kan, zegt de run dat. Hij eindigt als niet gedaan, met de reden erbij, in plaats van met een excuus dat als succes is gemarkeerd. Als elke tool die hij aanriep is mislukt, eindigt de run als niet gedaan, hoe zeker het antwoord ook klinkt. Een eerlijk einde hoort bij het werk.

Dit deel van Mangrove danken we aan agents die we zagen falen.

In een eenvoudige agentloop beslist het model wanneer het klaar is: het stopt met tools aanroepen, en wat het als laatste zei, is het antwoord. Mangrove laat dat niet aan het model over. Elk plan eindigt met een controle, en geen enkel plan kan die weghalen, want de runtime voegt hem toe nadat het plan is geschreven.

De controle vraagt of het antwoord de vraag volledig dekt, en of een tool die het model nog niet heeft gebruikt een gat kan dichten. De uitkomst is geen zelfrapportage. Gaat het model terug en roept het een tool aan, dan telt dat als werk. Vinkt het alleen zijn takenlijst af, dan niet, want toen we het maten, deden sommige modellen precies dat: ze zetten elk item op afgerond en stopten.

In de run van ons nieuwsoverzicht stuurde de controle de agent terug om nog twee pagina’s te lezen. Eén werd geblokkeerd. De andere liep tegen het paginabudget aan. Het antwoord dat hij daarna schreef, zei dat ook.

Dan is er nog het soort falen waar niemand graag over praat. Als je falen niet kunt melden, is een antwoord de enige manier om een run te beëindigen. Een run die niets vindt, zou dus eindigen op succeeded, met een excuus, en zijn eigenaar zou te horen krijgen dat het gelukt was. We maten dit bij een echte agent met alle tools beschikbaar: de meeste runs waarvan elke zoekopdracht mislukte, schreven toch een excuus in de vorm van een nieuwsoverzicht.

Mangrove geeft het model een uitweg. Het kan een run beëindigen als niet gedaan, met een reden die is geschreven voor de persoon voor wie de run bedoeld is. En er is een vangnet voor modellen die die uitweg niet nemen: als een run tools aanriep en ze allemaal mislukten, eindigt de run als task_not_done, hoe zeker het antwoord ook klinkt.

Een eerlijk einde hoort bij het werk.

Limieten die niet van goed gedrag afhangen

Transcript (vertaald)

De limieten van een agent horen niet af te hangen van zijn goede gedrag. Daarom houdt Mangrove ze in de runtime, niet in de prompt. Een tool die deze run niet mag gebruiken, krijgt het model nooit te zien. Roept het model hem toch aan, dan wordt de aanroep geweigerd. Aanroepen, tokens en tijd worden over de hele run geteld. En limieten worden alleen strenger. Een verzoek kan om minder vragen dan het platform toestaat, nooit om meer. Als het tokenbudget op is, wordt het werk niet weggegooid. De run schrijft één afsluitend antwoord en noemt wat hij niet heeft bereikt. Je hebt voor het werk betaald, dus je houdt wat de run heeft gevonden.

Je kunt een model vriendelijk vragen om binnen de limieten te blijven. Dat is een slechte manier om iets zonder toezicht te laten draaien, dus houdt Mangrove zijn limieten in de runtime.

Een tool die een run niet mag gebruiken, krijgt het model nooit te zien. Roept het model hem toch aan, dan wordt de aanroep op dezelfde manier geweigerd als bij een onbekende tool. Modelaanroepen, tokens en tijd worden over de hele run geteld, inclusief de eindcontrole, dus niets kan gratis rondjes draaien. Standaard krijgt een run 100 modelaanroepen, 1.000.000 tokens en 900 seconden, en de eigen limieten van een taak kunnen lager liggen: ons nieuwsoverzicht draaide met 60 aanroepen, 600.000 tokens en 600 seconden.

Limieten worden alleen strenger. Een verzoek kan om minder vragen dan het platform toestaat, nooit om meer.

Sommige details hebben we door echte incidenten geleerd. Eén gescrapete pagina van 1,3 miljoen tekens maakte van een gesprek van 5.000 tokens een verzoek van 347.000 tokens, dus elk toolresultaat is begrensd op 50.000 tekens, en het model krijgt te horen wanneer er een is afgekapt. Het tokenbudget is ook geen vaste drempel: het houdt ruimte vrij voor een stap die even groot is als de grootste waarvoor de run al heeft betaald, omdat de prompt met elk resultaat groeit.

Wat er bij de limiet gebeurt, is misschien wel het nuttigste deel voor iedereen die agents bouwt. Als het tokenbudget op is, sterft de run niet. Hem weggooien zou de duurste uitkomst zijn die er is: je betaalt dan voor elke aanroep en krijgt een foutmelding. In plaats daarvan stopt hij met werken en doet hij één afsluitende aanroep zonder tools, zodat hij niets nieuws kan beginnen, en schrijft hij op wat hij heeft en noemt hij wat hij niet heeft bereikt.

Je hebt voor het werk betaald, dus je houdt wat de run heeft gevonden.

Het handelt voor jou, en alleen onder jouw identiteit

Transcript (vertaald)

Een run handelt voor jou. Dus mag hij alleen onder jouw identiteit handelen. Voordat hij start, neemt een run de identiteit van zijn eigenaar aan en controleert hij of het de juiste is. Mislukt die controle, dan start de run niet. Bewaarde waarden zijn gekoppeld aan die eigenaar. Mail en bestanden worden bereikt via verwijzingen die voor die ene run zijn gemaakt. Tools van je gekoppelde servers zijn afgeschermd, en de run krijgt te horen dat hij wat ze teruggeven als gegevens moet behandelen, niet als opdrachten. Python draait in zijn eigen geïsoleerde sandbox. Outlook kan een concept opslaan, zonder manier om het te versturen. En elke koppeling wacht tot je zelf de schakelaar omzet. Hij kan veel. Maar alleen onder jouw identiteit.

Een run die je mail kan lezen, heeft een duidelijk antwoord nodig op de vraag wiens mail hij leest.

Voordat een run start, neemt hij de identiteit van zijn eigenaar aan en controleert hij of de identiteit die hij kreeg overeenkomt met de eigenaar op de run. Komt die niet overeen, dan start de run niet. Er is geen reserveaccount. De opslag voor bewaarde waarden heeft geen veld voor wiens gegevens het betreft, dus een toolaanroep kan niet bij die van iemand anders komen. Mail en bestanden worden bereikt via verwijzingen die voor die ene run zijn gemaakt, dus het model heeft een verwijzing in handen, geen mailbox.

Servers die je via MCP koppelt, houden we op afstand. Hun toolbeschrijvingen zijn afgeschermd, en de run krijgt te horen dat wat ze teruggeven gegevens zijn, geen opdrachten. De worker die je agent draait, ziet hun adressen nooit. Elke koppeling, en elk schrijfrecht zoals concepten of bestanden opslaan, wacht tot je zelf de schakelaar omzet.

We beweren niet dat een run daardoor onmogelijk te misleiden is. Een agent leest dingen die vreemden hebben geschreven, en dat risico verdwijnt niet doordat je een zorgvuldige prompt hebt geschreven. Daarom beperken we ook wat een misleide run zou kunnen doen: hij kan je mail niet versturen, zijn code draait geïsoleerd en hij kan alleen gebruiken wat je hebt gekoppeld.

Een run die kan wachten op schonere stroom

Transcript (vertaald)

Sommig werk hoeft niet nu meteen te gebeuren. Voeg één veld toe, en een run mag tot vierentwintig uur later starten. Mangrove leest de netprognose en zoekt de schoonste start in dat venster. Zou wachten minder dan vijf procent besparen, dan start hij meteen. Is er geen prognose te lezen, dan start hij ook meteen. Een CO₂-controle vertraagt een run nooit en laat hem nooit mislukken. Hoe dan ook vertelt de response je wat er is besloten, en hoeveel dat scheelt. Hetzelfde werk, op een schoner uur.

Dit is de functie die het meest zegt over wie hem heeft gebouwd.

Sommig werk hoeft niet nu meteen te gebeuren. Een weekrapport kan best een paar uur wachten. Voeg één veld toe, en een run mag tot 24 uur later starten:

{
  "question": "Summarise the EU grid carbon intensity news from this week",
  "greenShiftWindowHours": 8
}

Mangrove leest de prognose van de CO₂-intensiteit voor het stroomnet waarop zijn modellen draaien, en houdt de run vast tot de schoonste start in dat venster. Het let goed op wanneer dat de moeite waard is. Zou wachten minder dan 5% besparen, dan start de run meteen, want daaronder kost uitstel jou meer dan het het net bespaart. Is er geen prognose te lezen, dan start hij ook meteen. Een CO₂-controle vertraagt een run nooit en laat hem nooit mislukken.

De response vertelt je wat er is besloten: held, run_now of unavailable, de geplande start, de CO₂-intensiteit in gCO₂e/kWh met en zonder wachten, en de besparing. Op een net dat al schoon en stabiel is, starten de meeste runs gewoon op tijd. Dan doet de regel zijn werk, en dat lees je terug in de response.

Agents die je bewaart

Transcript (vertaald)

Een run is één taak. Een agent is een klus die je bewaart. Beschrijf het werk in de chat. GreenPT vraagt de paar dingen die het nodig heeft en maakt dan een concept van de agent: zijn instructies, zijn schema en een taak om hem te testen. Bewaar je hem, dan heeft hij zijn eigen pagina, met elke run en elk resultaat. Op een schema is er niemand om antwoord te geven. Daarom krijgt de run geen manier om iets te vragen. Via de API is het één aanroep om aan te maken en één adres om uit te voeren. Werk dat je één keer beschrijft, telkens opnieuw gedaan.

Een run is één taak. Een agent is een klus die je bewaart.

Beschrijf het werk in de chat van GreenPT, en die vraagt de paar dingen die hij moet weten: wanneer het werk moet draaien, hoe het resultaat je moet bereiken en of de klus mag wachten op schonere stroom. Daarna maakt hij een concept van de agent, met zijn instructies, zijn schema en een taak om hem te testen. Er wordt niets opgeslagen tot je het accepteert. Bewaar je hem, dan heeft hij zijn eigen pagina, met elke run en elk resultaat.

Een ingeplande run is anders dan een run die je volgt, want er is niemand om antwoord te geven. Daarom krijgt een ingeplande run geen manier om iets te vragen. Hij werkt de opdracht af met wat hij heeft en meldt wat hem niet lukte.

Developers krijgen hetzelfde in twee aanroepen: één om een agent aan te maken, en één om hem op zijn eigen adres uit te voeren.

POST /v1/agent-profiles
POST /v1/agent-profiles/weekly-report/runs

Elke stap vastgelegd

Transcript (vertaald)

Je zou een agent niet op zijn woord moeten hoeven geloven. Elke run streamt wat hij doet: elke stap, elke toolaanroep en elk resultaat. Hij legt ook vast wat hij over zichzelf heeft besloten: hoe de taak is beoordeeld, welk plan hij koos en welk budget hij kreeg. Veertien regels gelden voor elke trace, wat het model ook kiest, en tests bewaken dat. Zijn modelaanroepen melden hun energie en uitstoot, dus een run telt op tot één getal, in wattuur. Elke stap, vastgelegd.

Je zou een agent niet op zijn woord moeten hoeven geloven.

Elke run streamt wat hij doet: elke stap, elke toolaanroep en elk resultaat. Hij legt ook vast wat hij over zichzelf heeft besloten, als decision-events: hoe de taak is beoordeeld en hoe zeker die beoordeling was, welk plan hij koos, welk budget hij kreeg, waarom hij stopte. Liep een classifier in een time-out, dan staat dat in de trace, want “nooit geclassificeerd” en “geclassificeerd als algemeen” zijn verschillende feiten.

Veertien regels gelden voor elke trace, wat het model ook kiest: een toolaanroep krijgt altijd antwoord, stappen overlappen nooit, een plan komt altijd vóór de uitvoering, een run eindigt nooit twee keer. Tests houden de runtime daaraan, dus een regressie verschijnt als een gebroken regel en kan zich niet verstoppen in de normale variatie van een model.

En een run telt op tot één getal. De modelaanroepen in een run melden hun energie en uitstoot via hetzelfde impactrapport als elke GreenPT API-response, en de run houdt het totaal bij. Ons nieuwsoverzicht gebruikte 1,96 Wh en 0,14 g CO₂e. Over 21 afgeronde runs in één benchmark op onze teststack liep dat uiteen van 0,49 Wh tot 13,61 Wh, met een mediaan van 4,7 Wh. Deze totalen dekken de modelaanroepen in de eigen loop van de run. De beoordeling door Metis en tools zonder model, zoals zoeken, zitten er niet in.

Waarom we denken dat dit anders is

De meeste agentframeworks geven je onderdelen. Mangrove is een complete run, met een eigen mening:

• Het beoordeelt voordat het uitgeeft. Een beslismodel bepaalt de omvang van elke taak in milliseconden, zonder een woord te schrijven.
• Het heeft een besef van genoeg. Budgetten komen uit de taak en worden buiten het model afgedwongen.
• Het kan niet stilletjes doen alsof het gelukt is. Een run die is mislukt, zegt dat hij is mislukt, met een reden.
• Het houdt vast waarvoor je hebt betaald. Als het budget op is, krijg je een antwoord dat zijn gaten noemt.
• Het weet wat het heeft gebruikt. Energie en uitstoot komen met de run mee, in Wh en gram.
• Het kan wachten. Een run kan wachten op een schoner uur en je vertellen wat dat heeft bespaard.

Wat Mangrove niet doet

Een run is één uitwisseling. Hij begint met een schone lei, kan niet worden hervat, en een vervolgvraag is een nieuwe run. Citeer dus het deel van het vorige antwoord waarop je wilt voortbouwen.

De kosten van een run zijn bij de start niet bekend, omdat Mangrove bepaalt hoeveel stappen een taak nodig heeft. Twee runs van dezelfde vraag kunnen verschillende bedragen kosten.

Een taak die meer dan twintig rondes nodig heeft, komt magerder terug in plaats van te mislukken. Hem opsplitsen in smallere vragen helpt.

Waar we staan

Mangrove zit in private bèta, op de abonnementen Pro, Pro Max, Teams en Enterprise, en runs worden betaald uit je API-credits. Tijdens de bèta staat niet elke functie uit dit artikel voor elk account aan. De run van het nieuwsoverzicht bovenaan dit artikel kwam van onze teststack, met alle functies aan.

Wil je het proberen? De Mangrove-documentatie heeft een quickstart en uitgewerkte voorbeelden, en je kunt toegang vragen op onze Discord.

Vertel ons wat je er als eerste aan zou geven.