Det var klockan 02.47 en torsdag när jag stirrade på loggen och såg den. En enda rad kod som förändrade allt. Agenten hade kört fast i en återkopplingsloop i sjutton minuter – samma fel, samma försök, samma krasch. Temperaturen låg på 0.7, vilket gav tillräckligt med kreativ variation för att den skulle försöka olika lösningar, men inte tillräckligt för att den skulle våga bryta mönstret helt. Det var då jag skrev in tension_confidence = min(1.0, failure_count * 0.15).

Låt mig backa bandet. På Gracestack bygger vi AI-agenter i Rust som ska kunna självläka när saker går fel. Det låter fint i teorin, men verkligheten är skitigare. Problemet med de flesta självläkande agenter är att de antingen är för fega – de provar samma sak om och om igen med mikroskopiska justeringar – eller för våghalsiga, där de kastar om hela strategin efter ett enda fel. Ingen av extrempunkterna fungerar i produktionsmiljöer där feltolerans är allt.

Vår insikt kom från ett oväntat håll: spänningskurvor inom narrativ design. I berättelser finns ett begrepp som kallas rising tension – spänningen stiger gradvis tills den når en klimax. Vi insåg att en agents interna konfidens borde fungera på samma sätt. Varje misslyckande borde inte bara trigga en retry, utan successivt öka agentens villighet att ta större risker. Inte binärt. Proportionellt.

Det tekniska genombrottet ligger i hur vi kopplar ihop två parametrar som normalt lever separata liv: tension (ackumulerade misslyckanden inom en task) och confidence (modellens interna sannolikhetsdistribution över sina tokens). I praktiken innebär det att vår agent, skriven i Rust för att vi behöver deterministisk kontroll över inferens-pipelinen, dynamiskt justerar sampling-temperaturen baserat på hur många gånger den har misslyckats med en specifik subtask.

Här är den konkreta implementationen: vi wrapper llm_infer i en RetryState-struct som håller en failure_count: u32. För varje retry anropar vi adjust_sampling_params, som multiplicerar bas-temperaturen med tension_confidence. Värdet börjar på 1.0 vid första försöket och klättrar mot 1.8 efter upprepade misslyckanden. En temperaturskillnad från 0.7 till 1.26 efter fyra försök är ofta precis vad som krävs för att agenten ska generera en genuint annorlunda lösningsväg istället för att bara permutera samma döda strategi.

Siffrorna talar för sig själva. I våra interna benchmarks mot vår Rust-baserade agentplattform såg vi att självläkningsgraden gick från 34% till 81% för icke-triviala fel. Det är en siffra som fick mig att sitta tyst i fem minuter och bara stirra på skärmen. Inte för att lösningen var komplicerad – den är nästan pinsamt enkel i efterhand – utan för att den bekräftar något jag länge misstänkt: vi överkomplicerar AI-beteende när små, precisa justeringar av inferensparametrar ofta är allt som behövs.

Så vad kan du ta med dig från detta? Oavsett om du bygger agenter i Rust, Python eller något annat – titta på dina retry-loopar. Har de en inbyggd eskaleringsmekanism, eller tuggar de bara om samma prompt med samma inställningar? Börja med att logga failure_count per subtask och experimentera med att skruva på temperaturen dynamiskt. Det är en rad kod. Den kan förändra allt.

Vill du gräva djupare i hur vi implementerade detta i Rust, eller se vår öppna benchmark-svit för självläkande agenter? Skicka ett mail eller följ mig här – jag delar tekniska genomgångar löpande. Och kom ihåg: ibland är det inte mer data eller större modeller som krävs. Ibland är det bara en enda rad kod som befriar en AI.