Hvorfor sprogmodeller bliver “tabt” i samtale

En ny rapport fra Microsoft Research og Salesforce viser, at selv de mest avancerede Large Language Models (LLM’er) falder fra hinanden, når instruktioner gives i étaper frem for på én gang. Forfatterne fandt, at præstationen falder med gennemsnitligt 39 procent over seks opgaver, når en prompt er splittet over flere omgange:

En enkelt omgangssamtale (venstre) giver de bedste resultater, men er unaturlig for slutbrugeren. En multi-omgangssamtale (højre) finder selv de højest rangerede og mest performante LLM’er taber den effektive impuls i en samtale. Kilde: https://arxiv.org/pdf/2505.06120

Mere slående, tager tilstedeværelsen af svar en dyk, med prestigefyldte modeller som ChatGPT-4.1 og Gemini 2.5 Pro svingende mellem næsten perfekte svar og manifeste fejl, afhængigt af, hvordan den samme opgave er formuleret; yderligere kan output-konsistensen falde med mere end halvdelen undervejs.

Til at udforske dette adfærd, introducerer rapporten en metode kaldet sharding*, som splitter fuldt specificerede prompts i mindre fragmenter og frigiver dem én ad gangen i en samtale.

I de mest grundlæggende termer, er dette lig med at give en samlet og omfattende enkelt ordre på en restaurant, hvilket efterlader tjeneren med intet at gøre, men at anerkende anmodningen; eller også beslutter man sig for at angribe sagen samarbejdende:

To ekstreme versioner af en restaurant-samtale (ikke fra den nye rapport, kun til illustrative formål).

Til betoning, sætter eksemplet ovenfor måske kunden i et negativt lys. Men den grundlæggende idé, der er afbildet i den anden kolonne, er en transaktionsmæssig udveksling, der klargører et problem-sæt, før det behandles – åbenbart en rationel og rimelig måde at angribe en opgave på.

Dette setup er reflekteret i den nye arbejds sharded tilgang til LLM-interaktion. Forfatterne bemærker, at LLM’er ofte genererer for lange svar og derefter fortsætter med at stole på deres egne indsigt selv efter, at disse indsigt er blevet vist at være forkerte eller irrelevante. Denne tendens kombineret med andre faktorer kan få systemet til at tabe overblikket over udvekslingen helt.

I virkeligheden bemærker forskerne, hvad mange af os har fundet anekdotisk – at den bedste måde at få samtalen tilbage på sporet er at starte en ny samtale med LLM’en.

‘Hvis en samtale med en LLM ikke førte til de forventede resultater, kan starten af en ny samtale, der gentager den samme information, muligvis føre til betydeligt bedre resultater end at fortsætte en igangværende samtale.

‘Dette skyldes, at nuværende LLM’er kan blive tabt i samtalen, og vores eksperimenter viser, at det er ineffektivt at fastholde en samtale med modellen. Derudover, da LLM’er genererer tekst med tilfældighed, kan en ny samtale muligvis føre til forbedrede resultater.’

Forfatterne anerkender, at agente-systemer som Autogen eller LangChain potentielt kan forbedre resultaterne ved at fungere som fortolkningslag mellem slutbrugeren og LLM’en, kun kommunikerer med LLM’en, når de har samlet nok ‘sharded’ svar til at koagulere til en enkelt samlet forespørgsel (som slutbrugeren ikke vil blive eksponeret for).

Men forfatterne hævder, at et separat abstraktionslag ikke burde være nødvendigt, eller også burde bygges direkte ind i kilde-LLM’en:

‘Et argument kan fremføres, at multi-omgangs-kapaciteter ikke er en nødvendig funktion i LLM’er, da det kan offloads til agent-rammen. Med andre ord, har vi brug for native multi-omgangs-understøttelse i LLM’er, når en agent-ramme kan orkestrere interaktioner med brugere og udnytte LLM’er kun som single-omgangs-operatører?…’

Men efter at have testet påstanden over deres række af eksempler, konkluderer de:

‘[At] afhænge af en agent-lignende ramme til at behandle information kan være begrænsende, og vi argumenterer for, at LLM’er skal naturligt understøtte multi-omgangs-interaktion’

Dette interessante nye papir er titlen LLM’er bliver tabt i multi-omgangs-samtale, og kommer fra fire forskere over MS Research og Salesforce,

Fragmenterede samtaler

