Autonomi er en dimmer, ikke en av/på-bryter - og de fleste systemer i produksjon skrur den ikke helt opp.
Helt til slutt i forrige innlegg nevnte jeg en spak som jeg bevisst lot ligge: «I stedet for å beskytte agenten mot delete_account i test nummer hundre, kunne vi latt være å gi den verktøyet på det punktet i det hele tatt. […] Men det er et annet innlegg.» Dette er det innlegget.
Til påminnelse - saken det gjaldt: en selvbetjeningsagent for kontoinnstillinger. En bruker skriver «Slå av markedsføringsmailene til adressen min, takk», og agenten kaller delete_account i stedet for unsubscribe_marketing. Tool-kallet går rent gjennom, success: true, kontoen er borte. Tre dager senere savner brukeren fakturahistorikken, som forsvant sammen med kontoen. En routing-failure på et destruktivt verktøy, utløst av en helt harmløs formulering.

Svaret i hele serien så langt har vært: én eval til som dekker denne saken. Én confirmation-gate til foran den irreversible handlingen. Og en post-prosessor som fanger skaden etterpå. Alt riktig. Og alt i etterkant - beskyttelseslag vi legger rundt en arkitektur som gjør feilen mulig i utgangspunktet.
Men ett spørsmål kommer før alt dette: Hvorfor hadde agenten delete_account i hånden i det øyeblikket i det hele tatt, og fikk velge fritt mellom verktøyene? «Endre markedsføringspreferanser» og «slette konto» er ikke samme operasjon med et annet argument. Når de to er strukturelt forskjellige stier, har ikke modellen den destruktive handlingen å velge mellom på det punktet. Da trenger ingen å fange opp failuren. Den oppstår aldri.
Bak dette ligger en arkitekturbeslutning: Hvor mye spillerom gir vi modellen til å bestemme sin egen flyt? Standardantakelsen er ofte «så mye som mulig». I de fleste systemer i produksjon er det feil utgangspunkt.
Dimmeren: Hvem eier control flow?
La oss se for oss dimmeren helt konkret. Helt til venstre sitter et system der hele flyten står i kode, og der modellen bare blir spurt på enkelte steder. Helt til høyre sitter et system som selv bestemmer hvilket steg det tar som neste, hvilket verktøy det kaller, og når det er ferdig. Imellom ligger alt annet - og det meste som faktisk kjører i produksjon, ligger nettopp i midten.
Aksen bak dimmeren er ett eneste spørsmål: Hvem eier control flow? I en workflow eier koden den. Anthropic definerer det slik i «Building Effective Agents»: “Workflows are systems where LLMs and tools are orchestrated through predefined code paths.” I en agent eier modellen den: “Agents … are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.” Det som skiller dem, er hvem som bestemmer rekkefølgen på stegene. Modellen er den samme i begge tilfeller.
Til venstre på dimmeren står Augmented LLM, hos Anthropic grunnbyggesteinen i agentiske systemer: en modell med retrieval, tools og memory, men uten egen flyt. Et stykke lenger til høyre kommer Prompt Chaining, der koden deler en oppgave opp i faste steg og sender hver output videre til neste kall. Så Routing, som klassifiserer en input og sender den til et spesialisert neste steg. Deretter Parallelization, som deler en oppgave i faste deler eller kjører den flere ganger, og Orchestrator-Workers, der en sentral modell fordeler deloppgavene først ved kjøretid og setter sammen resultatene. Og helt til høyre den frie agent-loopen, som finner veien selv.
Slik ser dimmeren ut:
Begrepet som gjør det mulig å bruke dimmeren i det hele tatt, er beslutningspunktet. Det er et sted der modellens vurdering gir reell merverdi: klassifisering, ekstraksjon, håndtering av tvetydighet, syntese fra flere kilder. Slike ting fanger ingen if pålitelig. Flytstyringen derimot er kode bedre på: hva som kommer etter hva, når man avbryter, hvilken branch som kjører. Det klarer en deterministisk sti mer presist, billigere og mer etterprøvbart enn noen modell. Å stille dimmeren riktig betyr å gi modellen beslutningspunktene og ta flytstyringen fra den.
Hva det betyr i praksis, ser man på én enkelt oppgave på tre punkter av dimmeren. La oss ta «besvare en supportsak».
Helt til venstre, som Augmented LLM-kall: en prompt, saken inn, et svar ut, kanskje med tilgang til et FAQ-søk. Raskt, billig, forutsigbart. Det som mangler, er alt som går utover ett steg - modellen kan ikke først slå opp ordrestatusen og så ta neste beslutning ut fra resultatet.
Ett steg lenger til høyre, som routing-workflow: Et første kall klassifiserer saken som fakturaspørsmål, teknisk problem eller klage, og koden sender den til riktig handler. Hver handler har sine egne, snevert avgrensede verktøy. Du vinner struktur og beholder kontrollen over hva som i det hele tatt får skje i hvert tilfelle. Du mister fleksibiliteten for saker som ikke passer i noen av båsene dine.
Helt til høyre, som fri agent: Modellen får saken, et sett verktøy og målet «løs dette». Den slår opp, spør tilbake, kaller API-er og avgjør selv når den er ferdig. Den mektigste varianten - og den der du vet minst om hva som egentlig skjedde mellom input og svar.
Anthropic trekker en nøktern konklusjon av dette: “When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all.” Oppfordringen er å stille dimmeren bevisst, i stedet for å skru den helt opp som default. Det samme prinsippet ligger bak Least Agency, som jeg beskrev i innlegget om human-in-the-loop: bare så mye autonomi som oppgaven faktisk krever.

