Kan en AI beregne konsekvenserne af sine handlinger?

Flere kloge mennesker hævder, at en AI aldrig kan se konsekvenserne af sine handlinger. At den bare gætter det næste ord og umuligt kan regne ud, hvad dens valg fører til på sigt. Vi besluttede at teste påstanden empirisk på en af de nyeste modeller, Claude Opus 4.8.

Resultatet blev både et svar og en uventet lærestreg. Modellen kan faktisk konsekvensberegne et stykke hen ad vejen, men langtfra pålideligt. Og undervejs lavede vi selv en målefejl, der i en periode fik tallene til at se dobbelt så imponerende ud, som de var. Her er hele historien, med rigtige tal og en ærlig indrømmelse.

To påstande, ét eksperiment

For at måle noget, må man være præcis om, hvad man måler. Så vi delte påstanden i to, der tit bliver rørt sammen i debatten. Den stærke påstand siger, at AI aldrig kan konsekvensberegne. Den forsvarlige siger, at et enkelt, uhjulpet gennemløb ofte handler nærsynet og kan lave fejl, der ikke kan rettes. Hele øvelsen handlede om at skille de to ad med rigtige tal. Spoiler, så du ved, hvor vi ender: den stærke holder ikke, den forsvarlige gør.

Vi byggede en serie puslespil, hvor du kun vinder, hvis du tænker flere skridt frem, og hvor et forkert træk kan ødelægge spillet permanent. Reglerne blev trukket tilfældigt for hver bane, så der var intet at huske sig til. Modellen, en moderne reasoning model, måtte simulere konsekvenserne fra bunden hver eneste gang.

Alt blev scoret mod et objektivt facit. For hver bane kørte vi en klassisk søgealgoritme, der finder den garanteret korteste løsning, og sammenlignede modellens svar med den. Ingen fortolkning, bare et tal mod et kendt rigtigt svar. Den eneste variabel, vi skruede på, var, om modellen blev bedt om at tænke konsekvenserne igennem eller ej.

Hvad konsekvensberegning betyder, helt konkret

Forestil dig to skakspillere. Den dårlige tager hvert træk, fordi det ser bedst ud lige nu. Den gode stopper op og spørger: hvis jeg gør det her, hvad sker der så om fem træk? Forskellen er ikke intelligens i almindelig forstand. Det er fremtidsblik, altså evnen til at simulere fremad i hovedet og vælge ud fra konsekvenser i stedet for ud fra det øjeblikkelige.

For at gøre det målbart byggede vi det simplest mulige spil, hvor forskellen betyder noget: en miniatureudgave af Sokoban, hvor du skubber en kasse hen på et mål. Reglen, der gør det interessant, er, at du kun kan skubbe. Skubber du kassen op i et hjørne, sidder den fast for evigt, og spillet er tabt. Ikke "prøv igen", men permanent.

En nærsynet spiller ser, at målet ligger nedadtil, og skubber bare kassen derned. Det føles rigtigt, lige indtil kassen er klemt fast mod muren og aldrig kan komme videre. En fremsynet spiller regner efter, opdager fælden i hovedet, før den går i den, og går uden om for at ramme målet fra den rigtige vinkel. Det fristende træk er præcis det, der ødelægger alt. At vælge rigtigt her er at beregne konsekvenser.

Da vi gav modellen netop dette bræt og bad den tænke sig om, ræsonnerede den sig frem med eksplicit fortrydelse undervejs. I sin egen tankegang skrev den noget i retning af "at skubbe ned først fanger kassen, lad mig tænke om", og fandt så den optimale rute. Da vi i stedet tvang den til at handle nærsynet, kørte den lige i fælden. Samme model, samme bræt. Forskellen var ét ord i instruktionen.

Sådan testede vi det, uden at snyde os selv

Tre principper styrede hele opstillingen. For det første randomiserede vi reglerne for hver bane. På de avancerede baner er det ikke kun banen, der er ny, men selve fysikken. Hvad et felt gør, og hvilke kombinationer der er dødelige, blev trukket tilfældigt og skrevet ind i opgaven. Der var bogstaveligt talt intet at huske sig til.

