Turn: A Language for Agentic Computation

Dit paper introduceert Turn, een gecompileerde, actor-gebaseerde programmeertaal die LLM-inferentie als een getypeerde primitief behandelt en via taalgebouwde constructies zoals cognitieve typeveiligheid en een capability-gebaseerd identiteitssysteem, kritieke invariants voor autonome agenten garandeert in plaats van ze als applicatieniveau-conventies te laten bestaan.

De kern

Stel je voor dat je een team van zeer slimme, maar soms wat onvoorspelbare assistenten wilt bouwen. Deze assistenten zijn AI-modellen (zoals de grote taalmodellen die we nu kennen). Ze kunnen geweldige ideeën bedenken, maar ze hebben een paar lastige eigenschappen: ze kunnen vergeten wat ze eerder zeiden, ze kunnen halve zinnen teruggeven, en als ze toegang krijgen tot je geheime sleutels (zoals wachtwoorden), kunnen ze die per ongeluk (of expres) doorgeven.

Tot nu toe bouwden we software voor deze AI-assistenten met gewone programmeertalen (zoals Python). Dat is alsof je een hoogspanningsnetwerk probeert te bouwen met speelgoedkabels. Het werkt vaak, maar het is onveilig en onbetrouwbaar.

Deze paper introduceert Turn: een nieuwe programmeertaal die speciaal is ontworpen voor deze "agenten" (AI-assistenten). In plaats van dat de programmeur alles zelf moet regelen, heeft Turn de regels voor veiligheid en orde al ingebouwd.

Hier is hoe Turn werkt, vertaald naar alledaagse metaforen:

1. De "Gedachteveilige" Doos (Cognitive Type Safety)

Het probleem: Als je een AI vraagt om een verslag te schrijven, krijg je soms een rommelige tekst. Als je die probeert te gebruiken in je programma, crasht het omdat de data niet klopt.
De Turn-oplossing: In Turn is elke vraag aan de AI een "doos" met een strakke vorm.

• Analogie: Stel je voor dat je een AI vraagt om een taart te bakken. In gewone talen krijg je een hoop meel, eieren en suiker in een zak. In Turn geef je de AI een mal (een sjabloon). De AI moet de taart precies in die mal bakken. Als de taart niet in de mal past, gooit het systeem het terug en zegt: "Probeer het opnieuw, dit is geen taart."
• Resultaat: De computer weet altijd zeker dat de data die hij krijgt, klopt. Geen verrassingen meer.

2. De "Zekerheidsmeter" (Confidence Operator)

Het probleem: AI's zijn soms zelfverzekerd over dingen die ze niet weten. Ze liegen met een glimlach.
De Turn-oplossing: Turn vraagt de AI niet alleen om het antwoord, maar ook om een zekerheidspercentage (bijv. 85% zeker).

• Analogie: Stel je voor dat je een weerman vraagt of het gaat regenen. In gewone talen zegt hij gewoon "Ja". In Turn zegt hij: "Ja, met 85% zekerheid." Als die zekerheid te laag is (bijv. onder de 70%), schakelt Turn automatisch over naar een veilige, vaste regel (bijv. "Neem een paraplu mee, want we zijn niet zeker").
• Resultaat: Je kunt beslissingen nemen op basis van hoe zeker de AI is, in plaats van blindelings te vertrouwen.

3. De "Onafhankelijke Werkplekken" (Actor Model)

Het probleem: Als je meerdere AI's laat samenwerken, raken ze vaak door elkaar heen. Ze vergeten wat ze eerder zeiden, of ze lezen elkaars notities verkeerd.
De Turn-oplossing: Elke AI-agent krijgt zijn eigen gescheiden werkplek met een eigen postvakje en een eigen geheugen.

• Analogie: In plaats van dat iedereen in één grote, drukke vergaderzaal schreeuwt (waar iedereen alles hoort en vergeten wordt), krijgt elke agent een geluidsdichte cabine. Ze hebben een eigen notitieblok (geheugen) en een postvakje. Als ze iets willen zeggen, sturen ze een briefje naar het postvakje van een ander. Ze kunnen elkaars notitieblok niet zien of veranderen.
• Resultaat: Geen chaos, geen vergeten informatie, en agents die niet in de war raken door elkaars gedachten.

4. De "Onzichtbare Sleutel" (Capability-Based Identity)

