Procedurminne: lärda färdigheter

Episodiskt minne sparar vad som hände. Semantiskt minne sparar vad som är sant. Procedurminne sparar hur man gör något — en färdighet.

För en agent betyder det: när en uppgift lösts framgångsrikt, spara tillvägagångssättet som en återanvändbar procedur. Nästa gång en liknande uppgift dyker upp hämtas proceduren och följs, i stället för att agenten famlar fram samma lösning igen.

Vinsten är dubbel: färre steg (billigare, snabbare) och högre tillförlitlighet (ett beprövat recept slår improvisation).

Voyager (Wang m.fl. 2023) visade principen konkret i Minecraft: agenten skrev återanvändbara färdigheter som kod, sparade dem i ett bibliotek, och byggde successivt mer avancerade färdigheter ovanpå enklare.

from dataclasses import dataclass, field

@dataclass
class Procedur:
    namn: str
    nar: str                      # beskrivning av när den gäller — det som matchas semantiskt
    steg: list[dict]              # verktygsanrop i ordning, med parametrar som mallar
    lyckade: int = 0
    misslyckade: int = 0
    @property
    def tillforlitlighet(self):
        n = self.lyckade + self.misslyckade
        return (self.lyckade + 1) / (n + 2)      # Laplace-utjämning: nya procedurer får ~0,5

class Procedurbibliotek:
    def __init__(self, embed, min_tillforlitlighet=0.6):
        self.embed, self.procedurer, self.min_t = embed, [], min_tillforlitlighet

    def spara(self, uppgift, spar, llm):
        """Kallas bara efter en VERIFIERAT lyckad körning."""
        p = llm.generalisera(uppgift, spar)      # abstrahera konkreta värden till parametrar
        if any(likhet(p.namn, q.namn) > 0.9 for q in self.procedurer):
            return None                           # finns redan
        self.procedurer.append(Procedur(**p, lyckade=1))
        return p["namn"]

    def hamta(self, uppgift, k=2):
        kandidater = [p for p in self.procedurer if p.tillforlitlighet >= self.min_t]
        return sorted(kandidater, key=lambda p: -cos(self.embed(uppgift), self.embed(p.nar)))[:k]

    def aterkoppla(self, namn, lyckades):
        for p in self.procedurer:
            if p.namn == namn:
                p.lyckade += lyckades; p.misslyckade += (not lyckades)

Tre regler som gör skillnaden mellan nytta och skada:

1. Spara bara verifierat lyckade lösningar — annars byggs ett bibliotek av fel.
2. Följ upp tillförlitligheten. En procedur som slutar fungera (API ändrades) ska sjunka och falla bort automatiskt.
3. Proceduren är ett förslag, inte ett tvång. Agenten ska kunna avvika när situationen skiljer sig — annars blir den stel.