Elk bestand dat je agent leest blijft op de rekening staan. Eén refactor kostte $14,29

Het contextbelastingmechanisme in Sonars eigen woorden — elk bestand dat de agent leest blijft resident in de gesprekscontext voor de rest van de run — naast de gemeten mediane kosten van losse refactortaken, van een Java-wijziging die daalt van $14,29 naar $9,38 voor de grootste besparing van 34% tot een TypeScript-wijziging die slechts van $9,45 naar $8,89 gaat, de kleinste, met 6% — De besparing hangt af van het soort taak en loopt van 6% tot 34%. Het cijfer om te onthouden staat links van elke pijl: wat het werkelijk kost om één refactorcommit te draaien.

Sonar publiceerde deze week een kostenmeting die nuttiger is dan het product dat het verkoopt.

De kop luidt dat semantische codenavigatie coding agents goedkoper maakt. Dat klopt, en het effect is bescheiden en taakafhankelijk. Het cijfer dat ik zou opschrijven is de basislijn: één gedragsbehoudende refactor van een open source Java-klasse kostte $14,29 aan modeluitgaven.

Geen sprint. Geen feature. Eén commit.

1. Wat er is gemeten, en hoe zorgvuldig

De methodologie verdient krediet vóór de bevindingen, want ze is strenger dan die van de meeste leveranciersbenchmarks.

Sonars opzet

Zes refactorcommits uit echte open source projecten

Projecten: Apache Commons Collections, SQLAlchemy, TanStack Query, AssertJ, QuartzNET.
Talen: Java, Python, TypeScript, C#.
Referentie-agent: Claude Opus 4.8 op hoge inspanning, subagents aan.
Runs: tien per kant, per taak.
Het filter: een run telt alleen als hij compileert en de betreffende tests slagen.

Die laatste regel maakt de rest het lezen waard. Een kostenvergelijking waarbij de goedkopere kant mag falen is geen kostenvergelijking — het is een meting van hoe snel je iets fouts kunt produceren. Filteren op compileren en tests is dezelfde discipline als Thinkingbox dat de database beoordeelt in plaats van de transcriptie, en het is nog steeds zeldzaam genoeg om te benoemen.

2. Het mechanisme: residentie, niet lezen

Dit is de zin die het hele verschijnsel verklaart, in Sonars eigen woorden:

Elk bestand dat de agent leest om die kaart te bouwen blijft resident in de gesprekscontext voor de rest van de run.

Dit is wat de meeste kostendiscussies missen. Het dure is niet het lezen van het bestand. Het is dat het bestand, eenmaal gelezen, wordt meegedragen in de context en bij elke volgende beurt van de lus opnieuw wordt gefactureerd.

Lees acht bestanden bij beurt drie van een run van veertig beurten en je hebt niet acht bestandslezingen betaald. Je hebt acht bestanden × zevenendertig beurten betaald.

En dat agents hele bestanden lezen is structureel: tekstzoeken vindt wáár een symbool voorkomt, maar kan niet beantwoorden "waar wordt dit echt gebruikt" — dus opent de agent kandidaten om erachter te komen. Wat Sonar bouwde is een bevraagbare graaf van de code (klassen, methodes, velden, interfaces en hun relaties) die trace-callers of get-type-hierarchy rechtstreeks beantwoordt, zodat er minder bestanden in de context belanden.

Waarom dit dezelfde kwaal is als de MCP-toolcatalogus

In het stuk over de MCP-roadmap waren de kosten de toolcatalogus: elke tool, beschrijving en parameterschema bij sessiestart in de context geladen, of de taak ze nodig had of niet, en bij de volgende taak opnieuw betaald. Hier zijn het bronbestanden. Dezelfde kwaal, andere drager: content die onvoorwaardelijk wordt geladen en daarna herhaaldelijk gefactureerd. De remedie is ook dezelfde: maak het laden voorwaardelijk en laat de agent ophalen wanneer nodig.

3. Wat één taak werkelijk kost

De absolute cijfers zijn het deel waar founders bij stil zouden moeten staan, want vrijwel niemand heeft de zijne gemeten.

Java · BloomFilter self-typing

$14,29 → $9,38

De duurste taak in de set en de grootste besparing, −34%. Een gedragsbehoudende wijziging herhaald over elke implementatie van een gedeelde abstractie — de vorm van werk waarin navigatie domineert.

C# · QuartzNET returntypes

$10,20 → $8,11

−20%. Alleen mediaan gemeten. Let op de basislijn: tien dollar om returntypes in een codebase te wijzigen.

TypeScript · TanStack mutation context

$9,45 → $8,89

−6%, de kleinste winst in het onderzoek. Duur om te draaien, en nauwelijks verbeterd door betere navigatie — want navigatie was niet wat hem duur maakte.

Java · BloomFilter package rename

$1,86 → $1,40

−25%. Een herinnering dat de spreiding tussen taken ongeveer een factor acht is, dus elk cijfer per taak — dit ook — is een slechte basis voor een budget.

De tokens volgden het geld: inputtokens 11–31% omlaag, outputtokens 4–35%.

4. "Tot 36%" betekent ook "slechts 6%"

Het marketingcijfer bij dit werk is "tot 36% goedkoper". Het gemeten bereik loopt ruwweg van −6% tot −34%, en de auteurs zeggen zelf waarom:

