Agent Native worden: waarom ik stopte met het najagen van modellen

Agent Native worden: waarom ik stopte met het najagen van modellen

Ik had bijna weer een modelvergelijking geschreven. Ik had het tabblad al open — Opus 4.8 links, GPT-5.5 rechts, de benchmark-grafiek gescreenshot, de "welke wint" kop half getypt. Toen betrapte ik mezelf op precies het gedrag waar ik mensen steeds voor waarschuw.

Ik behandelde het model alsof het het product was.

Dat is het niet. Niet meer. Ergens in de afgelopen zes weken — tussen de lancering van Claude Opus 4.8 op 28 mei en OpenAI die stilletjes Windows-computerbesturing voor Codex activeerde de dag erna — verschoof het zwaartepunt. Het slimste model is niet langer het belangrijkste. Wat nu telt is of jij agent native bent: of je hebt gereorganiseerd hoe je werkt rond agents, of dat je nog steeds in een chatvenster zit te prikken en hoopt dat de volgende puntrelease je redt.

Dat is de verschuiving waar ik het over wil hebben. Niet "welk model is het beste" — ik geef je mijn eerlijke beoordeling van Opus 4.8 versus GPT-5.5, want de cijfers zijn oprecht interessant en een ervan verrast je waarschijnlijk. Maar de modelstrijd is het kleine verhaal. Het grote verhaal is dat de applicatielaag zojuist belangrijker is geworden dan de modellaag, en de meeste ontwikkelaars hebben het nog niet door. Aan het einde hiervan heb je een duidelijk antwoord op een vraag waarvan je niet wist dat je hem moest stellen: produceer ik met deze agents, of word ik erdoor geconsumeerd?

Laat me je laten zien wat ik bedoel, te beginnen met het model waar niemand wakker van zou moeten liggen.

De Opus 4.8-release die aanvoelde als een iPhone-update

Hier komt een bekentenis die me in de problemen brengt bij de Anthropic-fans: ik heb Claude Opus 4.8 twee dagen lang naast Opus 4.7 gedraaid, op echte klantcode, en ik kon ze nauwelijks uit elkaar houden.

Niet op de slechte manier. Op de manier van een volwassen product. Je weet hoe een nieuwe iPhone landt en de camera technisch beter is en de chip technisch sneller is en na een week kun je oprecht niet meer herinneren welke je vasthoudt? Dat is Opus 4.8. Anthropic bracht het uit op 28 mei 2026 als een puntrelease bovenop 4.7, behield hetzelfde 1M-token contextvenster en hetzelfde tarief van $5/$25 per miljoen tokens, en maakte de snelle modus ongeveer 3x goedkoper. De hoofdfunctie in hun eigen framing is eerlijkheid — het model laat volgens de 244 pagina's tellende systeemkaart ongeveer vier keer minder vaak dan 4.7 een fout in zijn eigen code onopgemerkt voorbijgaan.

Die eerlijkheid is echt, en ik ben er dol op. Ik heb Opus 4.8 zien stoppen midden in een taak en me vertellen "Ik heb er niet veel vertrouwen in dat dit het concurrency-geval afhandelt, je zou het moeten bekijken" in plaats van de overwinning te claimen en het veld te verlaten. Als je mijn diepgaande analyse van Opus 4.8 inspanningsniveaus hebt gelezen, weet je al dat dit het meest onderschatte aspect van deze release is.

Maar van dag tot dag? Het verschil met 4.7 is klein. Uren van directe vergelijking en het eerlijke oordeel is: dit is een incrementele verfijning van een al uitstekend model, geen sprong. En dat is prima. Zo ziet een gezonde productlijn eruit. Het tijdperk waarin elke modelrelease je hele workflow overhoop gooit, loopt ten einde. We betreden de saai-maar-goed fase, waarin het model een betrouwbaar hulpmiddel is en het interessante werk ergens anders gebeurt.

Wat me brengt bij de benchmark waar iedereen over ruziemaakt — en de enige plek waar Opus 4.8 daadwerkelijk verliest.

Waar Opus 4.8 wint, en de ene benchmark die het verliest van GPT-5.5

Laat me je de echte cijfers geven, want de video die aanleiding gaf tot dit hele artikel had ze goed, en de nuance is belangrijk.