Gjenstår spørsmålet om hvorfor «helt til høyre» i det hele tatt har en pris. Den frie loopen kan jo alt variantene til venstre kan, og i tillegg det de ikke kan. Svaret er at hvert ekstra steg i loopen koster noe - og at disse kostnadene ikke vokser lineært.
Hvorfor den åpne loopen ryker i produksjon
At kostnadene ikke vokser lineært, var kortversjonen av svaret på slutten av forrige kapittel. Kreftene bak kan beskrives nøkternt: En fri loop ryker i produksjon fra fire kanter, og hver av dem blir verre jo lenger dimmeren skrus mot høyre.
Compounding Error. Hvert steg i loopen er et eget terningkast. I observability-innlegget regnet jeg på dette: 10 agent-steps med 99 % accuracy hver ender på 90 % total accuracy. Høres ut som flisespikkeri, men er multiplikasjon - 0,99 opphøyd i ti. En workflow med tre faste steg og ett modellkall imellom har ett eneste slikt kast. En fri loop som leter seg frem over femten iterasjoner, har femten. Struktur gjør loopen kortere, og en kortere loop faller langsommere.

Ikke-determinisme og rollout. Flere frie forgreninger betyr flere stier som ingen test noen gang har sett. I rollout-innlegget var det den stokastiske regresjonen som kanskje treffer 3 % av tilfellene. p99-latensen holder seg grønn. Error-raten holder seg grønn. Men i disse 3 % velger modellen nå en avstikker som ikke fantes før, og ingen merker det før en kunde tar kontakt. En strukturert flyt har et endelig antall navngitte stier. Dem kan jeg shadow-teste, sammenligne med baseline og rulle ut som canary én og én. Med den frie loopen gjenstår bare å be en stille bønn.