Den nye metode splitter først konventionelle single-omgangs-instruktioner op i mindre shards, designed til at blive introduceret på nøgleøjeblikke under en LLM-interaktion, en struktur, der reflekterer den eksplorerende, frem-og-tilbage-stil af engagement, set i systemer som ChatGPT eller Google Gemini.

Hver oprindelig instruktion er en enkelt, selvstændig prompt, der leverer hele opgaven på én gang, kombinerer en høj-niveau-spørgsmål, understøttende kontekst og eventuelle relevante betingelser. Den sharded version splitter dette op i flere mindre dele, hvor hver shard kun tilføjer ét stykke information:

Parrede instruktioner, der viser (a) en fuldstændig prompt leveret i en enkelt omgang og (b) dens sharded version brugt til at simulere en under-specifieret, multi-omgangs-samtale. Semantisk set leverer hver version den samme informations-nyttestof.

Den første shard introducerer altid hovedmålet for opgaven, mens resten leverer klarificerende detaljer. Sammen leverer de den samme indhold som den oprindelige prompt, men fordelt naturligt over flere omgange i samtalen.

Hver simuleret samtale udvikler sig mellem tre komponenter: assistenten, modellen under evaluering; brugeren, en simuleret agent med adgang til den fulde instruktion i sharded form; og systemet, som invigilerer og scorer udvekslingen.

Samtalen begynder med, at brugeren afslører den første shard, og assistenten svarer frit. Systemet klassificerer derefter svaret i en af flere kategorier, såsom en klarificerings-anmodning eller en fuld svar-forsøg.

Hvis modellen gør et svar-forsøg, trækker en separat komponent kun den relevante del ud til evaluering, ignorere eventuel omgivende tekst. På hver ny omgang afslører brugeren en yderligere shard, hvilket udløser et nyt svar. Udvekslingen fortsætter, indtil enten modellen får svaret rigtigt eller der ikke er flere shards tilbage at afsløre:

Diagram over en sharded samtale-simulation, med den evaluerede model fremhævet i rød.

Tidlige tests viste, at modeller ofte spurgte om information, der ikke var blevet delt endnu, så forfatterne droppede idéen om at afsløre shards i en fast orden. I stedet blev en simulator brugt til at bestemme, hvilken shard der skulle afsløres næste, baseret på, hvordan samtalen udviklede sig.

Bruger-simulatoren, implementeret ved hjælp af GPT-4o-mini, fik derfor fuld adgang til både den fulde instruktion og samtale-historien, og blev bedt om at bestemme, på hver omgang, hvilken shard der skulle afsløres næste, baseret på, hvordan udvekslingen udviklede sig.

Bruger-simulatoren omformulerede også hver shard for at fastholde samtale-flow, uden at ændre meningen. Dette tillod simuleringen at reflektere ‘give-and-take’ af virkelig dialog, samtidig med at kontrollen over opgave-strukturen blev fastholdt.

Før samtalen begynder, får assistenten kun den grundlæggende information, der er nødvendig for at fuldføre opgaven, såsom en database-skema eller en API-reference. Den bliver ikke fortalt, at instruktionerne vil blive brudt op, og den bliver ikke vejledt mod en bestemt måde at håndtere samtalen på. Dette gøres med vilje: i virkelighedens verden er modeller næsten aldrig fortalt, at en prompt vil være ufuldstændig eller opdateret over tid, og udeladelse af denne kontekst hjælper simuleringen med at reflektere, hvordan modellen opfører sig i en mere realistisk kontekst.

GPT-4o-mini blev også brugt til at bestemme, hvordan modellens svar skulle klassificeres, og til at trække det endelige svar ud af disse svar. Dette hjalp simuleringen med at forblive fleksibel, men introducerede lejlighedsvis fejl: dog fandt forfatterne efter at have kontrolleret flere hundrede samtaler manuelt, at færre end fem procent havde nogen problemer, og færre end to procent viste en ændring i resultatet på grund af dem, og de betragtede dette som en lav nok fejlrate inden for projektets parametre.

Simuleringsscenarier

Forfatterne brugte fem typer simulering til at teste modellens adfærd under forskellige betingelser, hver en variation over, hvordan og hvornår dele af instruktionen afsløres.

I Full-indstillingen modtager modellen den fulde instruktion på én gang. Dette repræsenterer den standardmæssige benchmark-format og fungerer som performances-baseline.