Op SWE-Bench Pro — de benchmark die het oplossen van echte GitHub-issues in een volledige codebase meet — scoort Opus 4.8 69,2%, omhoog van 64,3% bij 4.7. GPT-5.5 staat op 58,6%. Dat is geen afrondingsfout. Op het soort multi-file, "ga deze bug fixen in onze echte repo" werk dat mijn rekeningen betaalt, loopt Opus duidelijk voor.

Dan kom je bij Terminal-Bench 2.1 — agentische terminal-codering, de wereld van lange shell-commandoketens, CI-orkestratie, infrastructuurscripts — en het beeld draait om. GPT-5.5 scoort 78,2% tegenover 74,6% van Opus 4.8. Dat is een echt verlies voor Anthropic, en ik ga niet doen alsof het anders is. Wanneer de hele taak in de terminal leeft, is Codex met GPT-5.5 net wat zekerder. Ik heb het gevoeld bij het draaien van beide in dezelfde repo.

Hier is het deel dat me verraste — het deel dat de specificaties niet vastleggen. Kostenefficiëntie. GPT-5.5 is op papier goedkoper (ruwweg $1,25 input / $10 output per miljoen tokens versus Opus op $5 / $25). Maar het grotere verhaal is gedrag. Artificial Analysis ontdekte dat Opus 4.8 breedsprakig is — het heeft ongeveer 30% meer beurten nodig dan GPT-5.5 om agentische taken af te ronden. Meer beurten betekent meer tokens, meer kloktijd, en bij een lange autonome loop telt dat snel op. Dus bij een diep, meerdere uren durend agentisch werkproces eindigt GPT-5.5 vaak goedkoper en sneller, en veel mensen die ik vertrouw melden meer vertrouwen bij het toevertrouwen van het echt kritieke werk.

Dus wie wint?

Verkeerde vraag. Hier is hoe ik het daadwerkelijk routeer, en het is het nuttigste in heel deze sectie:

• Complex codebase-werk, code review, alles waar ik wil dat het model zijn eigen fouten opvangt → Opus 4.8. De SWE-Bench Pro-kloof en de eerlijkheidsupgrade verdienen het.
• Terminal-zwaar, infra, CI, lange autonome loops waar tokenkosten oplopen → GPT-5.5 in Codex. De efficiëntie en terminal-voorsprong zijn echt.
• Grote hoeveelheden eenvoudige taken → een goedkoper model. Een frontier-model verbranden op string-formatting is hoe je een verrassingsfactuur krijgt.

Die routeringsdiscipline alleen al bespaart aanzienlijk op mijn modeluitgaven versus het proppen van één frontier-model in elke klus. Als je de volledige vergelijking wilt, heb ik GPT-5.5 versus Opus 4.7 in detail hier uitgewerkt, en 4.8 verandert de vorm van die conclusie niet — het verscherpt haar.

Maar merk op wat er net gebeurde. Ik heb drie alinea's besteed aan het vertellen dat je modellen van twee verschillende bedrijven voor verschillende klussen moet gebruiken. Het model is geen stam waar je bij hoort. Het is een gereedschap dat je routeert. En het ding dat de routering doet — de plek waar je daadwerkelijk leeft en werkt — dat is de laag die net interessant is geworden.

Het echte verhaal is dat Codex een besturingssysteem wordt

Terwijl iedereen de Opus 4.8 benchmark-grafiek aan het screenshotten was, was OpenAI stilletjes bezig Codex te transformeren tot iets dat er veel minder uitziet als een coderingstool en veel meer als een besturingssysteem voor agents. Dit is waar mijn aandacht deze maand echt naartoe ging, en ik denk dat de jouwe dat ook zou moeten doen.

Loop door wat er is uitgebracht:

Windows-computerbesturing. Op 29 mei 2026 activeerde OpenAI volledige computerbesturing voor Codex op Windows — de agent kan zien, klikken en typen in Windows-applicaties, niet alleen een gesandboxte browser. De agent verliet de IDE en wandelde de hele machine in.

Afstandsbediening vanaf je telefoon. Codex toont een QR-code, je scant deze met de ChatGPT mobiele app, en nu stuur je een Codex-sessie op je desktop aan vanuit je telefoon — Windows of Mac. Ik startte een refactor vanaf mijn laptop, liep naar de lunch, controleerde de voortgang en stuurde bij vanuit mijn telefoon, en kwam terug bij een afgeronde branch. De desktop werd een werker die ik op afstand begeleid in plaats van een stoel waaraan ik geketend ben.