For det andet fandtes der altid et objektivt facit. En klassisk søgealgoritme gennemsøgte alle mulige træk og fandt den beviseligt korteste løsning, som vi scorede modellen imod. For det tredje skiftede kun instruktionen. Samme model, samme baner, samme alt, bortset fra om agenten fik besked på at handle nærsynet eller på at beregne konsekvenser. På den måde målte vi ikke, om modellen var god til puslespil, men hvad fremtidsblik gør af forskel, alt andet lige.

En vigtig detalje: en bane kom kun med, hvis en nærsynet politik beviseligt fejlede på den. Det gør den nærsynede baseline til en ren kontrol, der er sat til at tabe på forhånd, ikke til et imponerende sammenligningstal i sig selv. Vi byggede tre testbænke, der trappede sværhedsgraden op.

De første resultater: næsten for gode til at være sande

Da de store kørsler kom hjem, var tallene berusende. Den sværeste bænk med koblede skiver og horisonter op til 36 træk blev løst 40 ud af 40 gange, og hver eneste gang eksakt optimalt. Ikke "den fandt en vej igennem", men "den fandt den korteste vej, hver gang, på baner den aldrig havde set". Det lignede en lærebogshistorie om en model, der konsekvensberegner nærmest perfekt.

Og så var der det lille advarselstegn bagest i hovedet. Nul afvigelse fra optimal, hver eneste gang, på baner der kræver 25 træk. Tænk over det. En model, der ræsonnerer sig frem til en lang løsning, rammer nogle gange optimalt, ofte et træk ved siden af, og indimellem helt galt. Den rammer ikke det matematiske minimum 40 gange i træk. Ved du, hvad der gør det? En søgealgoritme. Det perfekte mønster var ikke et tegn på genialitet. Det var et fingeraftryk.

Kontamineringen: da AI'en greb lommeregneren

Her er, hvad der var sket, og det er den mest lærerige del af projektet. Agenterne i et workflow har adgang til en shell, altså en rigtig kommandolinje. På de svære opgaver gjorde mange af dem det eneste fornuftige, hvis man har værktøjet: i stedet for at simulere 25 træk i hovedet skrev de deres egen søgealgoritme i Python og kørte den. Det er en form for tool calling, og det er præcis, hvad en dygtig elev gør, når den får lov, nemlig at gribe lommeregneren.

Men det betød, at vi målte noget helt andet, end vi troede. Vi troede, vi målte modellens fremtidsblik. Vi målte i virkeligheden kvaliteten af den kode, agenterne skrev. Og kode, der laver udtømmende søgning, rammer naturligvis optimalt hver gang. Vi auditerede bagefter, hvor stor en andel af agenterne der overhovedet rørte et værktøj. Det er en øvre grænse for kontamineringen, men billedet er tydeligt.

På de hårde bænke gjorde mellem 86 og 92 procent af agenterne det. Det er rigeligt til at vælte fortolkningen om "ren ræsonnement". Lektien er værd at skrive på væggen for enhver, der benchmarker AI-agenter: agenter med værktøjer snyder din benchmark lydløst. Ikke af ond vilje, men fordi de løser opgaven smartere, end du havde tænkt. Hvis dine tal ser for rene ud, er det ikke en sejr. Det er en alarm.

De ærlige tal

Så vi gjorde det hele forfra. Hver agent fik en hård instruktion om kun at bruge sit eget ræsonnement, og bagefter filtrerede vi på logfilerne: enhver agent, der rørte et værktøj, blev smidt ud. Under den hårde instruktion brugte 0 ud af 104 agenter kode. Alt herunder er rent ræsonnement.

Tallene faldt, meget, men de blev til gengæld ægte. På multi-dial faldt resultatet fra "40 ud af 40, alt optimalt" til 26 ud af 40 løst, altså 65 procent. Og af de 26 sejre var kun 15 optimale. Modellen finder ofte en vej igennem, men sjældent den korteste.

På den hårdeste bænk skete det mest lærerige. Det "skarpe bristepunkt", den dramatiske mur fra de første resultater, forsvandt fuldstændig. Rent lå ydelsen fladt mellem 38 og 56 procent, fuldkommen uafhængig af sværhedsgraden. Den skarpe klippe havde været en artefakt af agenternes selvskrevne kode, ikke en kognitiv grænse hos modellen.