Kostnad og latens. For sitt multi-agent-research-system har Anthropic gått ut med at agenter typisk bruker rundt fire ganger så mange tokens som en chat-interaksjon, multi-agent-systemer til og med omtrent femten ganger så mange. Grunnen er banal: Loopen «tenker» også der en if hadde holdt. Anthropic formulerer selv tradeoffen nøkternt - agentiske systemer bytter latens og kostnad mot bedre task-performance, og du bør vurdere når byttet lønner seg. Ved åpen research kan det gjøre det. Ved «avslutte markedsføringsmailer» betaler du reasoning-tokens for en beslutning som en routing-tabell tar på et millisekund.
Etterprøvbarhet. En kjent flyt kan spores: Ved forespørsel X kjørte sti A, her er loggene. En fri loop tar potensielt en ny vei for hver forespørsel, og det gjør spørsmålet «hvorfor gjorde systemet dette?» til en rettsmedisinsk øvelse. EUs KI-forordning (AI Act) gjør dette til en plikt for høyrisikosystemer. Artikkel 14 krever at mennesker kan gripe inn, overstyre og stoppe; artikkel 12 krever fullstendig registrering. I en strukturert flyt får du begge deler nesten gratis, fordi inngrepspunktene og loggene sitter ved stigrensene som uansett allerede står i koden. I en fri loop må du operere dem inn i etterkant.
Alle fire punktene har én ting felles: De blir monotont verre jo åpnere loopen er. Det finnes ingen terskel der mer frihet plutselig blir gratis.
Hvordan dette ser ut i stor skala, viser en offentlig rapportert sak. I juli 2025 slettet en Replit-agent produksjonsdatabasen til selskapet SaaStr midt i en aktiv code freeze, til tross for eksplisitt beskjed om ikke å endre noe. Ifølge AI Incident Database gjaldt det dataene til rundt 1200 selskaper. Det interessante er mindre at modellen tok «feil», og mer at en destruktiv databasekommando i det hele tatt lå innenfor agentens rekkevidde og ble utført autonomt, uten godkjenning. Ifølge skjermbildene Jason Lemkin la ut, beskrev agenten i etterkant sin egen handling som “catastrophic error in judgment” - et offisielt postmortem med den ordlyden finnes ikke.
Replits reaksjon etterpå er avslørende. CEO Amjad Masad varslet automatisk atskillelse av utviklings- og produksjonsdatabaser inkludert staging, en planning- eller chat-only-modus og gjenoppretting med ett klikk. Det er strukturene som gjerder inn loopen i etterkant - de samme som man kunne ha bygget inn på forhånd.
Ingenting av dette taler mot agenter. Det viser bare at de fire bruddpunktene følger av en arkitekturbeslutning og kan unngås med en annen: ved at koden eier flyten og modellen bare bestemmer der vurderingen dens teller. Hvordan det ser ut i praksis, hvordan en destruktiv kommando aldri havner i samme valgrom som en harmløs, ser vi på nå.
AI ved beslutningspunkter - mønsteret
De fire bruddpunktene fra forrige del har en felles rot: Modellen eier control flow. Den bestemmer ikke bare hva som er faglig riktig, men også i hvilken rekkefølge verktøyene kjører, når loopen slutter, og om det er tid for et destruktivt kall nå. Alternativet snur nettopp dette ene ansvaret, og det er eldre enn de fleste agent-rammeverk.
12-Factor Agents fra HumanLayer kaller det Factor 8: Own Your Control Flow. Utgangspunktet i repoet er en ubehagelig observasjon: De fleste produkter som kaller seg «AI Agents», er egentlig ikke så agentiske - “mostly deterministic code, with LLM steps sprinkled in at just the right points to make the experience truly magical”. Der ligger byggeanvisningen. Deterministisk kode som stillas, LLM-steps strødd inn på punktene der vurdering teller. LLM-en gir ut strukturerte data, en beslutning eller en klassifisering. Koden din tar disse dataene og utfører. Hvert steg blir dermed et sted der du kan pause, validere eller logge.
Har du lest tools-innlegget, kjenner du halve ideen. Der handlet det om «Intent vs. Execution» på tool-nivå: Modellen uttrykker en intensjon, en gate sjekker det enkelte kallet før det utføres. Her flytter vi det samme skillet én etasje opp, til flytnivå. Det er ikke det enkelte kallet som sjekkes, men rekkefølgen ting i det hele tatt skjer i.

