Chat er ikke feil. Chat som default er feil.
I årevis har nesten hver eneste nye AI-funksjon fått det samme ansiktet: et tekstfelt nederst, en strøm av svar over. Enten jeg stiller et spørsmål, ber om å få en tekst skrevet om eller slipper en agent løs på en database - grensesnittet er alltid den samme kolonnen med snakkebobler. Det er billig å bygge og føles kjent. Problemet er bare at det sjelden passer til det vi faktisk gjør med outputen.
Så snart en agent ikke bare svarer, men produserer noe jeg jobber videre med - en plan, en migrering, en refusjon - begynner det egentlige problemet. Med et slikt resultat vil jeg gjøre helt ulike ting, og svært få av dem er «skrive enda en melding». For de fleste finnes det en flate som passer bedre enn enda et tekstfelt: en editor, en diff, et approval-panel, en tidslinje.
Dette innlegget går gjennom disse flatene én for én, med ett gjennomgående eksempel: et verktøy som lager en gjennomføringsplan ut fra et GitHub-issue. Det er interaksjonslaget over en serie som så langt har handlet om innmaten i agent-systemer - Contracts, verktøysikkerhet, Approval, Observability. Grensesnittet er stedet der denne innmaten enten blir synlig eller forblir usynlig.

Issue inn, 40 linjer plan ut - LGTM?
Du kopierer URL-en til et GitHub-issue, limer den inn i et felt og klikker «Analyser». Noen sekunder senere begynner teksten å strømme inn: først en oppsummering av hva issuet egentlig vil. Så de berørte delene av koden. Så en liste over risikoer, de konkrete gjennomføringsstegene og til slutt noen testideer. 40 linjer, ryddig strukturert, med overskrifter og punktlister. En plan, ikke småprat.
I de fleste verktøyene jeg kjenner, ville dette vært en chathistorikk. Den ene snakkeboblen etter den andre, ovenfra og ned, og du scroller med. Her er det noe annet: et dokument. Strukturert, lesbart i ett strekk, med tydelige seksjoner i stedet for en endeløs tråd av svar og oppfølgingsspørsmål. Forskjellen virker kosmetisk til å begynne med. Det er den ikke.
For nå kommer spørsmålet som bærer hele dette innlegget: Hva gjør du videre med denne planen?
Du leser den grundig, ikke bare skumleser, for snart blir den til kode. Du snubler over steg 3, som legger migreringen før backupen, og vil rette akkurat den ene linjen. Du vil holde planen opp mot det opprinnelige issuet for å se om den faktisk treffer kravet eller planlegger forbi det. Du vil eksplisitt godkjenne de to risikable stegene - skjemamigreringen og inngrepet i auth - før noe som helst skjer. Og så vil du ta planen i bruk og gjøre den om til faktisk arbeid.
Fem ting å gjøre med den ferdige planen. Lese, rette, sammenligne, godkjenne, ta i bruk. Og ikke én av dem heter «chatte videre».
Det er her chat-grensesnittet stille svikter. 40 linjer plan. LGTM. Approve. Done. Eller… i hvilket tekstfelt skriver jeg nå rettelsen til steg 3? Skriver jeg «endre steg 3, migreringen må kjøre etter backupen» og håper at modellen treffer riktig linje uten å skrive om de andre 39? Det er ikke redigering. Det er å beskrive redigering og krysse fingrene.
Så snart en agent produserer noe du jobber med, faller den ene samtalen fra hverandre i flere ulike oppgaver. Chat presser dem alle tilbake i det samme tekstfeltet. Det egentlige spørsmålet er hvorfor dette i det hele tatt er standardvalget for alt, når det så sjelden passer.
Seks oppgaver, ett tekstfelt
La oss se på hva som skjer rundt planen fra forrige kapittel. Input og generering kommer før - og så kommer tingene vi gjør med den ferdige planen: lese og vurdere, redigere, godkjenne, ta i bruk. Et halvt dusin aktiviteter, hver med sin egen takt. Input er et kort støt. Review er langsom lesing som hopper frem og tilbake. Redigering er punktvis. Godkjenning er ett bevisst, enkeltstående øyeblikk. Og en chattråd serialiserer alt dette i én eneste kolonne som vokser nedover.
Det er her friksjonen ligger. En tråd er en dårlig workflow-tracker, fordi samtalens takt og arbeidsflytens takt går etter forskjellige klokker. Samtalen vil at jeg skal svare på den siste meldingen. Arbeidsflyten vil at jeg skal hoppe tilbake til steg tre, endre to linjer der og la resten stå. I tråden betyr det: scrolle, lete, rekonstruere konteksten i hodet og skrive en ny melding som beskriver det jeg egentlig ville ta direkte tak i. Planen er et objekt med tilstander - tråden behandler den som en rekke talehandlinger.
I UX-debatten om agent-grensesnitt i 2026 blir ett poeng trukket hardt frem, blant annet av Adi Leviim i UX Collective: Chat er det grensesnittet som var raskest å levere. Det betyr ikke at det er det som fungerer best. Et tekstfelt pluss en svarstrøm er billig å bygge og kan brukes til ethvert use case. Prisen for det er flyttet, ikke borte. Seks ulike typer oppgaver, ett inputfelt - og det er brukeren som må bære jobben med å skille mellom modusene. Jeg må formulere i prosa om jeg vil spørre, rette eller godkjenne - selv om UI-et kunne tatt seg av det skillet. Det vet jo hvilket steg vi står på.
Det er den samme bevegelsen som med autonomi - en skyveknapp de fleste systemer ikke skrur helt opp. For UI gjelder det tilsvarende: Grensesnittet er et valg per oppgave. Hvilken flate som passer til hvilken oppgave, kan skrives ned ganske rett frem:
| Oppgavetype | Passende flate |
|---|---|
| se på planen, få oversikt | Dokument |
| endre én linje | Inline-redigering |
| sjekke mot kravet | Diff- / compare-view |
| godkjenne et risikabelt steg | Approval-panel |
| forstå hva som har kjørt | Tidslinje |
| utforske fritt, ennå uten form | Chat |
Chat står på siste rad, og det er ikke en avskjed: For åpen utforskning, når oppgaven ennå ikke har noen form, er et tekstfelt det riktige valget. Problemet er ikke chat. Problemet er chat som default for alt - også for de fem radene over, der en mer spesifikk flate ville gjort jobben.
La oss begynne øverst i tabellen. Når et verktøy lager en gjennomføringsplan ut fra et issue, er det første jeg gjør med planen å lese den og se strukturen. Til det er den passende flaten ikke en samtalehistorikk, men et dokument - en plan er et editor-problem.
Editoren: en plan er et dokument
Tilbake til planen vår: Én linje stemmer ikke helt - migreringen skal først kjøre etter backupen.
I en chat skriver du nå tilbake: «Nei, bytt om steg 3 og 4, backupen må komme først.» Agenten leser friteksten din, tolker den og genererer planen på nytt. I beste fall er rekkefølgen nå riktig. I verste fall har steg 6, som var riktig fra før, stille flyttet seg også - fordi en regenerering kaster terningen på hele tilstanden på nytt og ikke gir noen garanti for at alt utenom den ene endringen din forblir det samme.
Det er kjernen i problemet med re-prompting som korrigeringsmekanisme: Du har en strukturert tilstand - et typet plan-objekt med summary, steps[], risks[] - og jager den gjennom en fritekst-tolkning for å gjøre én punktvis endring. Agenten må først rekonstruere fra setningen din hva du mener, og produserer så et helt nytt objekt. Kontrakten mellom UI og agent finnes fortsatt, men den blir oppfylt helt på nytt ved hver rettelse i stedet for å bli justert målrettet.
En plan er et artefakt. Artefakter redigerer man direkte: Klikk på linjen for steg 3, endre teksten i dokumentet, ferdig. UI-et erstatter bare denne ene oppføringen i plan-objektet og lar resten være i fred. Kontrakten forblir intakt, fordi du jobber på objektnivå, ikke på nivået til en ny generering.
// Rettelse som fritekst tilbake til agenten.
// Den regenererer HELE plan-objektet ut fra setningen din -
// summary, steps[] og risks[] blir tolket på nytt.
// Det som var riktig fra før, kan flytte seg i samme slengen.
async function correctViaChat(message: string) {
const newPlan = await agent.send({
role: "user",
content: message, // "Nei, bytt om steg 3 og 4"
});
setPlan(newPlan); // full erstatning, ingen diff
}// Direkte manipulering av et typet plan-objekt.
// Bare steget du rører, blir erstattet; kontrakten
// (summary, steps[], risks[]) forblir strukturelt intakt.
function onSave(stepId: string, next: string) {
setPlan((plan) => ({
...plan,
steps: plan.steps.map((step) =>
step.id === stepId ? { ...step, text: next } : step,
),
}));
}Forskjellen høres abstrakt ut helt til du prøver den selv. Klikk på en linje i planen og endre den direkte:
Hvis du har autonomi-knappen fra i stad i bakhodet, er dette det samme skillet på UI-nivå: Intent mot Execution. Du redigerer resultatet, ikke prompten. Intensjonen har du formulert for lengst - nå retter du utførelsen uten å starte hele maskineriet på nytt.
En ærlig begrensning: Denne flate tilstanden - steg som en liste, ett felt per oppføring - er et bevisst valg, ikke en nødløsning. Så lenge stegene står uavhengig ved siden av hverandre, holder det med et array. Først når stegene har reelle avhengigheter i rekkefølge (steg 5 får bare kjøre hvis 2 og 3 lyktes), trenger du en task-graf i stedet for en liste. Det er en annen datastruktur og en annen redigeringsmodell - og for de fleste planer trenger du det rett og slett ikke.
Redigering løser det ene problemet: Jeg kan forme planen uten å skyte tilstanden i filler. Det løser ikke det andre. Hvordan vet jeg at planen i det hele tatt treffer det som stod i issuet? En flytende formulert liste med steg ser alltid plausibel ut. Om den faktisk oppfyller kravet, ser jeg først når jeg legger dem ved siden av hverandre.
Compare-viewet: det agenten sier vs. det som skjer
Husker du refund-agenten fra denne serien? I chatten står den vennlige setningen: «Refusjonen er satt i gang, beløpet er tilbake på kontoen i løpet av noen dager.» Tool-callet gikk gjennom, ingen feil, ingen rød ramme. Det er bare det at ingen penger flytter seg. I hovedboken står det ingenting - ingen oppføring, ingen transaksjon, ingen spor. Agenten har produsert en påstand, ikke et resultat. Det er nettopp det som er False Success: et svar som ser ut som suksess, mens tilstanden i backend er urørt.