Het probleem: AI's hebben vaak toegang nodig tot je bankrekening of e-mail. Maar als je de wachtwoorden in de tekst van de AI zet, kan de AI die per ongeluk doorgeven aan iemand anders.
De Turn-oplossing: Turn gebruikt onzichtbare sleutels.

• Analogie: Stel je voor dat je een AI een sleutel geeft om een deur te openen. In gewone talen is die sleutel een stukje papier met een code erop. De AI kan die code lezen en doorgeven. In Turn is de sleutel een magische, onzichtbare token. De AI kan de sleutel gebruiken om de deur te openen, maar hij kan de sleutel niet zien, niet kopiëren en niet op een briefje schrijven. Alleen het systeem zelf weet wat er achter die sleutel zit.
• Resultaat: Je wachtwoorden zijn nooit in handen van de AI. Ze zijn veilig, zelfs als de AI "dwaalt".

5. De "Tijdmachine" (Durable Execution)

Het probleem: Als een AI-taak lang duurt en je computer crasht, is alles weg. Je moet opnieuw beginnen.
De Turn-oplossing: Turn kan op elk moment een foto maken van de hele situatie.

• Analogie: Het is alsof je een spelletje speelt dat automatisch opslaat op elk moment. Als de stroom uitvalt, kun je het spel precies verder spelen waar je gebleven was, alsof er niets gebeurd is. De AI "weet" nog precies wat hij aan het doen was, welke beslissingen hij nam en wat hij onthield.
• Resultaat: Lange taken kunnen veilig worden onderbroken en hervat, zonder data te verliezen.

Waarom is dit belangrijk?

Voorheen moesten programmeurs al deze veiligheidsmaatregelen zelf uitvinden en bouwen met losse stukjes code. Dat was als het bouwen van een auto zonder remmen en hopen dat de bestuurder voorzichtig rijdt.

Turn is de auto met ingebouwde remmen, airbags en een navigatiesysteem. Het zorgt ervoor dat AI-software niet alleen slim is, maar ook veilig, betrouwbaar en gestructureerd werkt. Het maakt het mogelijk om complexe systemen te bouwen die echt kunnen samenwerken met AI, zonder dat je bang hoeft te zijn dat het allemaal uit elkaar valt.

Kortom: Turn maakt van AI een betrouwbare werknemer in plaats van een onvoorspelbare gast.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Turn: A Language for Agentic Computation" in het Nederlands.

Titel: Turn: Een taal voor agentische berekening

1. Het Probleem

De opkomst van Large Language Models (LLMs) heeft een nieuwe klasse software mogelijk gemaakt: agentische programma's. Deze programma's observeren hun omgeving, redeneren over ongestructureerde data en handelen autonoom. Het gebruik van bestaande algemene programmeertalen (zoals Python, TypeScript of Rust) voor deze doeleinden leidt echter tot fundamentele incompatibiliteiten.

Huidige benaderingen vertrouwen op frameworks die kritieke invarianten (zoals begrende context, getypeerde output, en beveiliging van credentials) implementeren als conventies op applicatieniveau, in plaats van als taalgaranties. Dit resulteert in vijf veelvoorkomende foutmodi:

1. Onbegrensde context: Context wordt beheerd als een simpele lijst. Bij overschrijding van het token-limiet gaat cruciale informatie verloren door stilzwijgende truncatie.
2. Ogetypeerde inferentie-uitvoer: LLMs geven strings terug. Het parsen naar JSON zonder schema-garantie leidt tot runtime-fouten die moeilijk te koppelen zijn aan de inferentie.
3. Versnipperde staat: De staat van een agent is verspreid over variabelen, databases en framework-internals, zonder één serialiseerbare representatie.
4. Geen duurzame uitvoering: Lange lopende agents sterven met hun proces; er is geen taal-niveau mechanisme voor checkpointing en hervatting.
5. Lekken van credentials: API-sleutels worden vaak als strings opgeslagen die toegankelijk zijn voor de LLM, wat een risico vormt voor data-exfiltratie via tool-calling.

2. Methodologie

Turn is een gecompileerde, actor-gebaseerde programmeertaal die specifiek is ontworpen voor agentische software. De taal is statisch getypeerd voor schema-inferentie (voor LLM-output) maar dynamisch getypeerd op het waarde-niveau voor flexibiliteit.

De kernarchitectuur bestaat uit:

• Compiler: Compileert broncode naar bytecode.
• Virtual Machine (VM): Een op stack gebaseerde VM geschreven in Rust.
• Actor Model: Afgeleid van Erlang, waarbij elke agent een geïsoleerd proces is met eigen context, geheugen en mailbox.
• Wasm-drivers: LLM-providers worden geïntegreerd via gesandboxde WebAssembly-drivers die pure transformatiefuncties zijn zonder toegang tot host-credentials.

