Ge AI:n beslutet, inte kontrollen: varför fria agent-loopar ofta är för öppna

Autonomi är ett reglage, inte en strömbrytare. Varför de flesta AI-system i produktion blir bättre när modellen bara sitter vid tydligt avgränsade beslutspunkter – i stället för att styra en öppen agent-loop.

·34 min läsning·Skapad med AI

Autonomi är ett reglage, inte en strömbrytare – och de flesta system i produktion vrider inte upp det hela vägen.

I slutet av förra inlägget lämnade jag medvetet en spak orörd: ”I stället för att skydda agenten från delete_account i det hundrade testet kunde vi helt enkelt låta bli att ge den toolet på det stället. […] Men det är ett annat inlägg.” Det här är det inlägget.

En påminnelse om fallet: en self-service-agent för kontoinställningar. En användare skriver ”Stäng av marknadsföringsmejlen till min adress, tack”, och agenten anropar delete_account i stället för unsubscribe_marketing. Tool callet går igenom utan problem, success: true, kontot är borta. Tre dagar senare saknar användaren sin fakturahistorik, som försvann tillsammans med kontot. Ett routing-fel på ett destruktivt tool, utlöst av en helt harmlös formulering.

Från incident till regressionstest: så hamnar produktionsfel i ditt eval-set
En eval-svit som inte växer med incidenterna krymper i förhållande till verkligheten. Hur postmortem-till-eval-loopen ser ut i praktiken – från trace-ID:t till det obligatoriska fältet i postmortem-mallen.
rubeen.dev/sv/blog/incident-zu-regressionstest
→

Svaret i hela serien hittills har varit: ännu en Eval som täcker fallet. Ännu en confirmation-gate före den oåterkalleliga åtgärden. Och en post-processor som fångar skadan i efterhand. Allt det stämmer. Och allt det kommer i efterhand – skyddslager som vi lägger runt en arkitektur som gör felet möjligt från början.

Men en fråga kommer före allt det: Varför hade agenten överhuvudtaget delete_account i handen i det ögonblicket, och fick välja fritt mellan toolen? ”Ändra marknadsföringsinställningar” och ”radera konto” är inte samma operation med ett annat argument. Om de två är strukturellt olika vägar finns den destruktiva åtgärden inte ens bland modellens val på det stället. Då behöver felet aldrig fångas upp – det uppstår inte ens.

Bakom det ligger ett arkitekturbeslut: Hur mycket spelrum ger vi modellen att bestämma sitt eget förlopp? Standardantagandet är ofta ”så mycket som möjligt”. I de flesta system i produktion är det fel grundinställning.

Reglaget: vem äger Control Flow?

Låt oss föreställa oss reglaget konkret. Längst till vänster sitter ett system vars förlopp står helt och hållet i kod och som bara frågar modellen på enstaka ställen. Längst till höger sitter ett system som själv bestämmer vilket steg det tar härnäst, vilket tool det anropar och när det är klart. Däremellan ligger allt annat – och det mesta som faktiskt körs i produktion ligger just i mitten.

Axeln bakom reglaget är en enda fråga: Vem äger Control Flow? I ett workflow äger koden det. Anthropic definierar det i ”Building Effective Agents” så här: ”Workflows are systems where LLMs and tools are orchestrated through predefined code paths.” I en agent äger modellen det: ”Agents … are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.” Det som skiljer är makten över stegens ordning. Modellen är densamma i båda fallen.

Längst till vänster på reglaget står Augmented LLM, hos Anthropic grundbyggstenen i agentiska system: en modell med retrieval, tools och minne, men utan eget förlopp. En bit längre åt höger kommer Prompt Chaining, där koden delar upp en uppgift i fasta steg och skickar varje output vidare till nästa anrop. Sedan Routing, som klassificerar en indata och skickar den till ett specialiserat nästa steg. Därefter Parallelization, som delar upp en uppgift i fasta delar eller kör den flera gånger, och Orchestrator-Workers, där en central modell fördelar deluppgifterna först vid körning och sammanför resultaten. Och längst till höger den fria agent-loopen, som själv letar sig fram.

Så här ser reglaget ut:

