Chatt är inte fel. Chatt som default är fel.
I flera år har nästan varje ny AI-funktion fått samma ansikte: ett textfält längst ner och en ström av svar ovanför. Oavsett om jag ställer en fråga, vill ha en text omskriven eller släpper in en agent i en databas – gränssnittet är alltid samma kolumn av pratbubblor. Det är billigt att bygga och känns bekant. Det passar bara sällan ihop med det vi faktiskt gör med resultatet.
Så fort en agent inte bara svarar utan producerar något som jag sedan jobbar vidare med – en plan, en migration, en återbetalning – börjar det egentliga problemet. Med ett sådant resultat vill jag göra helt olika saker, och väldigt få av dem går ut på att ”skriva ännu ett meddelande”. För de flesta finns det en yta som passar bättre än ännu ett textfält: en editor, en diff, en approval-panel, en tidslinje.
Det här inlägget går igenom ytorna en i taget, med ett och samma exempel hela vägen: ett verktyg som gör en implementationsplan av ett GitHub-issue. Det är interaktionslagret ovanpå en serie som hittills handlat om insidan av agentsystem – contracts, verktygssäkerhet, approval, observability. Gränssnittet är platsen där den insidan blir synlig. Eller förblir osynlig.

Issue in, 40 rader plan ut – LGTM?
Du kopierar URL:en till ett GitHub-issue, klistrar in den i ett fält och klickar på ”Analysera”. Några sekunder senare börjar text rinna in: först en sammanfattning av vad issuet egentligen vill. Sedan de berörda delarna av koden. Sedan en lista med risker, de konkreta implementationsstegen och till sist några testidéer. 40 rader, snyggt strukturerade, med rubriker och punktlistor. En plan, inget småprat.
I de flesta verktyg jag känner till hade det här varit en chatthistorik. En pratbubbla efter den andra, uppifrån och ner, och du scrollar med. Här är det något annat: ett dokument. Strukturerat, läsbart i ett svep, med tydliga avsnitt i stället för en ändlös tråd av svar och motfrågor. Skillnaden ser först kosmetisk ut. Det är den inte.
För nu kommer frågan som bär hela det här inlägget: Vad gör du härnäst med planen?
Du läser den noggrant, inte översiktligt, eftersom den snart ska bli kod. Du snubblar på steg 3, som lägger migrationen före backupen, och vill rätta just den raden. Du vill hålla planen mot det ursprungliga issuet för att se om den verkligen träffar kravet eller planerar förbi det. Du vill uttryckligen godkänna de två riskabla stegen – schemamigrationen och ingreppet i auth – innan något händer. Och sedan vill du tillämpa planen, göra om den till riktigt arbete.
Fem saker att göra med den färdiga planen. Läsa, rätta, jämföra, godkänna, tillämpa. Och inte en enda av dem heter ”chatta vidare”.
Det är här chattgränssnittet i tysthet går bet. 40 rader plan. LGTM. Approve. Klart. Eller… i vilket textfält skriver jag nu rättelsen till steg 3? Skriver jag ”ändra steg 3, migrationen måste köras efter backupen” och hoppas att modellen träffar rätt rad utan att skriva om de andra 39? Det är inte redigering. Det är att beskriva redigering och be en stilla bön.
Så fort en agent producerar något som du arbetar med faller den enda konversationen sönder i flera olika aktiviteter. Chatten pressar tillbaka allihop i samma textfält. Varför det ändå är standardvalet för allt, trots att det så sällan passar, är den egentliga frågan.
Sex uppgifter, ett textfält
Låt oss titta på vad som händer runt planen från förra avsnittet. Inmatning och generering kommer före – och sedan sakerna man gör med den färdiga planen: läsa och granska, redigera, godkänna, tillämpa. Ett halvdussin aktiviteter, var och en med sin egen takt. Inmatning sker i ett kort ryck. Review är långsam läsning som hoppar fram och tillbaka. Redigering är punktvis. Att godkänna är ett medvetet, enskilt ögonblick. Och en chattråd serialiserar allt detta till en enda kolumn som växer nedåt.
Det är här det skaver. En tråd är en dålig workflow-tracker, eftersom konversationens takt och arbetsflödets takt går på olika klockor. Konversationen vill att jag svarar på det senaste meddelandet. Arbetsflödet vill att jag hoppar tillbaka till steg tre, ändrar två rader där och låter resten stå. I tråden betyder det: scrolla, leta, rekonstruera kontexten i huvudet och skriva ett nytt meddelande som beskriver det jag egentligen ville ta i direkt. Planen är ett objekt med tillstånd – tråden behandlar den som en följd av talakter.
I UX-diskussionen kring agentgränssnitt 2026 har en poäng drivits hårt, bland annat av Adi Leviim i UX Collective: chatt är det gränssnitt som gick snabbast att leverera. Det betyder inte att det fungerar bäst. Ett textfält plus en svarsström är billigt att bygga och går att använda för varje use case. Priset för det har flyttats, inte försvunnit. Sex olika typer av uppgifter, ett inmatningsfält – och bördan att skilja mellan lägena hamnar hos användaren. Jag måste formulera i prosa om jag just nu vill fråga, rätta eller godkänna, trots att UI:t skulle kunna ta hand om den skillnaden. Det vet ju vilket steg vi är på.
Det är samma rörelse som med autonomi – ett reglage som de flesta system inte vrider upp på max. För UI:t gäller samma sak: gränssnittet är ett val per uppgift. Vilken yta som passar vilken uppgift går att skriva ner ganska rakt:
| Typ av uppgift | Lämplig yta |
|---|---|
| titta på planen, få överblick | Dokument |
| ändra en rad | Inline-edit |
| kontrollera mot kravet | Diff-/compare-vy |
| godkänna ett riskabelt steg | Approval-panel |
| förstå vad som har körts | Tidslinje |
| utforska fritt, utan form ännu | Chatt |
Chatten står på sista raden, och det är inget farväl: för öppet utforskande, när uppgiften ännu inte har någon form, är ett textfält rätt val. Problemet är inte chatt. Problemet är chatt som default för allt – också för de fem raderna ovanför, där en mer specifik yta skulle ta hand om jobbet.
Vi börjar högst upp i tabellen. När ett verktyg gör en implementationsplan av ett issue är det första jag gör med planen att läsa den och se strukturen. Den lämpliga ytan för det är inte en konversationshistorik utan ett dokument – en plan är ett editorproblem.
Editorn: en plan är ett dokument
Tillbaka till vår plan: en rad stämmer inte riktigt – migrationen ska köras först efter backupen.
I en chatt skriver du nu tillbaka: ”Nej, byt plats på steg 3 och 4, backupen måste komma först.” Agenten läser din fritext, tolkar den och genererar om planen åt dig. I bästa fall är ordningen nu rätt. I sämre fall har steg 6, som var rätt innan, tyst flyttat sig också – eftersom en omgenerering slår tärningarna på nytt för hela state:t och inte ger någon garanti för att allt utom din enda ändring förblir detsamma.
Det är kärnan i problemet med re-prompting som rättningsmekanism: du har ett strukturerat state – ett typat planobjekt med summary, steps[], risks[] – och skickar det genom en fritextstolkning för att göra en punktvis ändring. Agenten måste först rekonstruera vad du menar utifrån din mening och producerar sedan ett helt nytt objekt. Contractet mellan UI och agent finns kvar, men det uppfylls på nytt från grunden vid varje rättelse i stället för att ändras där det behövs.
En plan är en artefakt. Artefakter redigerar man direkt: klicka på raden för steg 3, ändra texten i dokumentet, klart. UI:t byter bara ut just den posten i planobjektet och lämnar resten orört. Contractet förblir intakt, eftersom du arbetar på objektets nivå, inte på nivån av en ny generering.
// Rättelsen går tillbaka till agenten som fritext.
// Den genererar om HELA planobjektet utifrån din mening -
// summary, steps[] och risks[] tolkas på nytt.
// Det som var rätt innan kan flytta sig på köpet.
async function correctViaChat(message: string) {
const newPlan = await agent.send({
role: "user",
content: message, // "Nej, byt plats på steg 3 och 4"
});
setPlan(newPlan); // fullständig ersättning, ingen diff
}// Direkt manipulation av ett typat planobjekt.
// Bara det steg du rör ersätts, contractet
// (summary, steps[], risks[]) förblir strukturellt intakt.
function onSave(stepId: string, next: string) {
setPlan((plan) => ({
...plan,
steps: plan.steps.map((step) =>
step.id === stepId ? { ...step, text: next } : step,
),
}));
}Skillnaden låter abstrakt tills man provar den. Klicka på en rad i planen och ändra den direkt:
Om du har kvar autonomireglaget från nyss i huvudet är det här samma uppdelning på UI-nivå: intent mot execution. Du redigerar resultatet, inte prompten. Avsikten har du formulerat för länge sedan – nu rättar du utförandet utan att starta om hela maskineriet.
En ärlig reservation: det här platta state:t – steg som en lista, ett fält per post – är ett medvetet beslut, ingen nödlösning. Så länge stegen står oberoende bredvid varandra räcker en array. Först när stegen har verkliga beroenden i ordningen (steg 5 får bara köras om 2 och 3 lyckades) behöver du en task-graf i stället för en lista. Det är en annan datastruktur och en annan redigeringsmodell – och för de flesta planer behöver du det helt enkelt inte.
Redigering löser det ena problemet: jag kan forma planen utan att paja state:t. Det andra löser den inte. Hur vet jag att planen överhuvudtaget träffar det som stod i issuet? En flytande formulerad steglista ser alltid rimlig ut. Om den faktiskt uppfyller kravet ser jag först när jag lägger dem bredvid varandra.
Compare-vyn: vad agenten säger vs. vad som händer
Tänk tillbaka på refund-agenten från den här serien. I chatten står den vänliga meningen: ”Återbetalningen är genomförd, beloppet är tillbaka på kontot inom några dagar.” Tool-callet gick igenom, inget fel, ingen röd ram. Men inga pengar rör sig. I ledgern står ingenting – ingen post, ingen transaktion, inga spår. Agenten har producerat ett påstående, inte ett resultat. Det är precis det som är false success: ett svar som ser ut som framgång medan backend-state:t är orört.