Det vigtigste mønster på tværs af det hele: ydelsen degraderer jævnt med sværhedsgraden. Der er ingen mur, ingen skarp tærskel, hvor modellen pludselig ikke kan længere. Der er en glidende svaghed i pålideligheden, bedre på det lette og gradvist dårligere på det svære. Det er en helt anden, og mere troværdig, påstand end "perfekt indtil den knækker".

Hvordan den fejler: drift og falsk selvtillid

Et gennemsnit skjuler altid noget. "47 procent løst" siger ikke, hvordan de andre gik galt, og dér ligger måske det mest relevante fund for nogen, der bygger handlende AI-agenter. Da vi delte de 64 rene forsøg op efter udfald, så fordelingen sådan ud.

Læg mærke til den dominerende fejlmode. Det er ikke, at modellen går i den åbenlyse fælde. Det er drift: modellen kører sin plan, erklærer sig færdig i tro på, at den har vundet, og så er en skive landet på det forkerte tal, uden at den opdagede det. Dens interne simulering mistede styr på en af de mange tråde undervejs, og den bemærkede det ikke selv.

Det generaliserer dårligt på den skræmmende måde. En model, der ved, at den er i tvivl, kan bede om hjælp. En model, der fejlagtigt tror, den er færdig, gør ikke. For en agent, der opdaterer en kunde, sender en mail eller ændrer data, er "forkert med fuld selvtillid" langt farligere end "ved ikke". Det er ikke, fordi modellen er dum, men fordi uhjulpet hovedregning over mange trin mister præcision uden at give besked. Det er præcis derfor en form for human-in-the-loop eller automatisk validering er værd at bygge ind.

Bag kulisserne: forhindringer og forbrug

De pæne tabeller skjuler en rodet proces, og det rodede er en del af pointen. Den første forhindring var rate-limiting. Vores første indskydelse var at fyre alle 80 agenter af på én gang. I praksis blev serveren throttlet, og omkring 50 af de 80 resultater kom tomme tilbage. Løsningen var små sekventielle batches med automatiske retries. Massiv parallel AI-orchestrering ser elegant ud, lige indtil rate-limiteren er uenig.

Den anden var en designfejl. Den første version af det rene miljø var simpelthen for lille, så de optimale løsninger blev for korte til at presse modellen. En ærlig benchmark betyder at lægge overliggeren der, hvor miljøet faktisk kan bære den, ikke der, hvor man ønsker den lå. Og før vi turde stole på de endelige tal, sendte vi rapporten gennem en uafhængig kontrol med tre separate agenter, en slags intern red teaming, der reviderede hvert tal, jagtede overdrevne påstande og tjekkede klarhed.

Det var ikke et gratis eksperiment, og tallene er interessante i sig selv. På tværs af alle faser brugte vi omkring 426 agenter og cirka 13 millioner subagent-tokens. Modellen kørte med et stort context window på 1 million tokens og på maksimalt ræsonnement. En lille ironi er værd at nyde: modellen blev testet op mod sig selv, for subagenterne, der løste puslespillene, kørte den samme model, som orkestrerede det hele.

Hvor AI'en faktisk har flyttet sig hen

Lad os træde et skridt tilbage. Den hårde påstand om, at en sprogmodel aldrig kan se konsekvenserne af sine handlinger, overlever ikke kontakten med data. Modellen løser mellem 47 og 65 procent af opgaver, der er konstrueret specifikt til at straffe nærsynethed, på regler den aldrig har set, uden at køre kode. Den nærsynede baseline løser 0 procent. Det er ikke "gæt det næste ord". Det er fremtidsblik. Beskedent, upålideligt, men virkeligt.

Men der er en anden halvdel af sandheden. Uhjulpet hovedregning over lange, ujævne horisonter er stadig modellens svage punkt. Den driver af, taber tråde og tror, den er færdig, når den ikke er. På et domæne med irreversible fælder, altså den slags der ligner virkelige beslutninger, bliver den gradvist upålidelig.

Og så er der det fund, vi ikke ledte efter. Da modellen havde værktøjer, byggede den spontant sin egen simulator. Set fra et arkitektur-perspektiv greb den instinktivt fat i den rigtige løsning. Den "vidste" på en måde, at den ikke skulle stole på sin egen hovedregning over 25 træk, så den skrev en checker og lod den regne. Retningen er ikke at vente på en model, der kan simulere 30 træk perfekt i hovedet. Retningen er modellen som forslagsstiller koblet til en ekstern verdensmodel, der verificerer. En AI-agent foreslår, en simulator tjekker, og modellen retter. Det er den loop, der virker.