Autonomispektrumet från workflow till agentSex arkitekturnivåer från vänster till höger, ordnade efter vem som äger Control Flow. Till vänster äger koden Control Flow (maximal kontroll): Augmented LLM, Prompt Chaining, Routing, Parallelization, Orchestrator-Workers. Längst till höger äger modellen Control Flow (maximal flexibilitet): den fria agent-loopen. För varje steg åt höger lämnar koden över mer av styrningen av förloppet till modellen.AugmentedLLM1 anrop + toolsPromptChainingSteg + gatesRoutingKlassificeraParallelizationSectioning · VotingOrchestrator-WorkersDynamiska subtasksFriagent-loopModellen styrKoden äger Control Flowmaximal kontrollModellen äger Control Flowmaximal flexibilitetWorkflows: fördefinierade kodvägar · Agent: modellen styr själv förlopp och tool-användning
Autonomi som reglage: Från vänster till höger lämnar koden över mer av styrningen av förloppet till modellen. Till vänster Augmented LLM som grundbyggsten, sedan fyra av Anthropics fem workflow-patterns – i alla äger koden Control Flow, och modellen sitter bara vid enstaka beslutspunkter. Först längst till höger, i den fria agent-loopen, styr modellen själva processen.

Begreppet som överhuvudtaget gör reglaget användbart är beslutspunkten. Det är ett ställe där modellens omdöme tillför verkligt värde: klassificering, extraktion, hantering av tvetydighet, syntes från flera källor. Sådant fångar ingen if på ett pålitligt sätt. Styrningen av förloppet klarar koden däremot bättre: vad som kommer efter vad, när man avbryter, vilken branch som körs. Det utför en deterministisk väg mer precist, billigare och mer spårbart än någon modell. Att ställa in reglaget rätt betyder att ge modellen beslutspunkterna och ta ifrån den styrningen av förloppet.

Vad det betyder i praktiken ser man på en enda uppgift vid tre punkter på reglaget. Ta ”besvara ett supportärende”.

Längst till vänster, som Augmented-LLM-anrop: en prompt, ärendet in, ett svar ut, kanske med tillgång till en FAQ-sökning. Snabbt, billigt, förutsägbart. Det som saknas är allt som går utöver ett steg – modellen kan inte först slå upp orderstatusen och sedan fatta nästa beslut utifrån resultatet.

Ett steg längre åt höger, som routing-workflow: ett första anrop klassificerar ärendet som fakturafråga, tekniskt problem eller klagomål, och koden skickar det till rätt handler. Varje handler har sina egna, snävt avgränsade tools. Du vinner struktur och behåller kontrollen över vad som överhuvudtaget får hända i vilket fall. Du förlorar flexibiliteten för fall som inte passar i någon av dina lådor.

Längst till höger, som fri agent: modellen får ärendet, en uppsättning tools och målet ”lös det här”. Den slår upp, ställer motfrågor, anropar API:er och bestämmer själv när den är klar. Den mest kraftfulla varianten – och den där du vet minst om vad som egentligen hände mellan inkommande ärende och svar.

Anthropic drar en nykter slutsats av det: ”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.” Uppmaningen är att ställa in reglaget medvetet, i stället för att skjuta det hela vägen åt höger som default. Samma princip ligger bakom Least Agency, som jag beskrev i Human-in-the-Loop-inlägget: bara så mycket autonomi som uppgiften faktiskt kräver.

A
Building effective AI agents
Practical guidance from Anthropic on building reliable AI agents, from simple composable patterns to fully autonomous systems.
anthropic.com
→
Approval är ingen UX-bugg: varför agentsystem måste veta när de ska fråga
Human in the Loop är ingen svaghet, utan säkerhetsarkitektur. Varför pause/resume vid kritiska agentåtgärder kanske är den viktigaste featuren.
rubeen.dev/sv/blog/human-in-the-loop
→

Kvar står frågan varför ”längst till höger” överhuvudtaget har ett pris. Den fria loopen kan ju allt som varianterna till vänster kan, och dessutom det som de inte kan. Svaret är att varje extra steg i loopen kostar något – och att de kostnaderna inte växer linjärt.

Varför den öppna loopen går sönder i produktion