Persistente ingelogde browsertabbladen. De interne browser van Codex behoudt nu inlogstatus over meerdere tabbladen, als een echte Chrome-sessie. Dat klinkt alledaags. Dat is het niet. Het is het verschil tussen een agent die alleen openbare pagina's kan aanraken en een die kan opereren in je daadwerkelijke geauthenticeerde tools.

Multi-agent thread-orkestratie. Je kunt een masterprompt opstarten die meerdere sub-agent threads aanstuurt, elk werkend aan een stuk van een grotere taak, gecoördineerd over projecten en git worktrees. Dit is agent-teamwork als eersteklas functie, geen hack. Als multi-agent orkestratie nieuw voor je is, behandelt mijn gids voor Opus agent-teams hetzelfde patroon vanuit de Claude-kant — de concepten zijn direct overdraagbaar.

In-chat zoeken over elk gesprek, plus een GitHub-achtige activiteitenpagina die dagelijkse streaks, taakduur en tokengebruik bijhoudt. Ze gamificeren je agentgebruik op de manier waarop GitHub commits gamificeerde. Dat is een teken van waar dit naartoe gaat.

Samengenomen verandert de framing volledig. Codex is niet langer "een AI die code schrijft." Het is een multi-device, multi-agent besturingsoppervlak dat reikt in je bestanden, je browsersessies, en nu je hele desktop. Ik testte een eerdere golf hiervan en schreef het op in mijn volledige Codex super-app review — maar elke update duwt het verder van "app" richting "omgeving waarin je leeft." Het model erin is bijna bijzaak. Het platform is het product.

En zodra je Codex als platform ziet in plaats van als tool, begint een voorspelling die zes maanden geleden als sciencefiction klonk voor de hand liggend te worden.

Vibe coding wordt een functie, geen product

Weet je nog toen "vibe coding" inhield dat je je aanmeldde bij een speciaal platform? Je ging naar Replit of Lovable of Bolt, beschreef je app, en het scaffolde, hostte, koppelde auth, en provisioneerde een database. Die platforms doen het op papier prima — Lovable heeft naar verluidt 8 miljoen gebruikers en $200 miljoen ARR bereikt, Bolt bereikte $40 miljoen ARR in minder dan vijf maanden. De categorie is echt en groeit.

Maar kijk waar de zwaartekracht naartoe trekt.

Waarom een apart vibe-coding platform openen als de agent die al je terminal draait de app kan genereren, previewen, hosten, en auth en een database kan opzetten vanuit één prompt? De capaciteit vouwt in in de agent. Codegeneratie, directe preview, deployment, auth, database — deze stoppen met een bestemming te zijn die je bezoekt en worden vaardigheden die je agent al bij de hand heeft.

Ik denk dat dit de koers is, en ik zeg het ronduit: vibe coding wordt een functie binnen het bredere agent-ecosysteem, geen zelfstandig product. De waarschijnlijke eindtoestand is een volledige AI-native, plugin-gebaseerde vibe-coding-capaciteit die in Codex of een Claude-gestuurde omgeving leeft — met "breng je eigen tokens" en breng-je-eigen-agents, zodat jij de kosten en flexibiliteit bepaalt in plaats van de opslag van een platform te betalen.

Ik betoogde een versie hiervan in waarom vibe coding dood is — niet dood als in verdwenen, dood als in opgelost. De vaardigheid overleeft. Het zelfstandige product wordt opgeslokt. Op dezelfde manier waarop zelfstandige "AI-schrijf-apps" werden opgeslokt door elk hulpmiddel dat je al gebruikte.

Als je nu een bedrijf bouwt bovenop een speciaal vibe-coding platform, is dat geen reden voor paniek. Het is een reden om te vragen waar je daadwerkelijke moat ligt. Want de generatiecapaciteit is het niet — dat wordt een commodity-functie. Wat overigens precies het soort strategische vraag is waar ik founders mee help; als je liever iemand hebt die je AI-architectuur in kaart brengt voordat je bouwt op een verschuivend fundament, kun je zien wat ik bouw op fiverr.com/s/EgxYmWD.