Sharded-indstillingen splitter instruktionen op i flere dele og leverer dem én ad gangen, simulerer en mere realistisk, under-specifieret samtale. Dette er den primære indstilling, der bruges til at teste, hvordan modeller håndterer multi-omgangs-input.

I Concat-indstillingen syes shardsene sammen igen som en enkelt liste, bevarende deres formulering, men fjernende omgangs-strukturen. Dette hjælper med at isolere effekterne af samtale-fragmentering fra omformulering eller indholdstab.

I Recap-indstillingen kører som Sharded, men tilføjer en sidste omgang, hvor alle tidligere shards genopsummeres, før modellen giver et sidste svar. Dette tester, om en sammenfatnings-prompt kan hjælpe med at genskabe tabt kontekst.

Til sidst går Snowball videre, ved at gentage alle tidligere shards på hver omgang, og holder den fulde instruktion synlig, mens samtalen udvikler sig – og tilbyder en mere tilgængelig test af multi-omgangs-evne.

Simuleringstyper baseret på sharded instruktioner. En fuldt specificeret prompt er splittet op i mindre dele, som kan bruges til at simulere enten single-omgang (Full, Concat) eller multi-omgangs-samtaler (Sharded, Recap, Snowball), afhængigt af, hvor hurtigt informationen afsløres.

Opgaver og metrikker

Seks generations-opgaver blev valgt for at dække både programmering og naturlig sprog-domæner: kode-genererings-prompts blev taget fra HumanEval og LiveCodeBench; Text-to-SQL-forespørgsler blev hentet fra Spider; API-kald blev konstrueret ved hjælp af data fra Berkeley Function Calling Leaderboard; grundlæggende matematik-problemer blev leveret af GSM8K; tabel-beskrivelses-opgaver var baseret på ToTTo; og multi-dokument-sammenfattelser blev trukket fra Summary of a Haystack-dataset.

Modellens præstation blev målt ved hjælp af tre kerne-metrikker: gennemsnitlig præstation, evne og utilstedelighed.

Gennemsnitlig præstation fangede, hvor godt en model gjorde det samlet over flere forsøg; evne reflekterede de bedste resultater, en model kunne nå, baseret på dens top-score-de outputs; og utilstedelighed målte, hvor meget disse resultater varierede, med større mellemrum mellem bedste og værste resultater, der indikerede mindre stabil adfærd.

Alle score blev placeret på en 0-100 skala for at sikre konsistens over opgaver, og metrikker blev beregnet for hver instruktion – og derefter gennemsnitligt for at give en samlet billed af modellens præstation.

Seks sharded-opgaver, der blev brugt i eksperimenterne, dækkende både programmering og naturlig sprog-generering. Hver opgave vises med en fuldt specificeret instruktion og dens sharded version. Mellem 90 og 120 instruktioner blev tilpasset fra etablerede benchmarks for hver opgave.

Medvirkende og tests

I de initielle simuleringer (med en estimeret omkostning på 5000 dollars), blev 600 instruktioner, der dækkede seks opgaver, sharded og brugt til at simulere tre samtale-typer: full, concat og sharded. For hver kombination af model, instruktion og simuleringstype, blev ti samtaler kørt, producerende over 200.000 simuleringer i alt – et schema, der gjorde det muligt at fange både samlet præstation og dybere målinger af evne og utilstedelighed.

Femten modeller blev testet, der dækkede en bred vifte af udbydere og arkitekturer: OpenAI-modellerne GPT-4o (version 2024-11-20), GPT-4o-mini (2024-07-18), GPT-4.1 (2025-04-14), og tænke-modellen o3 (2025-04-16).

Anthropic-modellerne var Claude 3 Haiku (2024-03-07) og Claude 3.7 Sonnet (2025-02-19), adgang via Amazon Bedrock.

Google bidrog med Gemini 2.5 Flash (preview-04-17) og Gemini 2.5 Pro (preview-03-25). Meta-modellerne var Llama 3.1-8B-Instruct og Llama 3.3-70B-Instruct, samt Llama 4 Scout-17B-16E, via Together AI.

De andre indgange var OLMo 2 13B, Phi-4 og Command-A, alle adgang via Ollama eller Cohere API; og Deepseek-R1, adgang via Amazon Bedrock.

For de to ‘tænke’-modeller (o3 og R1), blev token-grænser øget til 10.000 for at kunne rumme længere resonans-kæder:

