AI-assistenter och agenter är inte deterministiska – men de kan användas för att bygga deterministiska system

En språkmodell kan ge olika svar på samma fråga. Formuleringen kan förändras. Resonemanget kan ta en annan väg. Ett verktyg kan anropas med andra parametrar. Ibland blir resultatet bättre än väntat. Ibland missar modellen något som verkade självklart.

Det är inte ett tillfälligt fel som nödvändigtvis kommer att försvinna med nästa modellversion. Variationen är en del av hur tekniken fungerar. Därför hör man ibland slutsatsen:

AI går inte att använda i system där resultatet måste vara förutsägbart.

Det är en rimlig invändning, men en alltför långtgående slutsats. AI-assistenten behöver inte själv vara deterministisk för att systemet runt den ska kunna leverera ett kontrollerat och verifierbart resultat.

Två olika sorters system

Traditionell programvara bygger vanligtvis på explicita regler. Om ett visst villkor är uppfyllt ska en viss operation utföras. Samma indata, samma kod och samma tillstånd ska i princip ge samma resultat.

En språkmodell fungerar annorlunda. Den beräknar vilket svar som är sannolikt utifrån instruktionen, sammanhanget och modellen. Även när variationen begränsas kan man inte utgå från att varje körning producerar exakt samma resultat.

Det är en viktig skillnad. Men de två typerna av system behöver inte konkurrera. De kan användas för olika delar av samma arbetsflöde.

AI är bra på att:

• tolka ostrukturerad information
• identifiera möjliga mönster
• formulera hypoteser
• föreslå klassificeringar
• generera kod eller konfiguration
• förklara komplicerat material
• ta fram möjliga handlingsalternativ

Traditionell programvara är bra på att:

• kontrollera datatyper och format
• tillämpa fasta regler
• genomföra beräkningar
• hantera behörigheter
• validera gränsvärden
• upprätthålla tillstånd
• logga och spåra beslut
• stoppa otillåtna operationer

Det intressanta uppstår när vi låter systemen göra det de är bäst på.

AI kan föreslå – systemet avgör

Anta att en AI-agent läser ett dokument och försöker avgöra vilken informationsklassning det bör ha.

Det vore riskabelt att låta modellens fritext direkt styra lagring, åtkomst eller publicering. Modellen kan missförstå dokumentet, använda en kategori som inte finns eller lämna ett tvetydigt svar. I stället kan modellen få lämna ett strukturerat förslag:

{
  "föreslagen_klass": "konfidentiell",
  "identifierade_risker": [
    "personuppgifter",
    "ekonomisk information"
  ],
  "motivering": "Dokumentet innehåller..."
}

Det omgivande systemet kan därefter kontrollera att:

• klassen finns i organisationens fastställda modell
• obligatoriska uppgifter är ifyllda
• identifierade personuppgifter behandlas enligt reglerna
• AI:n inte försöker utföra en otillåten åtgärd
• en människa godkänner klassningen när risken kräver det

AI:n tolkar och föreslår. Den deterministiska delen validerar, beslutar och verkställer.

Skilj resonemanget från beslutet

Ett vanligt arkitekturfel är att låta språkmodellen både analysera situationen och fatta det slutliga beslutet. Det kan fungera i en demonstration. Det blir betydligt svårare att kontrollera i ett verksamhetssystem.

En säkrare uppdelning är:

Ostrukturerad information
          ↓
    AI-baserad tolkning
          ↓
  Strukturerat förslag
          ↓
Deterministisk validering
          ↓
Regler eller mänskligt beslut
          ↓
      Verkställande

Modellen används där variation är värdefull: tolkning, sammanhang och förslag. Programkod och fastställda regler används där variation är farlig: behörigheter, ekonomiska transaktioner, myndighetsbeslut och förändringar i andra system.

AI kan också skapa deterministiska artefakter

AI behöver inte alltid delta när systemet körs. En assistent kan användas under utvecklingen för att skapa programkod, tester, valideringsregler, databasscheman, konfigurationsfiler, beslutsregler, infrastrukturdefinitioner och dokumentation. Resultatet kan därefter granskas, testas, versionshanteras och köras som vanlig programvara.

AI:s arbete sker då innan systemet tas i drift. Det färdiga systemet behöver inte anropa en språkmodell över huvud taget.

Det liknar hur en mänsklig utvecklare arbetar. Utvecklarens tankeprocess är inte deterministisk. Två utvecklare kan skapa olika lösningar på samma problem. Men programmet som granskas, kompileras och driftsätts kan ändå ha ett förutsägbart beteende.

AI-genererad kod bör bedömas enligt samma grundprincip:

Vi ska inte lita på koden därför att vi litar på den som skrev den. Vi ska lita på den därför att vi kan verifiera hur den fungerar.

Tester är bryggan mellan sannolikhet och förutsägbarhet

Om en AI-assistent genererar en funktion kan resultatet variera mellan körningar. Men funktionen behöver inte accepteras direkt. Den kan kontrolleras genom enhetstester, integrationstester, typkontroll, statisk kodanalys, säkerhetsskanning, kodgranskning, reproducerbara byggprocesser och testdata med kända förväntade resultat.

När koden klarar de fastställda kontrollerna blir det mindre viktigt exakt hur den skapades.

Det betyder inte att tester bevisar att systemet är felfritt. Det gör de aldrig. Men de omvandlar ett sannolikt förslag till ett artefakt som kan bedömas mot explicita krav. AI producerar ett möjligt svar. Testerna avgör om svaret får bli en del av systemet.