Ett stycke chattext bjuder in till skumläsning. Det är flytande formulerat, artigt, rimligt – och blicken glider över sammanfattningen, eftersom den läses som ett resultat. En diff gör tvärtom. Den ställer två tillstånd bredvid varandra och tvingar oss att titta: till vänster det ena, till höger det andra, och skillnaden emellan. Där chatten berättar, jämför compare-vyn.
En grön chatthistorik med trasigt backend-state är farligare än en röd stacktrace. Stacktracen skriker åt dig. Den gröna historiken viskar att allt är i sin ordning.
Diffen finns i två varianter i agentsystem, och de avslöjar olika luckor.
Den första: ursprungligt issue ↔ genererad plan. Här ligger kravet bredvid det som agenten gjort av det. Täcker planen verkligen alla tre punkter i issuet, eller bara två, eftersom den tredje tyst försvann på vägen? I löptext märks ett saknat krav knappt – planen låter komplett så länge vi inte lägger issuet bredvid. Jämförelsen gör utelämnandet synligt innan någon kod har skrivits.
Den andra: påstående ↔ systemtillstånd. Det agenten påstår att den har gjort, mot det systemet faktiskt visar. ”Refund genomförd” till vänster – den saknade ledger-posten till höger. Den här varianten är den viktigare, eftersom den sätter in där chatten ljuger mest övertygande: vid framgångsbeskedet efter en muterande åtgärd. Agenten får gärna påstå saker. Vi kontrollerar påståendet mot state:t.
Båda varianterna, bredvid varandra – växla mellan dem:
- Login med e-post + lösenord
- MFA via TOTP
- Rate limiting för misslyckade försök
- Steg: e-post/lösenord-flöde
- Steg: TOTP-setup + verify
- — inte i planen —
Idén är inget enstaka fynd. I flera UX-guider för agentsystem från 2026 dyker det upp mönster som i grunden menar samma sak: ”Action Receipt”, som ger ett kvitto på varje åtgärd, eller tool-call-review med before/after-diff och en väg för rollback. Olika namn, samma rörelse mot en jämförelse som går att kontrollera. Varje agentåtgärd producerar inte bara ett påstående om vad som ska ha hänt, utan en artefakt där vi kan se efter vad som faktiskt hände.
Compare-vyn löser ett synlighetsproblem. Den gör skillnaden mellan anspråk och effekt gripbar, i stället för att gömma den i löptext. Men synlighet är inte kontroll. En diff visar mig att planen migrerar en databas eller utlöser en betalning – den stoppar inte steget. För de harmlösa åtgärderna räcker det att titta i efterhand. För de riskabla behöver jag en kontrollpunkt före: en punkt där jag avgör om steget överhuvudtaget får köras.
Approval-panelen: godkännande som primär interaktion
Compare-vyn slutade med en öppen fråga: vem godkänner det riskabla steget? I chatten är svaret oftast en popup som ploppar upp mitt i historiken – ett modalt avbrott som rycker dig ur läsningen och lämnar dig ensam med ett ja/nej-beslut. Du klickar, dialogen försvinner, och det du just bekräftade scrollar iväg uppåt. Godkännande förtjänar en egen yta, inte ett overlay över samtalet.
En approval-panel gör tillståndet synligt och lätt att skanna: väntar → bekräftas → godkänt. Den visar vilket tool-call med vilka argument som skulle köras, innan det körs – inte som en beskrivning i löptext utan som ett konkret, parsat förslag. Du ser mutationen, inte berättelsen om den. Och du ser den på en fast plats som inte drunknar i historiken så länge något fortfarande väntar på ditt beslut.
För att inte varje steg ska hamna framför dig behöver du en försortering efter risk: read-only, mutation med låg risk, mutation med hög risk, oåterkallelig. Modellen kan själv markera vad som kräver godkännande – en requiresApproval-flagga, satt vid databasmigrationer, ändringar i auth och behörigheter, billing-logik, destruktiva eller utåtverkande breaking changes. Mer pålitligt är att tvinga fram den klassningen som policy på verktygsnivå – en allowlist per verktygstyp. Att lita enbart på modellens egen bedömning är riskabelt: vid prompt injection eller hallucination kallar den just den känsliga åtgärden harmlös. På så sätt sker en läsning tyst i bakgrunden, medan ett DROP-statement stannar upp för bekräftelse. Framför människan hamnar bara det som verkligen motiverar friktionen.