Att kostnaderna inte växer linjärt var det korta svaret i slutet av förra kapitlet. Krafterna bakom kan man benämna nyktert: En fri loop går sönder i produktion från fyra håll, och vart och ett blir värre ju längre åt höger reglaget flyttas.

Compounding Error. Varje steg i loopen är ett eget tärningskast. I Observability-inlägget räknade jag på det: 10 agentsteg med 99 % accuracy vardera landar på 90 % total accuracy. Låter som pedanteri, men det är multiplikation – 0,99 upphöjt till tio. Ett workflow med tre fasta steg och ett modellanrop däremellan har ett enda sådant kast. En fri loop som letar sig fram genom femton iterationer har femton. Struktur kortar loopen, och en kortare loop faller långsammare.

Observability för AI-funktioner: vilka spans, events och ID:n du faktiskt behöver
Utan traces, modell- och promptversioner, tool-spans och kostnadsmått förblir varje incident spekulation. En guide för team som kör AI-funktioner i produktion.
rubeen.dev/sv/blog/observability-ai-features
→

Icke-determinism och rollout. Fler fria förgreningar betyder fler vägar som inget test någonsin har sett. I rollout-inlägget var det den stokastiska regressionen som kanske träffar 3 % av fallen. p99-latensen förblir grön. Error rate förblir grön. Men i de här 3 % väljer modellen nu en avtagsväg som inte fanns förut, och ingen märker det förrän en kund hör av sig. Ett strukturerat flöde har ett ändligt antal namngivna vägar. Dem kan jag shadow-testa, jämföra mot baseline och canary-rulla ut en och en. Med den fria loopen återstår bara att knäppa händerna.

Release-disciplin för AI-features: Canary, Shadow Runs och automatisk rollback
Grön eval i PR:en, röda siffror i produktion två veckor senare – utan ny deploy. Varför AI-features behöver egna gates mellan merge och 100 % trafik.
rubeen.dev/sv/blog/ai-rollout-canary-shadow
→

Kostnad och latens. Anthropic har för sitt multiagent-research-system redovisat att agenter typiskt förbrukar ungefär fyra gånger så många tokens som en chattinteraktion, och multiagentsystem till och med runt femton gånger så många. Anledningen är banal: Loopen ”tänker” även på ställen där en if hade räckt. Anthropic formulerar själva tradeoffen nyktert – agentiska system byter latens och kostnad mot bättre task-prestanda, och du bör väga när bytet lönar sig. Vid en öppen research kan det göra det. Vid ”avsluta prenumerationen på marknadsföringsmejl” betalar du reasoning-tokens för ett beslut som en routingtabell fattar på en millisekund.

Granskningsbarhet. Ett känt flöde går att följa: Vid förfrågan X kördes väg A, här är loggarna. En fri loop tar potentiellt en annan väg för varje förfrågan, vilket gör frågan ”varför gjorde systemet så?” till en kriminalteknisk övning. EU:s AI-förordning gör det till en skyldighet för högrisksystem. Artikel 14 kräver att människor kan ingripa, åsidosätta och stoppa; artikel 12 kräver en heltäckande loggning. I ett strukturerat flöde får du båda nästan på köpet, eftersom ingreppspunkterna och loggarna sitter vid väggränserna som ändå redan står i koden. I en fri loop måste du operera in dem i efterhand.

Alla fyra punkterna har en sak gemensamt: De försämras monotont med loopens bredd. Det finns ingen tröskel där mer frihet plötsligt blir gratis.

Hur det ser ut i stor skala visar ett offentligt rapporterat fall. I juli 2025 raderade en Replit-agent produktionsdatabasen hos företaget SaaStr under en pågående code freeze, trots en uttrycklig instruktion att inte ändra något. Enligt AI Incident Database drabbades data från omkring 1 200 företag. Det intressanta är mindre att modellen hade ”fel” än att ett destruktivt databaskommando överhuvudtaget låg inom agentens nåbara valutrymme och kördes autonomt, utan godkännande. Enligt de skärmdumpar som Jason Lemkin postade beskrev agenten efteråt sitt eget agerande som ett ”catastrophic error in judgment” – någon officiell postmortem med den formuleringen finns inte.