Et chat-avsnitt inviterer til skumlesing. Det er flytende formulert, høflig, plausibelt - og øynene våre glir over oppsummeringen fordi den leses som et resultat. En diff gjør det motsatte. Den stiller to tilstander side om side og tvinger oss til å se etter: det ene til venstre, det andre til høyre, forskjellen i midten. Der chatten forteller, sammenligner compare-viewet.
En grønn chathistorikk med ødelagt backend-tilstand er farligere enn en rød stacktrace. Stacktracen skriker til deg. Den grønne historikken hvisker at alt er i orden.
Diffen finnes i to varianter i agent-systemer, og de avslører hver sine hull.
Den første: Opprinnelig issue ↔ generert plan. Her ligger kravet ved siden av det agenten har laget ut av det. Dekker planen virkelig alle tre punktene fra issuet, eller bare to, fordi det tredje stille ble svelget på veien? I løpende tekst legger man knapt merke til et krav som mangler - planen høres komplett ut så lenge vi ikke legger issuet ved siden av. Sammenligningen gjør utelatelsen synlig før det blir skrevet en eneste linje kode.
Den andre: Påstand ↔ systemtilstand. Det agenten påstår at den har gjort, mot det systemet faktisk viser. «Refusjon satt i gang» til venstre - den manglende oppføringen i hovedboken til høyre. Denne varianten er den viktigste, fordi den tar tak der chatten lyver mest overbevisende: i suksessmeldingen etter en muterende handling. Agenten får gjerne påstå. Vi sjekker påstanden mot tilstanden.
Begge variantene ved siden av hverandre - bytt mellom dem:
- Innlogging med e-post + passord
- MFA via TOTP
- Rate limiting for mislykkede forsøk
- Steg: e-post/passord-flyt
- Steg: TOTP-oppsett + verify
- — ikke i planen —
Denne ideen er ikke et enkeltstående funn. I flere UX-veiledninger for agent-systemer fra 2026 dukker det opp mønstre som i bunn og grunn mener det samme: «Action Receipt», som kvitterer hver handling med et bevis, eller Tool-Call-Review med before/after-diff og en vei tilbake via rollback. Ulike navn, én bevegelse mot sammenligning som kan etterprøves. Hver agent-handling produserer ikke bare et utsagn om hva som angivelig har skjedd, men et artefakt der vi kan sjekke hva som faktisk skjedde.
Compare-viewet løser et synlighetsproblem. Det gjør forskjellen mellom ambisjon og virkning håndgripelig i stedet for å gjemme den i løpende tekst. Men synlighet er ikke kontroll. En diff viser meg at planen migrerer en database eller utløser en betaling - den stopper ikke steget. For de harmløse handlingene holder det å se etter i etterkant. For de risikable trenger jeg en instans før: et punkt der jeg avgjør om dette steget i det hele tatt får kjøre.
Approval-panelet: godkjenning som primær interaksjon
Compare-viewet sluttet med et åpent spørsmål: Hvem godkjenner det risikable steget? I chatten er svaret som regel en popup som braser inn midt i historikken - et modalt avbrudd som river deg ut av lesingen og lar deg stå alene med en ja/nei-beslutning. Du klikker, dialogen forsvinner, og det du nettopp bekreftet, scroller ut av syne. Godkjenning fortjener sin egen flate, ikke et overlay over samtalen.
Et approval-panel gjør tilstanden synlig og lett å skanne: venter → bekreftes → godkjent. Det viser hvilket tool-call som ville kjørt med hvilke argumenter, før det kjører - ikke som en beskrivelse i fritekst, men som et konkret, parset forslag. Du ser mutasjonen, ikke fortellingen om den. Og du ser den på et fast sted som ikke drukner i historikken så lenge noe fortsatt venter på beslutningen din.
For at ikke hvert eneste steg skal havne foran deg, trenger du en forhåndssortering etter risiko: read-only, lavrisiko-mutasjon, høyrisiko-mutasjon, irreversibel. Modellen kan selv markere hva som trenger godkjenning - et requiresApproval-flagg, satt for DB-migreringer, endringer i auth og tilganger, faktureringslogikk, destruktive breaking changes eller slike som virker utad. Mer pålitelig er det å håndheve denne klassifiseringen som policy på verktøynivå - en allowlist etter verktøytype. Å stole på modellens egen vurdering alene er risikabelt: Ved prompt injection eller hallusinasjon kaller den nettopp den kinkige handlingen harmløs. Slik kjører en read stille i bakgrunnen, mens en DROP-setning stopper opp for bekreftelse. Bare det som virkelig rettferdiggjør friksjonen, havner foran mennesket.