Strukturerade svar räcker inte

Det har blivit vanligt att kräva att en språkmodell svarar i JSON eller följer ett definierat schema. Det är en viktig förbättring, men den gör inte modellens slutsats deterministisk.

Ett svar kan vara syntaktiskt korrekt men ändå innehålla fel klassificering, påhittade uppgifter, bristfällig motivering, otillåtna kombinationer eller värden som är korrekta i formatet men fel i verksamheten.

Strukturerad utdata gör modellens svar lättare att kontrollera. Den ersätter inte kontrollen. Ett schema kan säkerställa att fältet belopp innehåller ett tal. Det kan inte på egen hand säkerställa att beloppet är riktigt, rimligt eller godkänt.

Agenter behöver tydliga befogenheter

Problemet blir särskilt viktigt när en AI inte bara ger råd utan också får använda verktyg. En agent kan exempelvis läsa dokument, söka i databaser, skapa ärenden, skicka meddelanden, ändra konfiguration, beställa resurser och starta andra processer.

Då räcker det inte med en bra instruktion. Agentens faktiska befogenheter måste begränsas tekniskt. Ett robust system bör definiera:

• vilka verktyg agenten får använda
• vilka data den får läsa
• vilka objekt den får förändra
• tillåtna parametrar
• belopps- och mängdgränser
• vilka åtgärder som kräver godkännande
• hur varje operation loggas
• hur en pågående process kan stoppas
• hur felaktiga förändringar återställs

Agenten kan få föreslå att ett konto ska stängas. Den bör inte nödvändigtvis ha behörighet att göra det. Agenten kan få skapa ett utkast till ett meddelande. Ett deterministiskt system kan kontrollera mottagare, dataklassning och obligatoriskt godkännande innan något skickas.

Instruktioner styr beteendet mjukt. Behörigheter och validering styr det hårt.

När en människa måste finnas i loopen

Mänskligt godkännande används ibland som en generell säkerhetslösning. Men en människa i loopen hjälper bara om personen förstår vad som ska bedömas, får tillräcklig information, har tid att göra en verklig kontroll, har mandat att stoppa processen — och inte utsätts för så många förslag att godkännandet blir rutin.

Om en användare förväntas godkänna hundratals AI-genererade beslut om dagen blir den mänskliga kontrollen snart symbolisk.

Därför bör mänsklig granskning reserveras för sådant som verkligen kräver omdöme. Maskinellt verifierbara krav ska kontrolleras av kod.

Allt behöver inte bli deterministiskt

Det är heller inte alltid nödvändigt att eliminera variation. Om en AI hjälper till att formulera ett textutkast, sammanfatta ett möte, föreslå frågor, hitta möjliga problem eller skapa alternativa lösningar kan variation vara en tillgång.

Kravet bör inte vara att varje system alltid ger identiska svar. Kravet bör vara att graden av variation motsvarar konsekvensen av ett fel. Ju större påverkan en åtgärd kan få, desto mindre bör systemet förlita sig på modellens fria bedömning.

Det deterministiska skalet

Ett användbart sätt att tänka är att placera den icke-deterministiska modellen inuti ett deterministiskt skal. Skalet kan bestå av:

• identitets- och behörighetskontroll
• validerade in- och utdata
• tillåtna verktyg
• fasta verksamhetsregler
• testade kodkomponenter
• transaktionsgränser
• loggning och spårbarhet
• mänskliga kontrollpunkter
• säkra standardvärden
• mekanismer för att avbryta och återställa

Modellen får arbeta inom skalet, men den får inte själv bestämma skalets gränser.

Det är i praktiken samma princip som används för människor i välstyrda verksamheter. Vi förutsätter inte att varje individ alltid agerar exakt likadant. Vi bygger roller, behörigheter, attestregler, kontroller och uppföljning runt arbetet.

Frågan är inte om AI:n går att lita på

När organisationer diskuterar AI-agenter hamnar samtalet ofta i en alltför enkel fråga:

Kan vi lita på modellen?

Ett bättre antal frågor är:

• Vad får modellen föreslå?
• Vad får den besluta?
• Vad får den verkställa?
• Vilka resultat kan verifieras automatiskt?
• Vilka åtgärder kräver mänskligt godkännande?
• Vad händer när modellen har fel?
• Kan felet upptäckas innan det får konsekvenser?
• Kan åtgärden återställas?
• Vem äger det slutliga ansvaret?

En modell som ibland har fel kan ändå vara mycket användbar i ett system som förväntar sig att den ibland har fel. En modell som verkar mycket träffsäker kan däremot bli farlig i ett system som saknar kontroller för de få tillfällen då den misslyckas.

Arkitekturen kommer före agenten

Vi kommer sannolikt att använda allt fler assistenter och agenter. De kommer att bli bättre på att resonera, använda verktyg och utföra längre arbetsflöden.

Men bättre modeller avskaffar inte behovet av systemarkitektur. Tvärtom. Ju mer kapabla agenterna blir, desto viktigare blir det att skilja mellan sannolika bedömningar och tillåtna handlingar.

AI-assistenten behöver inte vara deterministisk. Men systemet måste vara deterministiskt där verksamheten kräver det.

Det uppnår vi inte genom att skriva längre instruktioner till modellen. Vi uppnår det genom att bygga tydliga gränser, verifierbara artefakter, testade regler och kontrollerade befogenheter runt den.

AI kan stå för tolkningen, variationen och förslagen. Systemet måste fortfarande stå för reglerna, besluten och ansvaret.