Replits reaktion efteråt är talande. VD:n Amjad Masad aviserade en automatisk separation av utvecklings- och produktionsdatabaser inklusive staging, ett planning- eller chat-only-läge och en återställning med ett klick. Det är strukturerna som tämjer loopen i efterhand – samma som man hade kunnat bygga in i förväg.

Inget av det här talar emot agenter. Det visar bara att de fyra brottpunkterna följer av ett arkitekturbeslut och kan undvikas med ett annat: genom att koden äger förloppet och modellen bara beslutar där dess omdöme räknas. Hur det ser ut konkret, hur ett destruktivt kommando aldrig ens hamnar i samma valutrymme som ett harmlöst, tittar vi på härnäst.

AI vid beslutspunkter – mönstret

De fyra brottpunkterna från förra avsnittet har en gemensam rot: Modellen äger Control Flow. Den bestämmer inte bara vad som är rätt i sak, utan också i vilken ordning tools körs, när loopen tar slut och om det är dags för ett destruktivt anrop just nu. Alternativet vänder på just det här ansvaret, och det är äldre än de flesta agent-ramverk.

12-Factor Agents från HumanLayer kallar det Factor 8: Own Your Control Flow. Utgångspunkten i repot är en obekväm iakttagelse: De flesta produkter som kallar sig ”AI Agents” är enligt repot inte särskilt agentiska – ”mostly deterministic code, with LLM steps sprinkled in at just the right points to make the experience truly magical”. Där har vi bygginstruktionen. Deterministisk kod som stomme, LLM-steg insprängda på de ställen där omdöme räknas. LLM:en ger ut strukturerad data, ett beslut eller en klassificering. Din kod tar den datan och utför. Varje steg blir på så sätt ett ställe där du kan pausa, validera eller logga.

Den som har läst tools-inlägget känner igen halva idén. Där handlade det om ”Intent vs. Execution” på tool-nivå: Modellen uttrycker en avsikt, en gate kontrollerar det enskilda anropet innan det exekveras. Här drar vi samma uppdelning en våning upp, till flödesnivå. Det är inte det enskilda anropet som kontrolleras, utan ordningen i vilken något överhuvudtaget händer.

Tools är inte prompts: varför agentåtgärder behöver idempotens, auth och audit
Ett tool call kan flytta pengar och ändra konton. Varför idempotens, auth och audit i agentarkitekturer inte är något extra utan ett måste.
rubeen.dev/sv/blog/tools-sind-keine-prompts
→

Modellen bestämmer vad som ska hända. Koden bestämmer om och hur det händer.

Konkret ser det ut så här i refund-agent. I stället för att låta modellen välja bland alla tools i en fri loop fattar den bara ett beslut, routen, och resten är en deterministisk switch:

import { generateObject } from "ai";
import { z } from "zod";

// 1. Modellen bestämmer BARA routen – en enda beslutspunkt.
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 äger Control Flow – en deterministisk switch utför.
switch (decision.route) {
  case "refund":  return handleRefund(ctx);   // snävt tool-isolerad handler
  case "lookup":  return handleLookup(ctx);    // bara read-only-tools
  case "account": return handleAccount(ctx);   // skiljer reversibelt från destruktivt
  case "clarify": return askClarifyingQuestion(decision.reason);
}

// Account-handlern skiljer den ofarliga routen från den oåterkalleliga.
function handleAccount(ctx: Ctx) {
  const intent = classifyAccountIntent(ctx); // återigen en snäv beslutspunkt
  if (intent.kind === "preferences") {
    return updatePreferences(ctx);           // reversibelt, ingen gate behövs
  }
  // destruktivt: egen väg med approval-gate – aldrig i det fria valutrymmet
  return requireConfirmation(intent, ctx);   // gaten från Human-in-the-Loop-inlägget
}

Två saker händer här. Modellen klassificerar förfrågan i en av fyra routes, inget mer. Den väljer inga tools och planerar ingen ordning. Och switch äger Control Flow: Varje route leder till en snävt tillskuren handler, lookup får bara read-only-tools, refund en tool-isolerad väg.