Og her lurer det egentlige problemet. En godkjenningsknapp frister deg til å bare vinke ting gjennom. Den som klikker «Approve» ti ganger på rad, sjekker ikke lenger den ellevte gangen - det er rubber-stamping, og det er målbart farlig. I Human-in-the-Loop-debatten har automation complacency vært beskrevet i årevis: Så snart de foreslåtte svarene var feil og ble tatt over i blinde, sank treffsikkerheten til deltakerne målbart - det feilaktige forslaget dro dem med seg ned i stedet for å bli rettet av dem. Tilsyn som bare nikker, er ikke tilsyn.
Mottiltaket heter cognitive forcing: et bevisst mellomsteg som bryter refleksen. Tilstanden «bekreftes» er et slikt steg - en kort pause med plikt til å begrunne, der du ikke bare klikker, men skriver ned i én setning hvorfor denne mutasjonen får kjøre. Friksjonen er selve featuren her. Den tvinger blikket tilbake på argumentene i tool-callet før det blir virkelighet.
Prøv å godkjenne steget - uten begrunnelse går det ikke:
run_migration({
table: "users",
statement: "ALTER TABLE users DROP COLUMN legacy_token",
reversible: false
})I UX-debatten begynner det å tegne seg konkrete mønstre for dette. En «Intent Preview» viser deg hva agenten har tenkt å gjøre, og gir deg mer enn et binært ja - for eksempel: fortsett, endre planen eller ta over selv. «Autonomy Dial» fra UX-veiledninger fra 2026 - beskrevet blant annet i Smashing Magazine - gjør graden av selvstendighet til en innstilling i seg selv i stedet for å kable den fast. Tommelfingerregelen bak: nudge, don’t nag. Spør der det betyr noe, ikke ved hvert steg - ellers sløves oppmerksomheten, og du er tilbake til å vinke ting gjennom.
Når godkjenningen er gitt, begynner arbeidet. Flere tool-calls kjører, tilstander endres, noe blir skrevet, slettet, sendt. Panelet har vist deg hva som skulle skje. Men hvordan vet jeg hva som faktisk skjedde - i hvilken rekkefølge, med hvilket resultat, hvor det hang seg opp? Chathistorikken gjengir det i beste fall som en gjenfortelling.
Tidslinjen: trace i stedet for chathistorikk
Etter godkjenningen kjører noe - og her viser forskjellen seg mellom to typer registrering. En chathistorikk forteller hva som ble sagt. En audit-logg eller en trace viser hva som faktisk skjedde. Det er ikke det samme, og sprekken mellom de to er nøyaktig der False Success bor: Agenten sier «refusjonen er sendt», scrollbacken leses som en løst sak - og i tracen står det at det avgjørende tool-callet aldri gikk gjennom.
En tidslinje er mer enn en penere chathistorikk: Den er trace-waterfallen - den hierarkiske rekkefølgen av det systemet har gjort, med varighet, nesting og resultat per steg.
Hva en slik flate viser, kjenner vi allerede fra Observability-innlegget: tool-execution-spans med argumenter og resultat, approval-events som pauser i forløpet, tidsstempler, varighet. I kjernen er det LLM-calls for modell-interaksjonene, tool-executions for hvert tool-call og agent-orkestreringen som root-span som holder alt sammen. I en god tidslinje kan jeg filtrere (bare tool-calls, bare feil), zoome og hoppe rett til et steg - i stedet for å scrolle gjennom hundrevis av chatbobler.
Det er poenget agent-UX-debatten kommer tilbake til igjen og igjen: I en lang, delvis autonom sesjon oppstår det fort hundrevis av hendelser. Spørsmålet «Hva skjedde mellom minutt 30 og 45?» er i praksis umulig å besvare i en lineær chat - du scroller, leter, mister tråden. I en filtrerbar tidslinje markerer du bare et tidsrom.
La oss være ærlige om hvor dette hører hjemme. Ved en engangsgenerering av en plan - single-shot, ett modell-call, ett resultat - gir en tidslinje fortsatt lite. Det er knapt noe å neste, «tracen» er én linje. Verdien øker i det øyeblikket planen blir tatt i bruk: flere tool-calls etter hverandre, flere sub-issues som skrives, en godkjenning midt i, kanskje et retry etter en feil. Da er tidslinjen forskjellen mellom «jeg tror det kjørte» og «jeg ser hva som kjørte - og hvor det hang seg opp».
Det er også grunnen til at denne flaten og Observability ikke er to temaer, men ett. Tidslinjen er frontenden til den samme tracen du uansett trenger i backend for å debugge incidents. Den som instrumenterer ordentlig, får grensesnittet for sporbarhet nesten gratis.

