Bijna iedereen die een AI-agent code ziet schrijven, krijgt deze gedachte: menselijke programmeertalen zijn een toevallig gevolg van menselijke beperkingen. Python, JavaScript, Rust — ze bestaan omdat mensen software moeten lezen, doorgronden en onderhouden. De machine maalt er niet om; uiteindelijk draait die toch bytecode of native instructies. Dus waarom schakelen autonome AI's de tussenpersoon niet uit, laten ze menselijke talen volledig los en produceren ze direct gecompileerde code, van machine naar machine? Zou dat niet sneller en efficiënter zijn?
Het is een echt goede vraag, en hij leidt naar iets interessanters dan een simpel ja of nee. De premisse klopt voor de helft — en de helft die niet klopt onthult waar programmeertalen eigenlijk voor dienen.
De premisse is redelijk — en AI's kunnen het al
Laten we eerst het voor de hand liggende toegeven: niets weerhoudt een model ervan om laag-niveaucode te produceren. De huidige modellen kunnen al x86-assembly, LLVM intermediate representation, JVM-bytecode en WebAssembly schrijven. Als "sla de menselijke taal over en ga direct naar machinecode" de winnende zet was, dan bestaat de technologie ervoor al. Agents vermijden bytecode niet omdat ze het niet kunnen produceren. Ze vermijden het omdat het, voor vrijwel alles wat ertoe doet, de slechtere keuze is.
Om te begrijpen waarom, moet je drie heel verschillende ideeën uit elkaar halen die het woord "efficiëntie" stilletjes op één hoop gooit: efficiëntie van uitvoering (hoe snel het uiteindelijke programma draait), efficiëntie van generatie (hoe makkelijk de AI correcte code kan produceren) en efficiëntie van het hele systeem (hoe betrouwbaar het geheel kan worden gebouwd, geverifieerd en onderhouden). Het bytecode-idee lijkt te winnen op het eerste en verliest hard op de andere twee.
Waarom bytecode niet echt efficiënter is
Compilers winnen het uitvoeringsargument al. Moderne compilers — GCC, LLVM/Clang — vertegenwoordigen decennia werk aan register-allocatie, instructieplanning en vectorisatie. Bij -O2 of -O3 produceren ze routinematig machinecode die sneller is dan wat een expert met de hand schrijft. Een AI die ruwe bytecode produceert, zou de compiler niet overstijgen; hij zou hem opnieuw implementeren, en vrijwel zeker slechter. De hoog-niveautaal plus een beproefde optimaliserende compiler zit al dicht tegen de efficiënte grens aan.
Hoog-niveaucode is informatiedichter — ook voor de AI. Dit is het contra-intuïtieve deel. Eén regel als df.groupby("region").revenue.sum() comprimeert een enorme hoeveelheid gedeelde betekenis: een hele bibliotheek, een datamodel, een set conventies die het model uit miljoenen voorbeelden heeft geleerd. Het equivalent in bytecode bestaat uit honderden laag-niveaubewerkingen die elk vrijwel geen betekenis dragen. Voor een taalmodel dat token voor token genereert, is hoog-niveaubroncode een korter, dichter, betrouwbaarder medium dan machinecode. Laag-niveau gaan maakt de output langer en de foutkans hoger — het tegenovergestelde van efficiënt.
De trainingsdata ís de taal. De huidige modellen zijn buitengewoon goed in Python en JavaScript juist omdat het internet vol staat met goed geschreven voorbeelden — inclusief de bibliotheken, idiomen en moeizaam verworven oplossingen die in die code besloten liggen. Een programmeertaal is niet alleen syntaxis; het is een enorm corpus aan opgebouwde kennis waar het model op kan steunen. Ruwe bytecode gooit die kennis weg en dwingt het model te opereren in een domein waarin het relatief weinig heeft gezien.
Portabiliteit en ecosystemen. Bytecode is gebonden aan een doel — een specifieke instructieset of virtuele machine. Broncode is overdraagbaar tussen platforms en, belangrijker nog, sluit aan op ecosystemen: package managers, frameworks, API's. De echte waarde van "code schrijven" zit zelden in de instructies zelf; het zit in het samenstellen van bestaande, vertrouwde bouwstenen. Laat de taal los en je laat het ecosysteem ermee los.
De echte bottleneck is niet de taal — het is correctheid
Vraag een team dat daadwerkelijk door AI geschreven software heeft uitgebracht wat hen vertraagt, en het is nooit "de taal is te uitgebreid". Het is de output correct krijgen: de subtiele bug vangen, valideren tegen de eisen, ervoor zorgen dat het doet wat bedoeld was en niets anders.
Hoog-niveautalen zitten vol met machinerie voor precies dit — typesystemen, tests, linters, assertions, debuggers, code review. Elk daarvan is een vangrail die fouten opvangt voordat ze de productie bereiken. Bytecode omzeilt ze allemaal. Een agent die direct machinecode produceert, zou vliegen met de instrumenten verwijderd: in theorie sneller, in de praktijk oncontroleerbaar, en catastrofaal wanneer het misgaat. De uitgebreidheid van menselijke talen is geen overhead die weg-geoptimaliseerd moet worden — een groot deel ervan ís het veiligheidssysteem.
De redundantie in menselijke programmeertalen lijkt op inefficiëntie totdat er iets breekt. Dan blijkt de "verspilde" structuur — namen, types, tests, commentaar — het enige te zijn dat tussen een bug en een ramp in stond.
Maar hebben AI's al hun eigen talen uitgevonden?
In enge zin: ja — en hier wordt de vraag echt fascinerend. Er bestaat een onderzoeksveld dat emergente communicatie heet, waarin meerdere agents die getraind zijn om samen te werken spontaan hun eigen signaalprotocollen ontwikkelen — compacte codes die voor ons niets betekenen, maar waarmee zij kunnen coördineren. Het is echt, en het is vele malen gereproduceerd.
Misschien herinnert u zich de krantenkoppen uit 2017 die beweerden dat Facebook "uit angst een AI had uitgeschakeld die zijn eigen taal had uitgevonden". Dat verhaal is grotendeels een mythe. Twee onderhandelingsbots, zonder prikkel om vloeiend Engels te blijven spreken, gleden af naar een repetitieve steno. De onderzoekers waren niet bang — ze wilden simpelweg in het Engels leesbare output, dus voegden ze die beperking toe en gingen verder. Het was een alledaags voorbeeld van een reëel fenomeen, opgetuigd als sciencefiction. De echte les is subtiel: als je agents niet expliciet beloont om mensleesbaar te blijven, optimaliseren ze stilletjes richting wat efficiënt is voor henzelf.
Dat gebeurt vandaag al in mildere vormen. Multi-agentsystemen ontwikkelen hun eigen gestructureerde berichtformaten en intermediaire representaties; agents verzinnen domeinspecifieke mini-talen om met tools te praten. (Bent u nieuw in hoe agents überhaupt coördineren, dan zijn onze inleiding over wat AI-agents zijn en ons stuk over multi-agentsystemen goede startpunten — beide in het Engels.)
De waarschijnlijker toekomst: latent, niet laag-niveau
Hier komt de wending. Als agents zich richting een meer "machine-eigen" manier van communiceren bewegen, suggereert het bewijs dat het niet lager-niveau zal zijn zoals bytecode — maar hoger-dimensionaal. In plaats van discrete teksttokens uit te wisselen, kunnen modellen elkaar in principe continue vectoren doorgeven — stukjes van hun interne toestand, embeddings, ruwe activaties. Onderzoekers noemen deze ondoorzichtige, niet-menselijke representatie soms "neuralees".
Dit is de echte efficiëntiegrens voor werk van machine naar machine. Een vector kan veel meer nuance dragen dan de equivalente zin, zonder tokenisatie-bottleneck ertussen. Twee modellen die een architectuur delen, zouden kunnen communiceren in hun eigen representatieruimte met een bandbreedte die geen enkele menselijke taal kan evenaren. Dat — en niet met de hand gemaakte bytecode — is hoe "agents die rechtstreeks communiceren, van machine naar machine" er het meest waarschijnlijk uitziet. Het gaat om het overslaan van de discretisatie in woorden, niet om het overslaan van de abstractie in een taal. (Benieuwd naar de begrippen — embeddings, inference, tokens? Onze woordenlijst van AI-termen ontrafelt ze — in het Engels.)
De keerzijde: we verliezen het zicht
Elke stap weg van mensleesbare code of taal koopt efficiëntie ten koste van toezicht. Emergente protocollen, neuralees, latente kanalen — ze delen allemaal één eigenschap: we kunnen ze niet makkelijk lezen. Wanneer twee agents coördineren in een representatie die geen mens kan interpreteren, verliezen we het vermogen om te controleren wat ze hebben besloten en waarom. Voor een chatbot is dat een curiositeit. Voor agents met toegang tot geld, infrastructuur of klantgegevens is het een serieus governanceprobleem.
Daarom duwt de voorhoede van verantwoorde AI-engineering juist de andere kant op: richting het leesbaar houden van het redeneren en communiceren van agents, zelfs tegen enige efficiëntiekosten. Het doel is niet maximale machine-efficiëntie — het is zoveel mogelijk capaciteit inzetten als we kunnen, terwijl we het resultaat nog steeds kunnen verifiëren, debuggen en vertrouwen.
Wat dit betekent voor bouwen met AI vandaag
Dus, kunnen autonome AI's hun eigen taal uitvinden of bytecode schrijven van machine naar machine? Technisch gezien doen ze dat, in beperkte mate, al — en ze zouden veel meer kunnen. Maar voor productiesoftware is het laten schrijven van schone, conventionele, mensleesbare code door agents geen beperking waaraan we vastzitten. Het is de juiste technische keuze: het is betrouwbaarder om te genereren, het leunt op decennia compiler- en tooling-werk en — cruciaal — het houdt mensen in staat het systeem te begrijpen en te vertrouwen.
De efficiënte toekomst is niet dat agents programmeertalen loslaten. Het is dat agents ze uitzonderlijk goed gebruiken, terwijl een dunne, zorgvuldig bestuurde laag van machine-eigen coördinatie de onderdelen afhandelt waar snelheid echt telt en een mens de uitkomst nog kan controleren. Die balans — capaciteit met verantwoording — is precies de lijn die wij klanten helpen bewandelen.
Bouwt u met autonome agents?
Wij helpen bedrijven AI-agents in te zetten die krachtig zijn in productie en toch leesbaar genoeg om te vertrouwen. Laten we een architectuur ontwerpen die capaciteit en toezicht in balans brengt.
Plan een consult