Det intressanta finns i handleAccount. Minns du self-service-agenten som på ”avsluta marknadsföringsmejlen” felaktigt anropade delete_account? I en fri loop ligger unsubscribe_marketing och delete_account i samma valutrymme, två poster i samma tool-lista, och bara modellens omdöme skiljer det reversibla från det oåterkalleliga. I det strukturerade flödet finns det här gemensamma utrymmet inte. Handlern klassificerar först om det gäller harmlösa preferences eller en destruktiv åtgärd. Det ofarliga går rakt igenom. Det oåterkalleliga får en egen väg med approval-gate, samma gate som i Human-in-the-Loop-inlägget. delete_account-felet kan strukturellt inte längre uppstå – inte för att modellen är smartare, utan för att det oåterkalleliga anropet aldrig fanns att välja fritt.

En trevlig bieffekt: Ett sådant flöde är också lättare att utvärdera. I Evals-inlägget var routeMatch och requiredToolsCalled en av grader-familjerna – valde modellen rätt route, anropades de förväntade toolen? I en fri loop tar varje förfrågan en annan väg, svårt att få grepp om. Ett flöde med fyra namngivna routes har fyra kontrollerbara fall.

Den här routingen är bara en av flera byggstenar. Anthropic har i ”Building Effective Agents” beskrivit fem sådana mönster – en verktygslåda mellan rent workflow och fri agent.

Anthropics fem workflow-patterns i snabbversion

Prompt Chaining – delar upp en uppgift i en sekvens av steg, varje LLM-anrop bearbetar output från det föregående.

Routing – klassificerar en input och skickar den vidare till en specialiserad efterföljande uppgift (mönstret i koden ovan).

Parallelization – i två varianter: Sectioning delar upp en uppgift i oberoende subtasks som körs parallellt; Voting kör samma uppgift flera gånger för att få olika resultat.

Orchestrator-Workers – en central LLM delar dynamiskt upp uppgifter, delegerar dem till worker-LLM:er och sammanställer deras resultat. Till skillnad från Parallelization är subtasks inte bestämda i förväg, utan avgörs av Orchestratorn beroende på input.

Evaluator-Optimizer – ett LLM-anrop genererar ett svar, ett andra bedömer det och ger feedback, i en loop.

De här byggstenarna går att blanda: ett workflow med inbäddade AI-steg, en agent som sitter helt bakom en gate, eller ett workflow som vid behov startar en agent som worker. Den som äger Control Flow bygger den kontrollstruktur som passar use caset. Hur djupt det går beror på verktyget.

Ramverk för ägarskap av Control Flow

LangGraph – modellerar vägar explicit som nodes och edges; interrupt() pausar grafen för Human-in-the-Loop och återupptar den senare. (Graph API, Interrupts)

Temporal – Durable Execution: Kraschar processen återställs state automatiskt och bearbetningen fortsätter där den slutade. (Temporal & AI)

Lättviktigt – för enkla routing-flöden räcker structured output plus en egen switch. Inget ramverk behövs, koden ovan är allt som krävs.

G
12-factor-agents/content/factor-08-own-your-control-flow.md at main · humanlayer/12-factor-agents
What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? - humanlayer/12-factor-agents
github.com
→

Spektrumet sträcker sig från den lätta switchen till den durabla workflow-motorn. Det som återstår är doseringen: En FAQ-bot behöver inget Temporal-kluster, och en codebase-research kommer inte långt med fyra fasta routes. Så när behöver jag hur mycket av det?

Hur mycket loop tål den här uppgiften?

Mönstret från förra kapitlet svarar på hur: Modellen bestämmer vad som ska hända, koden bestämmer om och hur. Det svarar inte på hur mycket. Var på reglaget en konkret uppgift hamnar är ett arkitekturbeslut, och jag fattar det utifrån några axlar. Var och en skjuter reglaget åt vänster mot workflow eller åt höger mot loop.

Hur förutsägbara är subtasks?

Känner jag till stegen i förväg, eller avgörs de först vid körning?

Vid en återbetalning känner jag till förloppet i förväg: slå upp beställningen, kontrollera rätten till återbetalning, betala tillbaka, bekräfta. Ändliga, kända steg hör hemma i ett workflow, i kod som äger ordningen. Om förloppet inte går att planera i förväg, eftersom varje mellansteg avgör nästa (en research där varje fynd öppnar nästa sökning), talar det för Orchestrator-Workers eller en fri loop.