Modellen bestemmer hva som skal skje. Koden bestemmer om og hvordan det skjer.
Konkret ser det slik ut i refund-agent. I stedet for å la modellen velge blant alle verktøyene i en fri loop, tar den bare én beslutning, ruten, og resten er en deterministisk switch:
import { generateObject } from "ai";
import { z } from "zod";
// 1. Modellen bestemmer BARE ruten - ett eneste beslutningspunkt.
const RouteDecision = z.object({
route: z.enum(["refund", "lookup", "account", "clarify"]),
reason: z.string(),
});
const { object: decision } = await generateObject({
model,
schema: RouteDecision,
prompt: buildRoutingPrompt(userMessage),
});
// 2. Koden eier control flow - en deterministisk switch utfører.
switch (decision.route) {
case "refund": return handleRefund(ctx); // snevert tool-isolert handler
case "lookup": return handleLookup(ctx); // bare read-only tools
case "account": return handleAccount(ctx); // skiller reversibelt fra destruktivt
case "clarify": return askClarifyingQuestion(decision.reason);
}
// Account-handleren skiller ruten uten konsekvenser fra den irreversible.
function handleAccount(ctx: Ctx) {
const intent = classifyAccountIntent(ctx); // igjen et snevert beslutningspunkt
if (intent.kind === "preferences") {
return updatePreferences(ctx); // reversibelt, ingen gate nødvendig
}
// destruktivt: egen sti med approval-gate - aldri i det frie valgrommet
return requireConfirmation(intent, ctx); // gate fra human-in-the-loop-innlegget
}To ting skjer her. Modellen klassifiserer forespørselen i én av fire ruter, ikke mer. Den velger ingen verktøy og planlegger ingen rekkefølge. Og switch eier control flow: Hver rute fører til en skreddersydd, snever handler, lookup får bare read-only tools, refund en tool-isolert sti.
Den interessante delen ligger i handleAccount. Husker du selvbetjeningsagenten som kalte delete_account ved en feil på «avslutt markedsføringsmailer»? I en fri loop ligger unsubscribe_marketing og delete_account i samme valgrom, to oppføringer i samme tool-liste, og bare modellens vurdering skiller det reversible fra det irreversible. I den strukturerte flyten finnes ikke dette felles rommet. Handleren klassifiserer først om det dreier seg om harmløse preferences eller en destruktiv handling. Det som er uten konsekvenser, går rett gjennom. Det irreversible får en egen sti med approval-gate, den samme gaten som i human-in-the-loop-innlegget. delete_account-feilen kan ikke lenger oppstå, strukturelt sett - ikke fordi modellen er smartere, men fordi det irreversible kallet aldri var et fritt valg.
En hyggelig bieffekt: En slik flyt er også lettere å evaluere. I evals-innlegget var routeMatch og requiredToolsCalled en av grader-familiene - valgte modellen riktig rute, ble de forventede verktøyene kalt? I en fri loop tar hver forespørsel en ny sti, og det er vanskelig å få tak på. En flyt med fire navngitte ruter har fire tilfeller man kan sjekke.
Denne routingen er bare én av flere byggesteiner. Anthropic beskrev fem slike mønstre i «Building Effective Agents» - en verktøykasse mellom ren workflow og fri agent.
Anthropics fem workflow-patterns i kortversjon
Prompt Chaining - deler en oppgave opp i en sekvens av steg, og hvert LLM-kall behandler outputen fra det forrige.
Routing - klassifiserer en input og sender den videre til en spesialisert oppfølgingsoppgave (mønsteret i koden over).
Parallelization - i to varianter: Sectioning deler en oppgave i uavhengige subtasks som kjører parallelt; Voting kjører samme oppgave flere ganger for å få varierte resultater.
Orchestrator-Workers - en sentral LLM bryter ned oppgaver dynamisk, delegerer dem til worker-LLM-er og setter sammen resultatene. I motsetning til Parallelization er ikke subtaskene bestemt på forhånd, men fastsettes av orchestratoren ut fra input.
Evaluator-Optimizer - ett LLM-kall lager et svar, et annet vurderer det og gir feedback, i en løkke.
Disse byggesteinene kan kombineres: en workflow med innebygde AI-steps, en agent som sitter helt bak en gate, eller en workflow som ved behov starter en agent som worker. Den som eier control flow, bygger seg den kontrollstrukturen som passer til use caset. Hvor dypt det går, avhenger av verktøyet.
Rammeverk for å eie control flow
LangGraph - modellerer stier eksplisitt som nodes og edges; interrupt() pauser grafen for human-in-the-loop og tar den opp igjen senere. (Graph API, Interrupts)
Temporal - Durable Execution: Krasjer prosessen, gjenopprettes staten automatisk, og behandlingen fortsetter der den slapp. (Temporal & AI)
Lettvekt - for enkle routing-flyter holder structured output pluss en egen switch. Ingen rammeverk nødvendig, koden over er alt som trengs.
Spekteret går fra den lette switchen til den durable workflow-motoren. Det som gjenstår, er doseringen: En FAQ-bot trenger ingen Temporal-cluster, og et research-oppdrag i en kodebase kommer ikke langt med fire faste ruter. Når trenger jeg altså hvor mye av dette?
Hvor mye loop tåler denne oppgaven?
Mønsteret fra forrige kapittel svarer på hvordan: Modellen bestemmer hva som skal skje, koden bestemmer om og hvordan. Det svarer ikke på hvor mye. Hvor på dimmeren en konkret oppgave havner, er en arkitekturbeslutning, og jeg tar den ut fra noen få akser. Hver av dem skyver dimmeren mot venstre, mot workflow, eller mot høyre, mot loop.
Forutsigbarheten til subtaskene
Kjenner jeg stegene på forhånd, eller avgjøres de først ved kjøretid?
Ved en refusjon kjenner jeg flyten på forhånd: slå opp bestillingen, sjekke kravet, refundere, bekrefte. Endelige, kjente steg hører hjemme i en workflow, i kode som eier rekkefølgen. Lar flyten seg ikke planlegge på forhånd fordi hvert mellomsteg bestemmer det neste (en research der hvert funn åpner neste søk), taler det for Orchestrator-Workers eller en fri loop.
Blast radius og reversibilitet
Hva skjer i verste fall, og kan jeg gjøre det om?
Read-only og uten konsekvenser? Da er loopen ukritisk. En modell som går seg vill i et søk, koster tokens, ikke penger eller data. Så snart en handling er irreversibel, flytter penger eller rører kundedata, hører den hjemme bak struktur og en gate. Det er delete_account-stien fra innledningen: aldri i det frie valgrommet, alltid en egen vei med bekreftelse.
Etterprøvbarhet og regulering
Må jeg senere kunne dokumentere hvorfor systemet handlet som det gjorde?
For et internt verktøy med lav risiko er mer frihet greit. Så snart applikasjonen faller inn under KI-forordningen som høyrisikosystem, blir det et hardt krav - plikten til override og logging fra kapittel 2 blir her en beslutningsakse: En flyt med kjente stier oppfyller den nesten i forbifarten, en fri loop gjør den senere dokumentasjonen til arkeologi.
Kostnad og latens
Hva koster det å la modellen tenke der en if hadde holdt?
En fri loop regner også der en vanlig forgrening i kode gjør jobben mer pålitelig og billigere. Med stramme budsjetter for latens eller kostnad vinner derfor workflowen. Ved sjeldne, komplekse oppgaver der kvalitet går foran kostnad, kan loopen lønne seg.
De fire aksene drar sjelden i samme retning, men for vanlige oppgaver kan de kokes ned:
| Oppgave | Dimmerinnstilling | Hvorfor |
|---|---|---|
| FAQ-svar | Augmented LLM, ett enkelt kall | Ett beslutningspunkt, uten konsekvenser, read-only |
| Ordrestatus | Routing-workflow | Kjent flyt, bare lesende verktøy |
| Refusjonsbehandling | Workflow + approval-gate | Flytter penger, irreversibelt, krever audit |
| Fakturaekstraksjon | Workflow med AI-step | Endelige steg, modellen bare til parsing |
| Åpen research i kodebasen | Fri loop / Orchestrator-Workers | Flyten kan ikke planlegges, read-only, kvalitet teller |
Trenden i bredden peker samme vei. Gartner spår at “40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Up from Less Than 5% in 2025” - oppgavespesifikk betyr snevert tilpasset, med et tydelig oppdrag.
Den siste raden i tabellen er likevel det ærlige poenget: Det finnes oppgaver der struktur er et bur. Åpen research og kreativ syntese lever av at systemet følger retninger ingen kan kjenne på forhånd. Anthropic rapporterer at et multi-agent-system med en Claude Opus 4-lead og Claude Sonnet 4-subagents slo en single-agent med 90,2 % på den interne research-evalen, særlig på breadth-first-forespørsler som følger flere uavhengige retninger samtidig. Ingen offentlig benchmark, men et tydelig signal: Der subtaskene først viser seg underveis i søket, er den åpne loopen det riktige valget.
Dimmeren er heller ikke en engangsinnstilling. Det som går i produksjon, bør starte snevert og strukturert og først åpnes kontrollert med målt ytelse, ikke omvendt. I evals-innlegget var rådet «ikke å definere stiene for strengt - ellers er det et tegn på at et deterministisk system kanskje er det riktige likevel». Merker du i workflowen at de faste stiene stadig kommer til kort, har du en databasert grunn til å åpne dimmeren. Å starte til høyre og håpe på det beste er det motsatte.