3. Belangrijkste Bijdragen

Het paper introduceert vijf taal-niveau constructies die de bovengenoemde problemen oplossen:

1. Cognitive Type Safety (Kognitieve Typeveiligheid):

   • De infer constructie behandelt LLM-inferentie als een getypeerde primitieve.
   • De compiler genereert een JSON-schema uit een struct definitie.
   • De VM valideert de LLM-antwoord tegen dit schema voordat de waarde wordt gebonden.
   • Garantie: Als een infer expressie succesvol is, is de waarde structureel conform de gedeclareerde type.

2. Probabilistische Control Flow:

   • De confidence operator haalt de zekerheidsscore (0.0 - 1.0) uit de inferentie-resultaten.
   • Dit stelt ontwikkelaars in staat om deterministische takken te maken op basis van de onzekerheid van het model (bijv. fallback naar een deterministische oplossing als de confidence < 0.7).

3. Het Agentische Procesmodel:

   • Gebaseerd op het Erlang-actor model, maar aangepast voor agents.
   • Elke agent heeft een tripartiete context-architectuur (Systeem, Werkend, Episodisch) om het "Lost in the Middle"-probleem op te lossen. System prompts en recente context krijgen prioriteit in de attention-mechanismen van de LLM.
   • Ondersteuning voor suspend en resume voor exacte checkpointing van de processtaat.

4. Capability-Based Identity:

   • Credentials worden nooit als strings opgeslagen in het agent-geheugen.
   • De grant identity primitieve geeft een ondoorzichtige, niet-vervalsbare Identity-handle terug.
   • De VM-host injecteert de daadwerkelijke token alleen op het moment van de kernel-call (bijv. HTTP-request), waardoor exfiltratie door de LLM onmogelijk wordt.

5. Compile-time Schema Absorptie:

   • De use schema::<protocol>("url") macro haalt API-specificaties (zoals OpenAPI) op tijdens het compileren.
   • Het genereert native Turn-structs en closures, waardoor de kloof tussen LLM-output en externe API's wordt gedicht zonder dat de ontwikkelaar JSON-schema's handmatig hoeft te schrijven.

4. Resultaten en Evaluatie

De auteurs hebben Turn geëvalueerd met 105 tests (inclusief 24 specifieke experimenten) op een Apple M4 machine. De resultaten tonen aan dat:

• Credentials Veiligheid: Raw tokens komen nooit in de Turn-heap of de LLM-interface.
• Confidentie Semantiek: De probabilistische algebra werkt correct (bijv. productregel voor onzekerheid).
• Context Isolatie: De tripartiete architectuur garandeert dat system prompts en recente items altijd de "primacy" en "recency" posities innemen, ongeacht de contextgrootte.
• Prestaties:
  • Geheugentoegang is O(1) en schaalt lineair tot 100k entries zonder vertraging.
  • Duurzame uitvoering (checkpointing) van een agent met 5.000 entries kost minder dan 7ms en resulteert in exacte staatsherstel.
  • De overhead van de veiligheidsprimitieven (zoals schema-validatie) is verwaarloosbaar (< 1µs) vergeleken met de netwerk-latentie van LLMs (100ms - 5s).
• Complexiteitsreductie: Een investeringscomité-exemplaar dat in een Python-framework (LangChain) waarschijnlijk >350 regels code zou vereisen, is in Turn gerealiseerd in slechts 89 regels.

5. Betekenis en Conclusie

Turn vertegenwoordigt een paradigmaverschuiving in de ontwikkeling van agentische software. In plaats van te vertrouwen op frameworks die invariants als conventies behandelen, maakt Turn deze invariants tot eerste klas taalconstructies.

De kerninzicht is dat een agent een proces is, geen lus. Door de beperkingen van context, geheugen en beveiliging in de taal zelf te coderen, kunnen compiler en runtime deze mechanisch afdwingen. Dit elimineert een hele klasse van fouten die ontstaan wanneer kritieke invarianten worden overgelaten aan de discipline van de ontwikkelaar. Turn biedt daarmee sterkere garanties voor agentische software dan enige bibliotheek die is gebouwd op een algemene gastheertaal.

De taal is open source beschikbaar en vormt een fundament voor de toekomst van betrouwbare, schaalbare en veilige autonome agents.