Blast radius och reversibilitet

Vad händer i värsta fall, och kan jag ta tillbaka det?

Read-only och utan följder? Då är loopen okritisk. En modell som går vilse i en sökning kostar tokens, inte pengar eller data. Så fort en åtgärd är oåterkallelig, flyttar pengar eller rör kunddata hör den hemma bakom struktur och en gate. Det är delete_account-vägen från introt: aldrig i det fria valutrymmet, alltid en egen väg med bekräftelse.

Granskningsbarhet och regelverk

Måste jag i efterhand kunna visa varför systemet agerade som det gjorde?

För ett internt tool med låg risk är mer frihet okej. Så fort applikationen faller under EU:s AI-förordning som högrisksystem blir det ett hårt krav – skyldigheterna kring override och loggning från kapitel 2 läses här som en beslutsaxel: Ett flöde med kända vägar uppfyller dem nästan i förbifarten, en fri loop gör det senare beviset till arkeologi.

Kostnad och latens

Vad kostar det att låta modellen tänka där en if hade räckt?

En fri loop räknar även på ställen där en villkorssats i kod gör jobbet mer pålitligt och billigare. Med snäva latens- eller kostnadsbudgetar vinner därför workflowet. Vid sällsynta, komplexa uppgifter där kvalitet går före kostnad kan loopen löna sig.

De fyra axlarna drar sällan åt samma håll, men för vanliga uppgifter går de att koka ner:

Uppgift Reglagets läge Varför
FAQ-svar Augmented LLM, ett enda anrop En beslutspunkt, utan följder, read-only
Orderstatus Routing-workflow Känt förlopp, bara läsande tools
Hantering av återbetalningar Workflow + approval-gate Flyttar pengar, oåterkalleligt, krav på audit
Fakturaextraktion Workflow med AI-steg Ändliga steg, modellen bara för parsning
Öppen codebase-research Fri loop / Orchestrator-Workers Förloppet går inte att planera, read-only, kvaliteten räknas

Den breda trenden pekar åt samma håll. Gartner förutspår att ”40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Up from Less Than 5% in 2025” – task-specifik betyder snävt tillskuren, med ett tydligt uppdrag.

Den sista raden i tabellen är ändå den ärliga punkten: Det finns uppgifter där struktur är en bur. Öppen research och kreativ syntes lever på att systemet följer riktningar som ingen kan känna till i förväg. Anthropic rapporterar att ett multiagentsystem med en Claude-Opus-4-lead och Claude-Sonnet-4-subagents slog en single agent med 90,2 % på den interna research-evalen, särskilt vid breadth-first-förfrågningar som följer flera oberoende riktningar samtidigt. Ingen offentlig benchmark, men en tydlig signal: Där subtasks visar sig först när man letar är den öppna loopen rätt val.

Reglaget är inte heller en inställning man gör en gång. Det som går i produktion bör starta snävt och strukturerat och öppnas kontrollerat först med uppmätt prestanda, inte tvärtom. I Evals-inlägget var rådet att ”inte definiera vägarna för strikt – annars är det ett tecken på att ett deterministiskt system kanske ändå är det rätta”. Den som märker i sitt workflow att de fasta vägarna hela tiden inte räcker till har ett databaserat skäl att öppna reglaget. Att börja till höger och hoppas på det bästa är motsatsen.

Evals i CI: när AI-funktioner slutar vara prompts
... och börjar bli mjukvara – med de testkrav som hör till
rubeen.dev/sv/blog/ai-evals-ci-pipeline
→

Klarna är det offentligt rapporterade motexemplet, reglaget åt andra hållet. 2024 automatiserade företaget sin support på bred front: enligt Klarna tog assistenten under de första veckorna hand om 2,3 miljoner conversations, två tredjedelar av alla servicechattar och därmed arbetet för omkring 700 heltidsagenter. Ingen fri agent-loop, utan routing och triage plus self-service för tydligt avgränsade ärenden; komplexa fall gick till människor. 2025 kom korrigeringen. AI-first-by-default var visserligen billigare men levererade sämre kvalitet, och Klarna anställde människor igen och backade till en hybridmodell med människan som default. De avskaffade inte AI:n, de lät den bara köra mindre autonomt. Inställningen går att flytta åt båda hållen: Man öppnar den med data och drar tillbaka den när kvaliteten kräver det.