Gennemsnitlige præstations-score for hver model over seks opgaver: kode, database, handlinger, data-til-tekst, matematik og sammenfattelse. Resultater vises for tre simuleringstyper: full, concat og sharded. Modellerne er sorteret efter deres gennemsnitlige full-indstillingsscore. Skyggen reflekterer graden af præstations-fald fra full-indstillingen, med de sidste to kolonner, der rapporterer gennemsnitlige fald for concat og sharded i forhold til full.

Med hensyn til disse resultater, skriver forfatterne^†:

‘På et højt niveau ser hver model sin præstation forringe på hver opgave, når FULL og SHARDED præstation sammenlignes, med en gennemsnitlig forringelse på -39%. Vi kalder dette fænomen Tabt i samtale: modeller, der opnår strålende (90%+) præstation i laboratorie-lignende indstillinger med fuldt specificerede, single-omgangs-samtaler, kæmper på de samme opgaver i en mere realistisk indstilling, når samtalen er under-specifieret og multi-omgangs.’

Concat-score gennemsnitligt 95 procent af full, hvilket indikerer, at præstations-faldet i den sharded indstilling ikke kan forklares af informations-tab. Mindre modeller som Llama3.1-8B-Instruct, OLMo-2-13B og Claude 3 Haiku viste mere udtalt forringelse under concat, hvilket tyder på, at mindre modeller generelt er mindre robuste over for omformulering end større modeller.

Forfatterne observerer^†:

‘Overraskende, mere performante modeller (Claude 3.7 Sonnet, Gemini 2.5, GPT-4.1) bliver lige så tabt i samtalen som mindre modeller (Llama3.1-8B-Instruct, Phi-4), med gennemsnitlige forringelser på 30-40%. Dette skyldes i del metrik-definitioner. Da mindre modeller opnår lavere absolutte score i FULL, har de mindre omfang for forringelse end de bedre modeller.

‘Kort sagt, uanset hvor stærk en LLM’s single-omgangs-præstation er, observerer vi store præstations-forringelser i multi-omgangs-indstillingen.’

Den initielle test indikerer, at nogle modeller holder bedre stand i bestemte opgaver: Command-A på handlinger, Claude 3.7 Sonnet og GPT-4.1 på kode; og Gemini 2.5 Pro på data-til-tekst, hvilket indikerer, at multi-omgangs-evne varierer efter domæne. Resonans-modeller som o3 og Deepseek-R1 klarede sig ikke bedre samlet, måske fordi deres længere svar introducerede flere antagelser, der havde tilbøjelighed til at forvirre samtalen.

Utilstedelighed

Forholdet mellem evne og utilstedelighed, klart i single-omgangs-simuleringer, syntes at falde fra hinanden under multi-omgangs-betingelser. Mens evnen kun faldt moderat, doblede utilstedeligheden i gennemsnit. Modeller, der var stabile i fuld-format-prompts, som GPT-4.1 og Gemini 2.5 Pro, blev lige så ustabile som svagere modeller som Llama3.1-8B-Instruct eller OLMo-2-13B, så snart instruktionen blev fragmenteret.

Oversigt over evne og utilstedelighed, som vist i en box-plot (a), efterfulgt af utilstedeligheds-resultater fra eksperimenter med 15 modeller (b), og resultater fra den gradvise sharding-test, hvor instruktioner blev splittet op i ét til otte shards (c).

Modellens svar var ofte forskellige med op til 50 point på samme opgave, selv når intet nyt var tilføjet, hvilket tydede på, at præstations-faldet ikke skyldtes mangel på færdighed, men på, at modellen blev mere ustabil over omgangene.

Rapporten skriver^†:

‘[Selvom] bedre modeller tenderer til at have lidt højere multi-omgangs-evne, tenderer alle modeller til at have lignende niveauer af utilstedelighed. Med andre ord, i multi-omgangs-, under-specifierede indstillinger, viser alle modeller, vi tester, meget høj utilstedelighed, med præstations-fald på 50 procent-point i gennemsnit mellem bedste og værste simulerede løb for en fast instruktion.’

For at teste, om præstations-forringelse var knyttet til antallet af omgange, kørte forfatterne en gradvis sharding-eksperiment, hvor hver instruktion blev splittet op i ét til otte shards (se højre kolonne i billedet ovenfor).