Med det har vi sett fire flater som i mange tilfeller fungerer bedre enn et chatvindu: editor, diff, approval-panel, tidslinje. Da gjenstår chatten selv.
Når chat likevel er riktig
Har chat gått ut på dato? Nei - men den passer bare til en bestemt type oppgave. Skillet som betyr noe her, er ikke «chat vs. UI», men divergent vs. konvergent.
Divergent arbeid åpner søkerommet. Måltilstanden er ennå ikke fastlagt, den vokser frem underveis. Du famler deg frem, forkaster, prøver en annen retning. Det er dette en samtale er bygget for: Hver tur får være vag, hvert neste steg retter det forrige. Konvergent arbeid er det motsatte. Det finnes en sluttilstand som kan etterprøves - en godkjenning, en sammenligning, et resultat som er tatt i bruk - og spørsmålet er bare om denne tilstanden stemmer. Her blir chat svak, fordi den tvinger kontrollen inn i et tekstspor du selv må rekonstruere.
Et eksempel som viser begge deler: Du finpusser en UI-mockup. «Legg til et søkefelt over tabellen.» «Gjør tabellen mer kompakt.» «Fjern den andre kolonnen igjen.» Hver setning snevrer inn søkerommet litt, og målet - den gode layouten - finnes ikke engang som spesifikasjon i starten. Det krystalliserer seg i dialogen. Det er det stikk motsatte av en plan du godkjenner på forhånd. Ingen ville ønske å presse denne prosessen inn i et godkjenningsskjema, fordi det ikke finnes noe ferdig å godkjenne. Samtalen er verktøyet her.
Teknisk sett trenger «chat» for lengst ikke å være ren tekst. Moderne rammeverk tillater Generative UI: Agenten rendrer ekte komponenter under kjøring i stedet for bare å skrive. Et verktøy leverer da et skjema, en tabell eller en rekke metric-cards i stedet for bare tekst - i Vercel AI SDK for eksempel via tool-invocations som frontenden oversetter til komponenter. En ærlig merknad: Veien via React Server Components er for øyeblikket satt på pause i AI SDK; det som anbefales, er varianten på klientsiden med useChat pluss tool-invocations. Resultatet er likevel et chat-grensesnitt - men et med strukturerte, interaktive byggeklosser inni.
Og det er ikke et brudd med tesen i dette innlegget, men en bekreftelse av den. Vi velger flaten etter oppgaven. Når oppgaven er divergent utforskning, vinner chat - og så snart et konvergent øyeblikk dukker opp midt i utforskningen, skyver du rett og slett en strukturert byggekloss inn i strømmen. Selv «chat» er da ofte chat-pluss-struktur, ikke den rå formen alt dette begynte med.
Når chat vinner - og når den taper
Chat vinner:
- åpen brainstorming der retningen fortsatt er åpen
- finpussing av mockups og utkast steg for steg
- spørsmål til en kunnskapsbase
- tidlig utforskning der det ennå ikke finnes noen definert måltilstand
Chat taper:
- godkjenning av en risikabel handling
- sammenligning av to tilstander side om side
- å følge et langt forløp i flere trinn
- presis redigering av et strukturert artefakt
Dermed har vi den ærlige versjonen av tesen: Chat er én flate blant flere, og den har et tydelig bruksområde. Hvis vi konsekvent velger flaten etter oppgaven - hva betyr det for hvordan vi bygger agent-systemer?
Kontrollflaten er vollgraven
Blake Crosley kokte det i 2026-debatten ned til en formel som setter seg: Det er ikke modellen og ikke størrelsen på kontekstvinduet som avgjør om agenter kan brukes i produksjon, men grensesnittet som gjør arbeidet deres synlig, etterprøvbart og mulig å godkjenne. Konkurransefortrinnet sitter én etasje over reasoningen, i flaten som gjør den mulig å betjene. Kontrollflaten er den egentlige vollgraven - det du ser av agentens arbeid og kan stoppe hvis du er i tvil.
Det samler hele innlegget. En agent kan oppfylle kontrakten sin til punkt og prikke, bestå hver eneste eval og skrive en trace uten hull - og brukeren merker ingenting av det så lenge ikke noe UI viser det. Governance som bare finnes i backend, forblir usynlig for mennesket i den andre enden. Editoren viser kontrakten før den blir utført. Diffen viser virkningen før og etter. Approval-panelet gjør godkjenningen til en bevisst beslutning. Tidslinjen tar vare på forløpet, tilgjengelig i stedet for rekonstruert etter hukommelsen. En chat kan fortelle om alt dette. De strukturerte flatene gjør det etterprøvbart.
Dermed er sirkelen sluttet for serien. Hver flate i dette innlegget har røtter i et tidligere engineering-problem:
- Autonomi-knapp i stedet for fri loop - den som definerer beslutningspunkter, trenger et grensesnitt som gir kontrollen tilbake på disse punktene.
- Intent vs. Execution - diffen finnes fordi et vellykket tool-call ennå ikke er en riktig virkning; False Success blir først synlig i før-og-etter.
- Approval som kvalitetssikring - approval-panelet er UI-formen av Human-in-the-Loop, godkjenningen som et bevisst steg og ikke som en refleks.
- Trace i stedet for spekulasjon - tidslinjen er Observability for brukeren, forløpet som bevis i stedet for antagelse.




Én flate mangler fortsatt i denne oppramsingen, og den sitter i starten i stedet for på slutten: selve det strukturerte inputet - skjemaet med assistanse, der agenten fyller ut feltene i stedet for å spørre etter dem. Den kommer i neste del.
Det beste grensesnittet for en agent gjør arbeidet dens etterprøvbart - en chat gjør det bare til en fortelling.