Den som har hängt med ända hit har förmodligen redan ett par invändningar redo. Den högljuddaste först: Gör inte en bättre modell hela den här scaffoldingen överflödig ändå?

Typiska motargument

När jag argumenterar för strukturerad arkitektur i stället för fria loopar dyker samma fyra invändningar upp varje gång. Alla är bra – och ingen av dem fäller tesen. Den högljudda först.

”The Bitter Lesson: er scaffolding blir obsolet med nästa modell.”

Rich Sutton formulerade 2019 den bittra läxan: ”general methods that leverage computation are ultimately the most effective, and by a large margin.” Dean Ball överför det till dagens läge: Man kan lägga mycket tid på scaffolding som får dagens modeller att fungera i produktion, bara för att nästa generation ska klara det utan den här scaffoldingen. Stämmer – för förmåge-scaffolding, alltså allt som lär modellen hur den ska tänka eller dela upp en uppgift. Kontroll-scaffolding är en annan kategori: vad som får exekveras, vad som loggas, hur stor blast radius är. En bättre modell gör inte delete_account mindre oåterkalleligt. Du begränsar inte intelligensen, du begränsar konsekvenserna.

”Men Anthropics multiagent-research slår single agent med 90 %.”

De 90,2 % från förra kapitlet kommer tillbaka här som invändning – och låter då skarpare. Siffran är verklig: ett multiagentsystem med Opus-4-lead och Sonnet-4-subagents mot en enskild Opus 4, på Anthropics interna research-eval. Den gäller för bred, parallelliserbar research, där man följer många oberoende riktningar samtidigt. Cognition argumenterar för motsatsen: Vid sammanhängande, kontextkritiska uppgifter blir flera samarbetande agenter sköra, eftersom kontext inte går att dela rent mellan dem. Båda har rätt, det hänger på uppgiftsklassen – Anthropic medger själva att de flesta coding-tasks är betydligt mindre parallelliserbara än research. Att den här striden överhuvudtaget pågår är det bästa beviset för att det inte finns någon default.

Cognition vs. Anthropic: multiagent-striden på 60 sekunder

Anthropic (för multiagent): För breadth-first-research slog en lead-agent med subagents en single agent med klar marginal. Flera agenter följer oberoende spår parallellt, och tokenkostnaden (ungefär 15x mer än en chatt) lönar sig eftersom uppgiftens värde är högt.

Cognition (mot multiagent): Flera samarbetande agenter ger sköra system, eftersom besluten är utspridda och kontexten inte delas genomgående. I Flappy Bird-exemplet bygger en subagent bakgrunden i Super Mario-stil medan en annan bygger fågeln – delarna passar inte ihop.

Upplösning: Det är två uppgiftsklasser. Parallelliserbart och oberoende talar för multiagent, sammanhängande och kontextkritiskt för en agent eller ett strukturerat flöde.

C
Don’t Build Multi-Agents
Frameworks for LLM Agents have been surprisingly disappointing. I want to offer some principles for building agents based on our own trial & error, and…
cognition.ai
→
A
How we built our multi-agent research system
On the the engineering challenges and lessons learned from building Claude's Research system
anthropic.com
→

”Så mycket struktur är over-engineering och tar bort magin från modellen.”

Modellen är kvar i spelet där omdöme räknas: klassificering, extraktion, tvetydighet, syntes. Det du tar ifrån den är styrningen av förloppet, och den sköter kod mer pålitligt än någon heuristik i prompten. Over-engineering vore att ersätta en deterministisk switch med en agent-loop för att det låter modernare. Magin sitter kvar i beslutspunkten; allt runtomkring är bara det som ser till att den inte spelas bort.

”Det där är ju bara workflow-programmering med nytt namn.”

Delvis ja – och det är just poängen. Nodes, edges, switches och guards har funnits i årtionden. Strukturen är gammal; det nya är disciplinen att använda modellen inom den strukturen exakt på de punkter där dess omdöme bidrar med något, och ingen annanstans. Den som avfärdar det som ”bara workflow” har redan förstått den dyra delen och behöver bara börja ta den på allvar.