Da antallet af shards øgedes, steg utilstedeligheden jævnt, hvilket bekræftede, at selv mindre øgninger i omgangs-antal gjorde modellerne mere ustabile. Evnen forblev stort set uændret, hvilket understregede, at problemet ligger i konsekvens, ikke kapacitet.

Temperatur-kontrol

En separat række eksperimenter testede, om utilstedelighed blot var et produkt af tilfældighed. For at gøre dette, varierede forfatterne temperatur-indstillingen for både assistenten og bruger-simulatoren over tre værdier: 1,0, 0,5 og 0,0.

I single-omgangs-formater som full og concat, reducerede assistentens temperatur betydeligt utilstedeligheden, reducerede variationen med op til 80 procent; men i sharded-indstillingen havde samme intervention lille effekt:

Utilstedeligheds-score for forskellige kombinationer af assistent- og bruger-temperatur over full, concat og sharded indstillinger, med lavere værdier, der indikerer større svar-konsistens.

Selv når både assistenten og brugeren var sat til nul temperatur, forblev utilstedeligheden høj, med GPT-4o, der viste variation omkring 30 procent, hvilket tydede på, at ustabiliteten set i multi-omgangs-samtaler ikke blot er stokastisk støj, men en strukturel svaghed i, hvordan modeller håndterer fragmenteret input.

Konsekvenser

Forfatterne skriver om konsekvenserne af deres fund på usædvanlig længde i rapportens afslutning, argumenterer for, at stærk single-omgangs-præstation ikke garanterer multi-omgangs-pålidelighed, og advarer mod at over-rely på fuldt specificerede benchmarks, når man vurderer virkeligheds-beredskab (da disse benchmarks maskerer ustabilitet i mere naturlige, fragmenterede interaktioner).

De foreslår også, at utilstedelighed ikke blot er et sampling-artefakt, men en grundlæggende begrænsning i, hvordan nuværende modeller behandler udviklende input, og de foreslår, at dette rejser bekymringer for agent-rammer, der afhænger af vedvarende resonans over omgange.

Til sidst argumenterer de for, at multi-omgangs-evne skal behandles som en kerne-funktion i LLM’er, ikke noget, der offloads til eksterne systemer.

Forfatterne bemærker, at deres resultater sandsynligvis undervurderer den virkelige skala af problemet, og drager opmærksomhed til de ideelle betingelser for testen: bruger-simulatoren i deres setup havde fuld adgang til instruktionen og kunne afsløre shards i en optimal orden, hvilket gav assistenten en urealistisk gunstig kontekst (i virkelighedens brug, giver brugere ofte fragmenterede eller tvetydige prompts uden at vide, hvad modellen behøver at høre næste).

Derudover blev assistenten evalueret umiddelbart efter hver omgang, før den fulde samtale udviklede sig, og dette forhindrede, at senere forvirring eller selv-modsigelse blev straffet, hvilket ellers ville have forværret præstationen. Disse valg, selv om de var nødvendige for eksperimentel kontrol, betyder, at de observerede utilstedeligheds-gab er sandsynligvis større, end de rapporterede.

De konkluderer:

‘[Vi] mener, at de gennemførte simuleringer repræsenterer en venlig test-omgang for LLM’er multi-omgangs-kapaciteter. Da de simulerings-betingelser er overordentligt simplificerede, mener vi, at den observerede forringelse i eksperimenterne sandsynligvis er en undervurdering af LLM’er utilstedelighed, og hvor ofte LLM’er bliver tabt i samtale i virkelighedssammenhænge.‘

Konklusion

Enhver, der har tilbragt en betydelig mængde tid med en LLM, vil sandsynligvis genkende problemerne, der er formuleret her, fra praktisk erfaring; og de fleste af os, forestiller jeg mig, har intuitivt opgivet ‘tabte’ LLM-samtaler for nye, i håb om, at LLM’en måske ‘starter forfra’ og holder op med at beskæftige sig med stof, der kom op i en lang, snoet og stadig mere irriterende udveksling.

Det er interessant at bemærke, at at kaste mere kontekst på problemet måske ikke nødvendigvis løser det; og faktisk, at observere, at rapporten rejser flere spørgsmål, end den giver svar (bortset fra måder at springe omkring problemet på).

* Forvirrende, dette er ikke relateret til den konventionelle betydning af ‘sharding’ i AI.

† Forfatternes egne fedte betoninger.

Først publiceret mandag, 12. maj 2025