De navigatiemotor zal niet helpen bij taken waar navigatie niet de beperking is.

Ze gaan verder en merken op dat de winst optrad bij "dezelfde kleine, gedragsbehoudende wijziging, herhaald over elke implementatie van een gedeelde abstractie", en dat "de winst gebonden is aan het soort werk, en dus niet bij elke taak beloofd wordt".

Dat is ongebruikelijk eerlijk voor leveranciersonderzoek, en het verdient krediet in plaats van hoongelach. Sonar verkoopt de oplossing, dus verdisconteer het kader — maar ze publiceerden de taak waar hun product slechts 6% haalde, benoemden de voorwaarde waaronder het niets doet, en gaven aan dat hun graaf precisie in typeresolutie inruilt tegen een compiler in ruil voor versheid. De meeste leveranciersbenchmarks doen geen van die drie.

5. Wat dit betekent als je met agents uitrolt

De besparing is niet de les. De les is dat kosten per taak nu een echt getal zijn en dat je het jouwe waarschijnlijk niet kent.

Kosten per afgeronde taak

Meet

Niet tokens per maand. Neem vijf taken die je team echt draait, noteer de modeluitgaven van elk van eerste prompt tot slagende tests, en let op de spreiding. Sonars taken liepen van $1,71 tot $14,29 — een factor acht op dezelfde opzet. De jouwe wordt groter.

Contextresidentie, niet lezen

Let op

De kostendrijver is wat in de context blijft, niet wat wordt opgehaald. Langlopende lussen die vroeg bestanden openen en ze nooit loslaten zijn het dure patroon, en het wordt erger naarmate de run langer duurt — het tegendeel van de intuïtie dat late beurten goedkoop zijn.

De beperking die je echt hebt

Repareer eerst

Is navigatie niet wat je taken duur maakt, dan koopt een navigatietool je 6%. Kijk waar je tokens heen gaan voordat je een oplossing koopt — hetzelfde advies geldt voor elke tool in deze categorie, deze inbegrepen.

Er is ook een rechtstreeks verband met McKinseys bevinding van gisteren dat 32% van de organisaties een softwareaankoop oversloeg om met coding agents te bouwen. Als één refactor tien dollar aan modeluitgaven kost, heeft de businesscase "dat bouwen we zelf wel" een regel nodig die de meeste van die beslissingen niet hadden. Dat maakt de beslissing niet fout. Het maakt de rekensom minder vanzelfsprekend dan hij in een demo lijkt.

6. Wat ik er niet in zou lezen

Zes taken blijven zes taken. Echte refactors uit echte projecten, veel beter dan synthetische, maar een steekproef van deze omvang ondersteunt een richting en geen percentage. De eerlijke bewering is "navigatiezware refactors werden merkbaar goedkoper bij deze zes", niet "je rekening daalt met een derde".

De basislijn is een dure configuratie. Opus 4.8 op hoge inspanning met subagents zit per ontwerp dicht bij de bovenkant van de kostencurve — dat is de juiste keuze om een plafond te meten, en het betekent dat deze dollarbedragen niet zijn wat een goedkoper model op een kleinere codebase zou opleveren.

Kosten zijn niet de enige as. Een configuratie die minder bestanden leest is goedkoper en kan ook slechter geïnformeerd zijn. Het compileren-en-testen-filter beschermt tegen de grofste versie daarvan, maar zegt niet of de wijziging goed was — alleen dat hij bouwde en de betreffende tests groen bleven.

De eerlijke samenvatting

Sonar mat wat een coding agent kost om een echte refactorcommit af te ronden, gefilterd op compileren en slagende tests, en publiceerde het bereik: $1,71 tot $14,29 per taak op een frontier-configuratie met hoge inspanning. Semantische navigatie sneed dat met 6% tot 34%, afhankelijk van of navigatie de bindende beperking was.

Het mechanisme is het meenemen waard, ook als je het product nooit koopt: een bestand dat je agent leest wordt niet één keer gefactureerd, het wordt elke beurt gefactureerd tot de run eindigt. Daarom worden lange agentlussen duur op een manier die niet in verhouding voelt tot het verzette werk, en het is dezelfde vorm als het MCP-toolcatalogusprobleem.

Ga vijf van je eigen taken van begin tot eind meten. Het interessante getal is niet de korting die iemand verkoopt. Het is de basislijn waar je nooit naar hebt gekeken.

Bronnen: Sonar, "Cut your coding agent's cost with semantic code navigation" · Productpagina Sonar Vortex · Documentatie Sonar Vortex context · De taakkosten, tokenverschillen, methodologie en geciteerde voorbehouden zijn zoals gepubliceerd door Sonar, dat de gemeten tool verkoopt; de lezing en de voorbehouden in sectie 6 zijn van mij.

De MCP-roadmap geeft toe dat het protocol is gebouwd voor een mens achter een laptop24 augustus 2026

Microsoft draaide dezelfde agenttaak twintig keer. Het cijfer zakte van 65% naar 25%27 augustus 2026

The Multi-Model Stack: How Startups Are Cutting AI Coding Costs by 85% in 2026July 8, 2026

IdeaToMVP Academy

Want to build with AI — not just read about it?

4-week live cohort for founders. Learn to ship AI agents, scope MVPs, and automate your business — taught by the same team that writes these guides.

Explore the Academy →