Och här lurar det egentliga problemet. En godkänn-knapp lockar till att vinka igenom. Den som klickar ”Approve” tio gånger i rad granskar inte längre den elfte gången – det är rubber-stamping, och det är mätbart farligt. I human-in-the-loop-diskussionen har automation complacency beskrivits i åratal: när de föreslagna svaren var fel och accepterades blint sjönk deltagarnas träffsäkerhet mätbart – det felaktiga förslaget drog ner dem i stället för att de rättade det. En tillsyn som bara nickar är ingen tillsyn.
Motåtgärden heter cognitive forcing: ett medvetet mellansteg som bryter reflexen. Tillståndet ”bekräftas” är ett sådant steg – en kort paus med krav på motivering, där du inte bara klickar utan skriver ner i en mening varför den här mutationen får köras. Här är friktionen själva featuren. Den tvingar blicken tillbaka till tool-callets argument innan det blir verklighet.
Försök godkänna steget – utan motivering går det inte:
run_migration({
table: "users",
statement: "ALTER TABLE users DROP COLUMN legacy_token",
reversible: false
})I UX-diskussionen börjar konkreta mönster ta form för det här. En ”Intent Preview” visar vad agenten tänker göra och ger dig mer än ett binärt ja – till exempel: fortsätt, ändra planen eller ta över själv. ”Autonomy Dial”, som dyker upp i UX-guider från 2026 – bland annat i Smashing Magazine – gör själva graden av självständighet till något man kan ställa in, i stället för att hårdkoda den. Tumregeln bakom: nudge, don’t nag. Fråga där det spelar roll, inte vid varje steg – annars trubbas uppmärksamheten av och du är tillbaka på att vinka igenom.
När godkännandet är givet börjar arbetet. Flera tool-calls körs, tillstånd ändras, något skrivs, raderas, skickas. Panelen visade dig vad som skulle hända. Men hur vet jag vad som faktiskt hände – i vilken ordning, med vilket resultat, var det hakade upp sig? Chatthistoriken ger i bästa fall en återberättelse.
Tidslinjen: trace i stället för chatthistorik
Efter godkännandet körs något – och här syns skillnaden mellan två sorters dokumentation. En chatthistorik berättar vad som sades. En audit-logg eller en trace visar vad som faktiskt hände. Det är inte samma sak, och glappet mellan dem är exakt där false success bor: agenten säger ”återbetalningen är skickad”, scrollbacken läses som ett löst ärende – och i tracen står det att det avgörande tool-callet aldrig gick igenom.
En tidslinje är mer än chatthistoriken i snyggare kläder: den är trace-vattenfallet – den hierarkiska följden av vad systemet har gjort, med varaktighet, nästling och resultat per steg.
Vad en sådan yta visar känner vi redan från observability-inlägget: tool-execution-spans med argument och resultat, approval-events som en paus i flödet, tidsstämplar, varaktighet. I grunden handlar det om LLM-calls för modellinteraktionerna, tool executions för varje tool-call och agent-orkestreringen som root-span som håller ihop allt. I en bra tidslinje kan jag filtrera (bara tool-calls, bara fel), zooma och hoppa direkt till ett steg – i stället för att scrolla genom hundratals chattbubblor.
Det är poängen som diskussionen kring agent-UX gör om och om igen: i en lång, delvis autonom session uppstår snabbt hundratals händelser. Frågan ”Vad hände mellan minut 30 och 45?” är i praktiken omöjlig att besvara i en linjär chatt – du scrollar, letar, tappar tråden. I en filtrerbar tidslinje är det bara att markera ett intervall.
Låt oss vara ärliga i bedömningen. Vid en engångsgenerering av en plan – single-shot, ett modellanrop, ett resultat – tillför en tidslinje inte mycket. Där finns knappt något att nästla, ”tracen” är en enda rad. Värdet ökar i samma ögonblick som planen tillämpas: flera tool-calls i rad, flera skrivna sub-issues, ett godkännande mitt i, kanske en retry efter ett fel. Då är tidslinjen skillnaden mellan ”Jag tror att det gick” och ”Jag ser vad som gick – och var det hakade upp sig”.
Det är också därför den här ytan och observability inte är två ämnen utan ett. Tidslinjen är frontenden för samma trace som du ändå behöver i backenden för att debugga incidenter. Den som instrumenterar ordentligt får gränssnittet för spårbarhet nästan på köpet.