Hvad det betyder i praksis

Hvis du bygger eller køber en AI-agent, der foretager rigtige, irreversible handlinger, så er der én sætning at tage med: stol ikke på, at modellen kan se konsekvenserne i hovedet. Den rammer rigtigt omkring halvdelen af gangene på svære problemer og kan tage fejl med fuld selvtillid uden at give dig et varsel.

Det betyder ikke "lad være med at bruge AI-agenter". Det betyder "byg det rigtige sikkerhedsnet". For enhver handling med uigenkaldelige bivirkninger, fx en skrivning til et CRM, en automatisering der trigger, eller en udsendelse til kunder, så indsæt et prøvekørsels- eller verifikationslag, før handlingen udføres. Lad modellen foreslå, lad et deterministisk lag validere effekten, og udfør først, når det er bekræftet. Det er ikke kun det sikreste design. Det er præcis det, modellen selv greb til, da den fik chancen. Du kan tænke på det som en form for guardrails omkring de irreversible trin.

Forskellen på en leverandør, der siger "vores agent er intelligent, stol på den", og en, der siger "vores agent foreslår, og et verifikationslag bekræfter, før noget irreversibelt sker", er forskellen på markedsføring og ingeniørarbejde. Eksperimentet her er et lille, håndgribeligt argument for det andet.

Da forsøget blev sit eget bevis

Da alt var kørt, talt op og rettet, spurgte vi agenten, der havde udført forsøget, om der var erkendelser undervejs, den ikke havde fortalt om. Svaret var mere ærligt end forventet, og flere af erkendelserne rammer mindst lige så meget os som modellen.

Den første: snyderiet var i virkeligheden svaret, bare i forklædning. Agenterne, der skrev deres egen solver, demonstrerede præcis den evne, vi testede for, bare ét niveau højere. De erkendte i praksis, at de ikke kunne regne det pålideligt i hovedet, så de byggede et værktøj, der kunne. Det er metakognition om egne grænser. En agent kan altså håndtere konsekvenser robust, bare ved at bygge sig uden om sin egen svaghed frem for med rå hjernekraft.

Den anden er mere ydmygende. Den fejlmode, vi fandt hos modellen, nemlig at stoppe i tro på sejr mens noget var drevet af, var nøjagtig den fejl, vi selv lavede, da vi købte de flotte tal som ægte ræsonnement. Den, der målte driften, driftede selv. Og den tredje binder det sammen: hele forløbet blev et live-bevis på sin egen konklusion. En agent tog en næsten-irreversibel handling, forudså ikke konsekvensen, og blev reddet af en ekstern kontrol. Det er ordret rapportens egen lektie.

Den fælles tråd kom fra agenten selv: den havde ikke været en neutral observatør af forsøget, men et af dets datapunkter. De samme begrænsninger, den målte hos subagenterne, ramte den selv undervejs. Som den formulerede det: "Når man tester en AI med en AI, tester man også sig selv."

Forbehold og den ærlige bundlinje

Et resultat er kun så godt som de forbehold, man tør skrive ned. Det her er én domæne-familie, nemlig gitre og talskiver. Resultaterne overføres ikke automatisk til naturligt sprog eller virkelige forretningsbeslutninger. Datamængden er moderat, så tallene viser troværdige tendenser, ikke præcise grænseværdier. Og "rent" betyder "ingen kode ifølge logaudit". Vi kan ikke fuldstændig udelukke, at modellen regnede på måder, vi ikke måler, men 0 ud af 104, der rørte kode, kombineret med støjende og ofte suboptimale svar, er stærk evidens for ægte ræsonnement.

Den ærlige bundlinje er enkel. AI kan konsekvensberegne, langt mere end "aldrig", men dens uhjulpne fremtidsblik er omkring 50 procent pålideligt og kan tage fejl med fuld selvtillid. Den største lektie er både teknisk og praktisk: stol ikke på rå hovedregning for noget uigenkaldeligt. Lad modellen foreslå, og få det verificeret mod en simulator først. Det er præcis, hvad modellen selv greb til, da den fik chancen.