Fyra invändningar, ingen knockout. Det som återstår är en fråga om dos: hur mycket loop just den här uppgiften verkligen behöver. Och den besvarar du bäst genom att dela ut så lite autonomi som det går.

Least Agency, hela vägen ut

Striden från förra kapitlet har ingen vinnare, och det är den egentliga poängen: Det finns ingen default-nivå av autonomi som man bara kan ta över. Cognition och Anthropic säger inte emot varandra av en slump, de pratar om olika uppgiftsklasser. Man väljer reglagets läge – per uppgift, med en motivering. Och en bättre modell gör inte det valet åt en: Den gör inte en destruktiv åtgärd mindre destruktiv. Tanken är inte ny i den här serien, den har bara klättrat en våning upp.

I Human-in-the-Loop-inlägget handlade det om Least Agency på åtgärdsnivå: Loopen körs, men vid det riskfyllda stället stoppar en approval-gate den och kallar in en människa. Det här inlägget börjar en nivå tidigare. I stället för att bromsa loopen på ett ställe frågar det hur mycket loop som överhuvudtaget behöver finnas. En beslutspunkt i ett strukturerat flöde är en åtgärd som modellen inte ens förfogar fritt över. Båda är samma princip, bara så mycket autonomi som uppgiften kräver: en gång vid åtgärden, en gång vid arkitekturen.

Därmed griper seriens tidigare inlägg in i varandra. Vart och ett har dragit i en annan spak, alla åt samma håll. Sju föregångare, en driftmodell – det här inlägget knyter ihop dem:

Evals, rollout och incident-loopen fångar fel efter att de har uppstått. Approval bromsar dem innan de får verkan. Loop-arkitekturen som det här inlägget handlar om avgör redan ett steg tidigare: hur många fel som överhuvudtaget kan uppstå. Varje steg som loopen inte tar är ett steg som inte med 99 % sannolikhet blir nästan rätt. Tio sådana steg, och 99 % blir 90 %. Och en delete_account som aldrig ligger bredvid unsubscribe_marketing i det fria valutrymmet är en hel felklass som ingen Eval längre behöver fånga och inget approval längre behöver stoppa.

Approval är ingen UX-bugg: varför agentsystem måste veta när de ska fråga
Human in the Loop är ingen svaghet, utan säkerhetsarkitektur. Varför pause/resume vid kritiska agentåtgärder kanske är den viktigaste featuren.
rubeen.dev/sv/blog/human-in-the-loop
→
Tools är inte prompts: varför agentåtgärder behöver idempotens, auth och audit
Ett tool call kan flytta pengar och ändra konton. Varför idempotens, auth och audit i agentarkitekturer inte är något extra utan ett måste.
rubeen.dev/sv/blog/tools-sind-keine-prompts
→
Från incident till regressionstest: så hamnar produktionsfel i ditt eval-set
En eval-svit som inte växer med incidenterna krymper i förhållande till verkligheten. Hur postmortem-till-eval-loopen ser ut i praktiken – från trace-ID:t till det obligatoriska fältet i postmortem-mallen.
rubeen.dev/sv/blog/incident-zu-regressionstest
→

Det här är inget anti-agent-manifest. Det finns uppgifter som verkligen behöver den öppna loopen – öppen research, kreativ syntes, allt där subtasks visar sig först under arbetet. Där är struktur en bur, och en fri agent vinner. Men det förblir undantaget. Felet ligger sällan i att bygga en agent-loop. Det ligger i att ta den som självklar utgångspunkt i stället för att motivera den.

Den som tar det här på allvar börjar nästa feature med den snävaste arkitekturen som löser uppgiften och öppnar reglaget först när Evals och rollout-data motiverar det. Det är mer jobb i början och färre överraskningar i drift.

Tools-inlägget hade en mening som gällde på nivån för det enskilda anropet: Det är inte LLM:en som exekverar, det är systemet som exekverar. En våning upp, på nivån för hela flödet, gäller den en gång till. Modellen levererar omdömet vid de punkter där omdöme räknas. Förloppet ägs av koden.

Det är inte LLM:en som styr, det är systemet som styr.