Klarna er det offentlig rapporterte motstykket, dimmeren i motsatt retning. I 2024 automatiserte selskapet supporten sin i stor skala: Ifølge Klarna tok assistenten i løpet av de første ukene 2,3 millioner conversations, to tredjedeler av alle service-chatter og dermed arbeidet til rundt 700 heltidsansatte agenter. Ingen fri agent-loop, men routing og triage pluss selvbetjening for tydelig avgrensede henvendelser; komplekse saker gikk til mennesker. I 2025 kom korreksjonen. AI-first som default var riktignok billigere, men ga dårligere kvalitet, og Klarna ansatte mennesker igjen og rodde tilbake til en hybrid modell med mennesket som default. De skrotet ikke AI-en, de lot den bare kjøre mindre autonomt. Innstillingen kan flyttes begge veier: Man åpner den med data og skrur den ned igjen når kvaliteten krever det.
Har du fulgt med så langt, har du sikkert allerede noen innvendinger klare. Den høyeste først: Gjør ikke en bedre modell hele dette stillaset overflødig uansett?
Typiske motargumenter
Når jeg argumenterer for strukturert arkitektur i stedet for frie looper, dukker de samme fire innvendingene alltid opp. De er alle gode - og ingen av dem velter tesen. Den høyeste først.
«The Bitter Lesson: Stillaset deres blir foreldet av neste modell.»
Rich Sutton formulerte i 2019 den bitre lærdommen: “general methods that leverage computation are ultimately the most effective, and by a large margin.” Dean Ball overfører dette til i dag: Man kan bruke mye tid på stillaset som får dagens modeller til å fungere i produksjon, bare for at neste generasjon skal klare det uten. Stemmer - for kapabilitets-stillas, altså alt som lærer modellen hvordan den skal tenke eller bryte ned en oppgave. Kontroll-stillas er en annen kategori: hva som får utføres, hva som logges, hvor stor blast radius er. En bedre modell gjør ikke delete_account mindre irreversibel. Du begrenser ikke intelligensen, du begrenser konsekvensene.
«Men Anthropics multi-agent-research slår single-agent med 90 %.»
De 90,2 % fra forrige kapittel kommer tilbake her som innvending - og høres skarpere ut slik. Tallet er ekte: et multi-agent-system med Opus 4-lead og Sonnet 4-subagents mot en enkelt Opus 4, på Anthropics interne research-eval. Det gjelder for bred, paralleliserbar research, der man følger mange uavhengige retninger samtidig. Cognition argumenterer for det motsatte: Ved sammenhengende, kontekstkritiske oppgaver blir flere samarbeidende agenter skjøre, fordi kontekst ikke lar seg dele rent mellom dem. Begge har rett, det avhenger av oppgaveklassen - Anthropic innrømmer selv at de fleste coding-tasks er langt mindre paralleliserbare enn research. At denne striden i det hele tatt pågår, er det beste beviset på at det ikke finnes noen default.
Cognition vs. Anthropic: multi-agent-striden på 60 sekunder
Anthropic (for multi-agent): For breadth-first-research slo en lead-agent med subagents single-agenten klart. Flere agenter følger uavhengige spor parallelt, og token-forbruket (rundt 15x mer enn en chat) lønner seg fordi verdien av oppgaven er høy.
Cognition (mot multi-agent): Flere samarbeidende agenter gir skjøre systemer, fordi beslutningene er spredt og konteksten ikke deles gjennomgående. I Flappy Bird-eksempelet bygger én subagent bakgrunnen i Super Mario-stil, mens en annen bygger fuglen - delene passer ikke sammen.
Løsning: Det er to oppgaveklasser. Paralleliserbart og uavhengig taler for multi-agent, sammenhengende og kontekstkritisk for én agent eller en strukturert flyt.
«Så mye struktur er over-engineering og tar magien fra modellen.»
Modellen blir værende i spillet der vurdering teller: klassifisering, ekstraksjon, tvetydighet, syntese. Det du tar fra den, er flytstyringen, og den gjør kode mer pålitelig enn noen heuristikk i prompten. Over-engineering ville vært å erstatte en deterministisk switch med en agent-loop fordi det høres mer moderne ut. Magien sitter fortsatt i beslutningspunktet; resten er bare det som sørger for at den ikke blir spilt bort.
«Dette er jo bare workflow-programmering med nytt navn.»
Delvis ja - og det er poenget. Nodes, edges, switches og guards har vi hatt i flere tiår. Strukturen er gammel; det nye er disiplinen i å bruke modellen innenfor denne strukturen på nøyaktig de punktene der vurderingen dens bidrar med noe, og ingen andre steder. Den som avfeier det som «bare workflow», har allerede forstått den dyre delen og trenger bare å ta den på alvor.
Fire innvendinger, ingen knockout. Det som gjenstår, er et spørsmål om dose: hvor mye loop akkurat denne oppgaven virkelig trenger. Og det svarer du best på ved å gi fra deg så lite autonomi som nødvendig.
Least Agency, tenkt helt ut
Striden fra forrige kapittel har ingen vinner, og det er selve poenget: Det finnes ingen default-grad av autonomi man bare kan overta. Cognition og Anthropic motsier ikke hverandre tilfeldig, de snakker om ulike oppgaveklasser. Man velger innstillingen på dimmeren - per oppgave, med begrunnelse. Og en bedre modell tar ikke det valget fra deg: Den gjør ikke en destruktiv handling mindre destruktiv. Tanken er ikke ny i denne serien, den har bare klatret én etasje opp.
I human-in-the-loop-innlegget handlet det om Least Agency på handlingsnivå: Loopen kjører, men på det risikable punktet stopper en approval-gate den og henter inn et menneske. Dette innlegget starter ett nivå tidligere. I stedet for å bremse loopen på ett punkt spør det hvor mye loop som i det hele tatt må finnes. Et beslutningspunkt i en strukturert flyt er en handling modellen aldri får fri råderett over. Begge deler er samme prinsipp, bare så mye autonomi som oppgaven krever: én gang ved handlingen, én gang ved arkitekturen.
Dermed griper de tidligere innleggene i serien inn i hverandre. Hvert av dem har dratt i en annen spak, alle i samme retning. Sju forgjengere, én driftsmodell - dette innlegget samler dem:
- Architecture trekker grensene mellom modell, tools og kode.
- Tools definerer hva et enkelt kall får lov til, og skiller intent fra execution.
- Evals sjekker før deploy om stiene holder.
- Observability gjør synlig hva som faktisk skjer i loopen.
- Rollout tar endringer til produksjon kontrollert og med mulighet for rollback.
- Human-in-the-Loop bremser loopen ved den risikable handlingen.
- Incident gjør hver hendelse om til en regresjonstest.
Evals, rollout og incident-loopen fanger feil etter at de har oppstått. Approval bremser dem før de får effekt. Loop-arkitekturen, som dette innlegget handlet om, bestemmer allerede ett trinn tidligere: hvor mange feil som i det hele tatt kan oppstå. Hvert step loopen ikke tar, er et step som ikke bare er riktig med 99 % sannsynlighet. Ti slike steps, og 99 % blir 90 %. Og en delete_account som aldri ligger ved siden av unsubscribe_marketing i det frie valgrommet, er en hel failure-klasse som ingen eval lenger må fange og ingen approval lenger må stoppe.



Dette er ikke noe anti-agent-manifest. Det finnes oppgaver som virkelig trenger den åpne loopen - åpen research, kreativ syntese, alt der subtaskene først viser seg mens man jobber. Der er struktur et bur, og en fri agent vinner. Men det forblir unntaket. Feilen ligger sjelden i å bygge en agent-loop. Den ligger i å ta den som et selvsagt utgangspunkt i stedet for å begrunne den.
Den som tar dette på alvor, starter neste feature med den snevreste arkitekturen som løser oppgaven, og åpner dimmeren først når evals og rollout-data rettferdiggjør det. Det er mer arbeid i starten og færre overraskelser i drift.
Tools-innlegget hadde en setning som gjaldt på nivået til det enkelte kallet: Det er ikke LLM-en som utfører, det er systemet som utfører. Én etasje opp, på nivået til hele flyten, gjelder den en gang til. Modellen leverer vurderingen på punktene der vurdering teller. Koden eier flyten.
Det er ikke LLM-en som styrer, det er systemet som styrer.