Därmed har vi sett fyra ytor som i många fall fungerar bättre än ett chattfönster: editor, diff, approval-panel, tidslinje. Kvar är chatten själv.
När chatt ändå är rätt
Har chatten spelat ut sin roll? Nej – men bara för en viss sorts uppgift. Distinktionen som spelar roll här är inte ”chatt vs. UI” utan divergent vs. konvergent.
Divergent arbete öppnar sökrymden. Måltillståndet ligger inte fast än, det växer fram under resans gång. Du trevar dig fram, kastar, provar en annan riktning. Det är det en konversation är byggd för: varje tur får vara vag, varje nästa steg rättar det föregående. Konvergent arbete är motsatsen. Det finns ett sluttillstånd som går att kontrollera – ett godkännande, en jämförelse, ett tillämpat resultat – och frågan är bara om det tillståndet stämmer. Här blir chatten svag, eftersom den tvingar in kontrollen i ett textspår som du själv måste rekonstruera.
Ett exempel som visar båda: du förfinar en UI-mockup. ”Lägg till ett sökfält ovanför tabellen.” ”Gör tabellen kompaktare.” ”Ta bort den andra kolumnen igen.” Varje mening smalnar av sökrymden en bit, och målet – den bra layouten – finns i början inte ens som specifikation. Den kristalliseras fram i dialogen. Det är raka motsatsen till en plan som du godkänner i förväg. Ingen skulle vilja pressa in den här processen i ett approval-formulär, eftersom det inte finns något färdigt att godkänna. Här är konversationen verktyget.
Tekniskt sett behöver ”chatt” sedan länge inte vara ren text. Moderna ramverk möjliggör generative UI: agenten renderar riktiga komponenter i runtime i stället för att bara skriva. Ett verktyg levererar då ett formulär, en tabell eller en rad metric cards i stället för bara text – i Vercel AI SDK till exempel via tool-invocations som frontenden översätter till komponenter. En ärlig kommentar: vägen via React Server Components är för närvarande pausad i AI SDK; det som rekommenderas är varianten på klientsidan med useChat plus tool-invocations. Resultatet är ändå ett chattgränssnitt – men ett med strukturerade, interaktiva byggstenar i.
Och det är inget brott mot tesen i det här inlägget utan en bekräftelse av den. Vi väljer ytan efter uppgiften. När uppgiften är divergent utforskande vinner chatten – och så fort ett konvergent ögonblick dyker upp inne i utforskandet skjuter du helt enkelt in en strukturerad byggsten i strömmen. Även ”chatt” är då ofta chatt plus struktur, inte den råa formen som allt började med.
När chatten vinner – och när den förlorar
Chatten vinner:
- öppen brainstorming där riktningen fortfarande är öppen
- förfining av mockups och utkast steg för steg
- frågor till en kunskapsbas
- tidigt utforskande där det ännu inte finns något definierat måltillstånd
Chatten förlorar:
- godkännandet av en riskabel åtgärd
- jämförelsen av två tillstånd bredvid varandra
- att följa ett långt flöde i flera steg
- precis redigering av en strukturerad artefakt
Därmed har vi den ärliga versionen av tesen: chatt är en yta bland flera, och den har ett tydligt användningsområde. Om vi konsekvent väljer den efter uppgiften – vad betyder det för hur vi bygger agentsystem?
Kontrollytan är vallgraven
Blake Crosley sammanfattade det 2026 i en formel som fastnar: vilka agenter som går att använda i produktion avgörs inte av modellen och inte av kontextfönstrets storlek, utan av gränssnittet som gör deras arbete synligt, granskningsbart och möjligt att godkänna. Konkurrensfördelen sitter en våning ovanför reasoningen, i ytan som gör den användbar. Control surface är den egentliga vallgraven (moat) – det du ser av agentens arbete och kan stoppa om det behövs.
Det knyter ihop hela inlägget. En agent kan uppfylla ett rent contract, klara varje eval och skriva en komplett trace – och användaren märker inget av det så länge inget UI visar det. Governance som bara finns i backenden förblir osynlig för människan i andra änden. Editorn visar contractet innan det utförs. Diffen visar effekten före och efter. Approval-panelen gör godkännandet till ett medvetet beslut. Tidslinjen håller fast förloppet, tillgängligt i stället för rekonstruerat ur minnet. En chatt kan berätta om allt detta. De strukturerade ytorna gör det granskningsbart.
Därmed sluts cirkeln över serien. Varje yta i det här inlägget har sin rot i ett tidigare engineering-problem:
- Autonomireglage i stället för fri loop – den som definierar beslutspunkter behöver ett gränssnitt som lämnar tillbaka kontrollen vid de punkterna.
- Intent vs. execution – diffen finns för att ett lyckat tool-call ännu inte är rätt effekt; false success blir synlig först i före-efter-jämförelsen.
- Approval som kvalitetssäkring – approval-panelen är UI-formen av human-in-the-loop, godkännandet som ett medvetet steg och inte som en reflex.
- Trace i stället för spekulation – tidslinjen är observability för användaren, förloppet som belägg i stället för som gissning.




En yta saknas fortfarande i uppräkningen, och den sitter i början i stället för i slutet: själva den strukturerade inmatningen – formuläret med assistans, där agenten fyller i fälten i stället för att fråga efter dem. Det är nästa del.
Det bästa gränssnittet för en agent gör dess arbete granskningsbart – en chatt gör det bara till en berättelse.