Dus als het model een hulpmiddel is en vibe coding een functie, wat is dan de eigenlijke frontier? Het is een categorie software waarvan de meeste mensen de naam nog niet eens hebben gehoord.

Agent native apps en de komst van mini-apps

Dan Shipper — CEO van Every — heeft een uitspraak die al weken door mijn hoofd rammelt: de meeste nieuwe software zal gewoon "Claude Code in een trenchcoat" zijn. Nieuwe functies zijn simpelweg knoppen die prompts afvuren op een onderliggende algemene agent.

Dat is de kern van agent-native apps: software die van de grond af is ontworpen om bediend te worden door een AI-agent, waar de UI en de agent gelijkwaardige partners zijn — alles wat de UI kan, kan de agent, en omgekeerd. Shippers team bouwde er een genaamd Proof, een documenteditor waar mensen en AI in real time samenwerken, oorspronkelijk met paars voor AI-tekst en groen voor menselijke tekst zodat je precies kon zien wie wat schreef. Toen ze het herbouwden als een collaboratieve webapp, begon iedereen bij Every het voor alles te gebruiken. Dat is het signaal: agent-native is geen gimmick, het is een betere manier van werken die mensen overnemen zonder dat het hen verteld hoeft te worden.

Breid het idee nu een stap verder uit, naar het ding waar ik oprecht enthousiast over ben: mini-apps.

Een mini-app is een kleine, taakspecifieke UI die een agent op aanvraag genereert en direct koppelt aan je echte tools via ingelogde plugins. Stel je dit concreet voor. Je vraagt je agent om je inbox af te handelen. In plaats van een muur tekst te dumpen, draait het een klein Tinder-achtig kaart-UI op: elke e-mail is een kaart met een al geschreven conceptantwoord. Je veegt om goed te keuren, tikt om te bewerken, veegt de andere kant op om te archiveren. Het leert van elke veeg — je toon, wat je negeert, waarop je altijd antwoordt — en de concepten worden beter. Die mini-app bestond vijf minuten geleden nog niet. De agent bouwde het voor die taak, verbonden met je echte Gmail, en het verdwijnt wanneer je klaar bent.

Dat is de visie: modulaire UI's, gegenereerd door agents, direct aangesloten op je data via geauthenticeerde verbindingen — Gmail, Slack, Notion, noem maar op. Je past ze aan, je deelt ze. Het is het fundament van hoe een agent-besturingssysteem er daadwerkelijk uitziet.

Hier is de eerlijke beperking, want ik verkoop je geen lucht. We zijn er nog niet helemaal. Codex kan vandaag nog niet apps laten bouwen die diep geïntegreerd zijn met je geauthenticeerde gebruikersplugins op de manier die deze visie vereist — een mini-app bouwen die veilig leest en schrijft naar je live Gmail met de juiste permissies is precies het moeilijke, half-opgeloste probleem dat tussen vandaag en die toekomst staat. De plugins bestaan. De ingelogde browser bestaat. De agent-orkestratie bestaat. Het schone, veilige "bouw me een mini-app gekoppeld aan mijn echte accounts" primitief is het ontbrekende stuk. Maar elke update dit jaar heeft precies dat spoor gelegd. Ik durf te wedden dat het in een of andere vorm arriveert voor het einde van het jaar.

En dat is precies de reden waarom "agent native worden" de vaardigheid is om nu te bouwen, voordat de tools volledig bijgehaald zijn. Want wanneer mini-apps arriveren, zullen de mensen die al in agents denken hun eigen persoonlijke software in een middag bouwen. De mensen die nog in een chatvenster typen, wachten tot iemand het voor hen bouwt.

Dus wat betekent "agent native worden" eigenlijk voor jou?

Laat me dit praktisch maken, want "wees agent native" is nutteloos als advies als ik je niet vertel wat je daadwerkelijk moet doen.

Agent native worden betekent in 2026 dat je je werk herstructureert rond vier gewoontes:

1. Routeer, aanbid niet. Stop met het kiezen van een model als een sportteam. Gebruik Opus 4.8 voor diep codebase-werk en zelfcontrolerende review, GPT-5.5 in Codex voor terminal-zware en lange autonome loops, en een goedkoop model voor het volume-gruntwerk. De vaardigheid is het matchen van de klus met het gereedschap, elke keer.

