I thought I was being clever. I wrote a helper function that reserved exactly thirty percent of the context window as a

Ik dacht dat ik slim bezig was. Ik schreef een helperfunctie die precies dertig procent van het context window reserveerde als een denkbudget voor onze AI-pipeline. Het was schoon, voorspelbaar en het werkte prachtig op Opus 4.5. Toen ik overstapte naar Opus 4.8, ging elke aanvraag dood met een 400-fout. Mijn zorgvuldig uitgedachte token-berekeningen waren van de ene op de andere dag waardeloos geworden.

Het oude patroon was simpel. Je stelde een budget_tokens-waarde in en het model verdeelde zijn denkproces om binnen die limiet te blijven. Als ik een context van 128K overhandigde, reserveerde mijn code ongeveer 38.000 tokens voor reasoning en liet de rest over voor het antwoord. Het voelde verantwoordelijk. Alsof je een auto onder de snelheidslimiet houdt.

Dat model is verdwenen. Nieuwere releases zoals Opus 4.7 en 4.8 gebruiken adaptive thinking. Je kiest niet langer een getal. In plaats daarvan geef je een effort-knop door. Dat klinkt als een naamswijziging, maar de twee besturingen zouden niet verder uit elkaar kunnen liggen. budget_tokens stelde een hard plafond in voor hoeveel het model mocht nadenken. Effort bepaalt hoe het model in de eerste plaats denkt en handelt. De één is een brandstofmeter; de ander is de engine map.

Effort koppelen aan echt werk

Toen de besturing veranderde, werkte mijn oude intuïtie niet meer. Ik moest opnieuw leren wat elke instelling in de praktijk oplevert. Ik heb tests uitgevoerd op ons interne verkeer om te ontdekken waar elk effort-niveau in de praktijk uitkomt.

Classificatie en routing moet bijna altijd low effort gebruiken. Dit zijn snelle beslissingen. Is dit een restitutieverzoek of een verkoopvraag? Moet deze log-entry worden geëscaleerd? Je hebt geen monoloog nodig. Lage effort houdt de latency laag en de kosten verwaarloosbaar klein.

De meeste app-traffic, het dagelijkse werk van samenvattingen, herschrijven, support-antwoorden en content-extractie, past bij medium tot high effort. Dit is het balanspunt. Het model krijgt genoeg ruimte om echte ambiguïteit op te lossen zonder tokens te verspillen aan een taak die geen uitgebreide chain of thought nodig heeft.

Coderen en agentic loops hebben xhigh effort nodig. Dit is waar fouten zich opstapelen. Als het model in de eerste beurt van een tool-calling loop een slecht plan schrijft, zal het de volgende drie stappen besteden aan het herstellen van de schade. Of erger nog, het roept de verkeerde tools aan, hallucineert parameters en laat de gebruiker staren naar een kapotte workflow. Betere reasoning vooraf voorkomt die spiraal.

Kritieke taken moeten max effort krijgen. Gebruik dit niet voor alles. Reserveer het voor de momenten waarop een fout antwoord meer kost dan welke tokenrekening dan ook. Financiële reconciliaties, veiligheidscontroles, architectuurkeuzes en medische triage zijn hiervoor geschikt. Als een fout betekent dat een mens urenlang de puinhoop moet opruimen, betaal dan voor het extra denkwerk.

De verrassing qua kosten

Hier is het deel dat mijn mentale model verbrak. Ik nam aan dat max effort mijn kosten altijd zou laten exploderen. Bij een enkele beurt gebeurt dat ook. De reasoning trace is langer. Maar bij agentic taken met meerdere stappen daalde de totale rekening vaak juist.

Het model plant beter bij de eerste poging. Het doet minder tool calls. Het voorkomt dat het zichzelf in doodlopende wegen manoeuvreert. Ik zag een data-extractie-agent die normaal gesproken vijf heen-en-weer beurten nodig had, in twee beurten klaar zijn omdat het model genoeg reasoning-ruimte had om het schema aan het begin correct te parsen. Wanneer je de kosten meet, kijk dan naar de voltooiing van de taak, niet naar de aanvraag. Een groter denkbudget per stap kan betekenen dat er in totaal minder stappen nodig zijn.

Hoe te migreren zonder de rest te breken

Als je nog steeds budget_tokens in je codebase hebt rondzweven, is dit het exacte pad naar buiten. Sla stappen drie en vijf niet over. Dat deed ik wel, en dat kostte me een middag debuggen.

Zoek in je code naar budget_tokens. Elke instantie moet weg. Deze parameter is dood op nieuwere modellen en zal een 400-fout triggeren.

Vervang het budget-object door een adaptive thinking block. Gebruik thinking: { type: "adaptive" }.

Voeg output_config toe met een expliciet effort-niveau voor elke call. Laat dit niet over aan een globale standaard als je verkeer gemengd is. Je lichtgewicht classificatie-endpoint moet niet per ongeluk dezelfde effort-instelling erven als je coding agent. Wees expliciet bij de aanroep.

Verwijder je helperfunctie voor budgetberekeningen. Ik weet het. Die heeft waarschijnlijk unit tests. De mijne ook. Maar het is nu ballast. Het platform wil niet jouw token-berekeningen. Het model regelt zijn eigen tempo.

Verwijder temperature, top_p en top_k. Bij Opus 4.7 en 4.8 zullen deze sampling-parameters 400-fouten veroorzaken. Het platform heeft ze uit deze generatie verwijderd. Je oude trucjes voor het tunen van de temperature zijn hier niet van toepassing, en als je ze laat staan, zal je migratie stilletjes mislukken.

Test elk model afzonderlijk. Opus 4.5 en 4.8 zijn totaal verschillende beesten. Een configuratie die op de ene werkt, werkt niet noodzakelijkerwijs op de andere. Als je meerdere versies ondersteunt, splits dan je logica of behandel ze als aparte backends.

Het oplossen van de UI-freeze

Er is één streaming-gedrag dat je gebruikers in verwarring zal brengen als je het niet afhandelt. Bij de nieuwe modellen worden thinking blocks gestreamd, maar is de tekst standaard leeg. In je interface ziet dit eruit als een lange, ongemakkelijke pauze zonder zichtbare voortgang. Gebruikers zullen denken dat de app is vastgelopen.

Om dit op te lossen, geef je thinking: { type: "adaptive", display: "summarized" } door. Hiermee krijg je een zichtbare voortgangsindicator zonder de ruwe thought stream in het chatvenster te dumpen. Je frontend blijft responsief en je gebruikers weten dat er op de achtergrond iets gebeurt.

De echte les

Ik heb een volledige abstractielaag gebouwd bovenop een parameter die de leverancier nooit bedoeld had om blijvend te zijn. Ik heb hun instellingen in mijn eigen logica verpakt omdat ik dacht dat ik de afweging beter begreep dan het platform. Dat deed ik niet. Adaptive thinking is een betere deal, omdat het model zelf beslist wanneer het diep moet nadenken en wanneer het op de automatische piloot kan gaan. Mijn codebase is nu kleiner. De resultaten zijn scherper geworden. Soms is de juiste engineering-stap om de slimme code te verwijderen en het platform zijn werk te laten doen.

Als je de originele migratie-notities wilt lezen, kun je ze hier vinden. Voor meer hands-on discussies zoals deze, word lid van de GyaanSetu AI community op Telegram.