2. Begeleid in plaats van bedien. Wen eraan om agentwerk op te starten, weg te lopen, en op afstand bij te sturen — vanuit je telefoon, over worktrees, over threads. Als je nog steeds elke toetsaanslag babysit, gebruik je een tool van 2026 met een workflow van 2023.

3. Denk in orkestratie. Stop met denken "één prompt, één antwoord." Begin met denken "hoofdtaak, spawn sub-agents, coördineer, merge." Multi-agent threads zijn geen poweruser-speeltje meer; ze zijn hoe de echte doorvoer wordt ontgrendeld.

4. Beschouw software als wegwerpbaar. Wanneer mini-apps landen, verandert de vraag van "welke app moet ik downloaden" naar "welke interface wil ik dat mijn agent nu bouwt voor deze taak." Begin die mindset te oefenen voordat de tools het je opdringen.

Er is een social media-analogie die het geheel kristalliseert. Op elk platform zijn er twee soorten mensen: producers die de tools beheersen en de feed vormgeven, en consumenten die door het algoritme worden gevormd. De AI-revolutie splitst zich op precies dezelfde manier. Of je leert deze agents te besturen — en wordt een producer, die hefboom opbouwt met elke taak — of je laat ze als passieve consument over je heen spoelen van welke interface iemand anders je voorschotelt.

Dat is de keuze. En daarom ben ik gestopt met het schrijven van modelvergelijkingen als hoofdgebeurtenis. Het model is nu het makkelijke deel. Het moeilijke, waardevolle, leerbare deel is de houding van de producer: je hele werkleven organiseren rond agents die jij aanstuurt, in plaats van te wachten op de volgende benchmarkgrafiek om je te vertellen aan welk model je loyaal moet zijn.

Hier is waar ik steeds op terugkom. De benchmarkkloof tussen Opus 4.8 en GPT-5.5 zal dit jaar een dozijn keer sluiten, omdraaien en weer sluiten. Niets daarvan zal uitmaken voor de persoon die al agent native is — die routeert gewoon opnieuw en blijft shippen. Dus de volgende keer dat een model lanceert en je instinct is om te vragen "is het de beste?", betrap jezelf. Stel in plaats daarvan de betere vraag: produceer ik hiermee, of word ik erdoor geconsumeerd? Beantwoord dat eerlijk, en je weet precies waaraan je vervolgens moet werken.

Veelgestelde vragen

Wat betekent "agent native"?

Agent native worden betekent het herstructureren van hoe je werkt zodat AI-agents het uitvoerende werk doen en jij de regie houdt — taken routeren naar het juiste model, op afstand begeleiden, meerdere agents orkestreren, en software beschouwen als iets dat een agent op aanvraag bouwt. Het is een werkhouding, niet een enkel hulpmiddel of product dat je koopt.

Is Claude Opus 4.8 beter dan GPT-5.5 voor coderen?

Dat hangt af van de klus. Opus 4.8 leidt bij volledig codebase-werk (69,2% vs 58,6% op SWE-Bench Pro) en zelfcontrolerende code review, terwijl GPT-5.5 wint bij terminal-codering (78,2% vs 74,6% op Terminal-Bench 2.1) en kostenefficiënter is bij lange autonome loops. Routeer diepe code review naar Opus en terminal-zwaar werk naar GPT-5.5.

Wat zijn agent native apps en mini-apps?

Agent native apps zijn gebouwd zodat de AI-agent en de UI gelijkwaardige partners zijn — alles wat je kunt klikken, kan de agent, en omgekeerd. Mini-apps zijn kleine, taakspecifieke interfaces die een agent op aanvraag genereert en koppelt aan je echte tools via ingelogde plugins, en die verdwijnen wanneer de taak klaar is. Zie de agent-native sectie hierboven voor een volledige uitleg.

Verdwijnen vibe-coding platforms zoals Replit en Lovable?

Niet verdwijnen, maar oplossen in agents. De kerncapaciteit — genereren, previewen, hosten, auth en een database toevoegen vanuit één prompt — vouwt samen in algemene agents zoals Codex en Claude Code, waardoor vibe coding van een zelfstandig product een functie wordt. De platforms overleven op specialisatie en onboarding, niet op de generatiecapaciteit alleen.

Laten we samenwerken

Wil je AI-systemen bouwen, workflows automatiseren, of je technische infrastructuur opschalen? Ik help je graag.

• Fiverr (maatwerk builds & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io