Wie ein KI-Agent funktioniert: ein Sprachmodell in einer Schleife mit Werkzeugen

Allgemein ist ein Agent eine Funktion, die jeder bisherigen Wahrnehmungsgeschichte eine Aktion zuordnet (Agentenfunktion aus der KI-Landkarte). Ein KI-Agent im engeren Sinn dieses Teils ist die folgende konkrete Konstruktion. Sei

1. T die Menge aller Texte (endlicher Folgen von Tokens) und ⊕ : T × T → T das Anhängen von Text ans Ende;
2. M : T → T ein Sprachmodell, das aus dem Kontext den nächsten Schritt schreibt (ein Modell mit Sampling ist in Wirklichkeit zufällig; hier nehmen wir einen festen Verlauf);
3. F ⊆ T die Menge der Schritte, die eine endgültige Antwort sind; die übrigen Schritte v ∈ T ∖ F sind Werkzeugaufrufe;
4. N : T ∖ F → T das Rahmenprogramm: Es führt einen Werkzeugaufruf tatsächlich aus und gibt sein Ergebnis als Text zurück;
5. c₁ ∈ T der Anfangskontext (Systemprompt, Werkzeugbeschreibungen und Aufgabe) und K_max ∈ ℕ, K_max ≥ 1, das Schrittbudget.

Ein Lauf des Agenten ist die Folge von Kontexten c₁, c₂, … und Schritten v₁, v₂, …, gegeben für k = 1, 2, …, K_max durch die Vorschrift

v_k = M(c_k),   c_k+1 = c_k ⊕ v_k ⊕ N(v_k)   (falls v_k ∉ F).

Der Lauf hält an im ersten Schritt k, für den v_k ∈ F — die Ausgabe ist die Antwort v_k —, oder nach Schritt K_max, falls kein Schritt eine endgültige Antwort war — die Ausgabe ist „Schrittbudget aufgebraucht“.

Der Agent wechselt also zwischen einem Modellschritt und der Ausführung eines Werkzeugs ab, bis das Modell antwortet oder das Budget aufgebraucht ist. Das Abwechseln von Überlegung und Aktion haben Shunyu Yao u. a. (2022) unter dem Namen ReAct (reason + act) beschrieben; die Notation oben ist eine vereinfachte Formalisierung für diesen Teil.

Der Agent habe m ≥ 1 Werkzeuge. Ein Werkzeug i ∈ {1, …, m} ist gegeben durch

1. einen Namen j_i (die Namen verschiedener Werkzeuge sind verschieden),
2. eine Beschreibung in Worten, wozu es dient,
3. ein Parameterschema S_i — eine Beschreibung, welche Parameter welcher Typen das Werkzeug annimmt (typischerweise als JSON-Schema),
4. eine Prozedur, die das Rahmenprogramm für gültige Parameter startet und die das Ergebnis als Text zurückgibt.

Name, Beschreibung und Schema aller Werkzeuge werden in den Prompt eingefügt. Ein Werkzeugaufruf ist eine strukturierte Ausgabe des Modells der Form (j, x) — Name und Parameter, etwa {"nastroj": "hledej", "text": "KL divergence"}. Das Modell ist so feinabgestimmt, dass es statt gewöhnlichen Texts eine solche Ausgabe schreiben kann. Das Rahmenprogramm verarbeitet den Aufruf (j, x) so:

1. gibt es ein i mit j = j_i und entsprechen die Parameter x dem Schema S_i, startet es die Prozedur des Werkzeugs i mit den Parametern x und hängt ihr Ergebnis als weitere Nachricht an den Kontext an;
2. andernfalls hängt es eine Fehlermeldung an den Kontext an und startet das Werkzeug nicht.

Das Modell selbst startet also nichts — es schreibt nur, was gestartet werden soll; starten (oder den Start verweigern) tut das Rahmenprogramm.

Für zwei Ja/Nein-Verteilungen (Regen mit Wahrscheinlichkeit p, das Modell sagt q; p, q ∈ (0, 1)) ist D_KL(p ‖ q) = p log₂ p/q + (1 − p) log₂ 1 − p/1 − q Bit (Informationstheorie).

D_KL(0,7 ‖ 0,5) = 0,7 · log₂ 0,7/0,5 + 0,3 · log₂ 0,3/0,5 = 0,7 · log₂ 1,4 + 0,3 · log₂ 0,6 = 0,340 − 0,221 = 0,119.

D_KL(0,5 ‖ 0,7) = 0,5 · log₂ 5/7 + 0,5 · log₂ 5/3 = −0,243 + 0,368 = 0,126.

Gemittelt wird jedes Mal über eine andere Verteilung (je nachdem, was die Wirklichkeit ist), deshalb ergibt das Vertauschen der Argumente eine andere Zahl — und ein Abstand (eine Metrik) muss symmetrisch sein. Das ist die Antwort, die der Agent sucht.

Das Modell hat zwischen den Aufrufen kein Gedächtnis; bei jedem Aufruf liest es den ganzen Kontext erneut — Systemprompt, Aufgabe und alle bisherigen Schritte und Werkzeugergebnisse. Der Lauf des Agenten (Definition oben) habe nach K ≥ 1 Modellaufrufen geendet, und für k = 1, …, K sei c_k ∈ ℕ die Länge des Kontexts (Anzahl der Tokens) vor dem k-ten Aufruf. Die Kosten der Schleife sind die Anzahl der Tokens, die das Modell während des Laufs als Eingabe verarbeitet:

Z = ∑_k=1^K c_k.

Weil der Kontext mit jedem Schritt wächst, wächst Z ungefähr mit dem Quadrat der Schrittzahl (Satz unten).

Sei K ∈ ℕ, K ≥ 1, die Anzahl der Modellaufrufe, c₁ ≥ 0 die Länge des Anfangskontexts und d ≥ 0 die Anzahl der Tokens, die jeder Schritt hinzufügt (Aufruf und Werkzeugergebnis zusammen), sodass c_k = c₁ + (k − 1) d für k = 1, …, K. Dann gilt

Z = K c₁ + d · K(K − 1)/2.

Beweis: Z = ∑_k=1^K (c₁ + (k − 1) d) = K c₁ + d ∑_k=1^K (k − 1) und ∑_k=1^K (k − 1) = 0 + 1 + … + (K − 1) = K(K − 1)/2. ∎ Für großes K überwiegt der zweite Term ≈ d K²/2: Eine doppelt so lange Sitzung kostet ungefähr viermal so viel. (Die Farben entsprechen den Termen der Zerlegung oben: d ist der konstante Wert von v_j + o_j.)

Suchen und einen Ausschnitt lesen. Der Systemprompt hat 157 Tokens, die Frage 18, also c₁ = 175. Nach den drei Schritten hat der Kontext 209, 414, 560 Tokens. Die vier Modellaufrufe lesen Z = 175 + 209 + 414 + 560 = 1 358 Tokens (Farben wie in der Formel oben).

Alles lesen. K = 11 Aufrufe, der Kontext wächst von 175 auf 24 927 Tokens, im Schnitt um d = 24 927 − 175/10 ≈ 2 475 pro Schritt. Nach dem Satz ist Z ≈ 11 · 175 + 2 475 · 11 · 10/2 = 138 050; tatsächlich sind es 141 820 (die Artikel sind unterschiedlich lang, deshalb fügen die Schritte nicht genau gleich viel hinzu). Systemprompt und Frage machen davon nur 1 925 Tokens aus — fast alles ist wiederholtes Lesen der Artikel.

Diese Begriffe sind nicht mathematisch; es sind Rollen von Teilen eines Agentenlaufs (Definition des KI-Agenten oben, Kontexte c₁, c₂, …, Werkzeuge N). Eine Sitzung ist ein Lauf des Agenten von c₁ bis zum Anhalten.

1. Ein Plan ist Text im Kontext — eine nummerierte Liste von Schritten, die der Agent als einen seiner Schritte v_k zu Beginn der Sitzung schreibt und in weiteren Schritten immer wieder umschreibt (Erledigtes abhaken, Übriges ändern). Das Modell liest ihn wie jeden anderen Teil des Kontexts; nichts erzwingt ihn.
2. Das Arbeitsgedächtnis ist der Kontext c_k einer Sitzung. Es vergeht mit der Sitzung und ist durch die Kontextlänge begrenzt, die das Modell bewältigt.
3. Das Langzeitgedächtnis sind Daten, die außerhalb des Modells und außerhalb des Kontexts gespeichert sind (Dateien, Datenbanken) und das Ende der Sitzung überdauern. Der Agent schreibt in sie und liest aus ihnen nur über Werkzeugaufrufe; in einer weiteren Sitzung gelangen sie nur in den Kontext, wenn der Agent sie liest oder das Rahmenprogramm sie in c₁ einfügt.
4. Ein Teilagent ist ein anderer Agentenlauf, den der Hauptagent als Werkzeug startet: Der Teilagent beginnt mit einem eigenen Anfangskontext (nur der Beschreibung der Teilaufgabe), arbeitet in seiner eigenen Schleife, und in den Kontext des Hauptagenten kehrt als Werkzeugergebnis N(v_k) nur seine endgültige Antwort zurück. Die Einzelheiten seiner Arbeit füllen den Hauptkontext so nicht.

Seien p ∈ [0, 1], d ∈ [0, 1], r ∈ ℕ ∪ {0} und n ∈ ℕ, n ≥ 1. Ein Schritt mit Kontrolle (geschlossene Schleife) läuft so ab:

1. der Agent führt den Schritt aus; der Versuch gelingt mit Wahrscheinlichkeit p;
2. der Agent prüft das Ergebnis (führt die Tests aus, liest die Ausgabe eines Befehls, vergleicht mit der Erwartung); einen gelungenen Versuch nimmt die Kontrolle immer an, einen misslungenen erkennt sie mit Wahrscheinlichkeit d als fehlerhaft;
3. der Versuch ist gelungen ⇒ der Schritt endet mit Erfolg;
4. der Versuch ist misslungen, die Kontrolle hat es erkannt und der Agent hat bisher weniger als r-mal wiederholt ⇒ der Agent wiederholt den Schritt ab Punkt 1;
5. andernfalls (der Fehler ist durch die Kontrolle gerutscht oder die Wiederholungen sind aufgebraucht) endet der Schritt mit Misserfolg.

Die Ergebnisse der einzelnen Versuche und Kontrollen sind voneinander unabhängig. Die Erfolgsquote eines Schritts q ist die Wahrscheinlichkeit, dass der Schritt mit Erfolg endet; eine Aufgabe besteht aus n solchen unabhängigen Schritten hintereinander und gelingt genau dann, wenn alle gelingen. Dann gilt

q = p ∑_k=0^r ((1 − p) d)^k,   P(die Aufgabe gelingt) = qⁿ.

Der Summand k ist die Wahrscheinlichkeit, dass die ersten k Versuche scheitern und das Scheitern erkannt wird (jeweils mit Wahrscheinlichkeit (1 − p) d) und Versuch k + 1 gelingt; diese Möglichkeiten schließen sich gegenseitig aus, deshalb werden sie addiert. Ohne Kontrolle (d = 0 oder r = 0) ist q = p.

Erfolgsquote eines Schritts (Farben wie in der Formel oben): q = 0,9 + 0,9 · 0,1 · 0,9 + 0,9 · (0,1 · 0,9)² = 0,9 + 0,081 + 0,00729 = 0,98829.

Die ganze Aufgabe: ohne Kontrolle 0,9²⁰ = 0,122, mit Kontrolle 0,98829²⁰ = 0,790. Der Schritt hat sich nur von 90 % auf 98,8 % verbessert, die Aufgabe aber von 12 % auf 79 % — die Potenz n bläst kleine Unterschiede im Schritt auf.

Sei q ∈ (0, 1) die Erfolgsquote eines Schritts, und eine Aufgabe aus n unabhängigen Schritten gelinge mit Wahrscheinlichkeit qⁿ (Definition oben). Die Länge der in der Hälfte der Fälle bewältigten Aufgabe ist die reelle Zahl n_50 % > 0, für die q^n_50 % = 1/2, also

n_50 % = ln 0,5/ln q = ln 2/−ln q ≈ 0,69/1 − q   für q nahe 1

(die näherungsweise Gleichheit folgt aus −ln q ≈ 1 − q für q → 1). Weil qⁿ mit wachsendem n fällt, gilt qⁿ ≥ 1/2 genau dann, wenn n ≤ n_50 %; die größte ganze Schrittzahl, die der Agent in mindestens der Hälfte der Fälle schafft, ist also ⌊n_50 %⌋.

In unserem Modell: p = 0,9 ohne Kontrolle 6,6 Schritte, mit Kontrolle 58,8; p = 0,99 ohne Kontrolle 69,0, mit Kontrolle 686. Die Aufgabe, die ein Agent zur Hälfte schafft, wird ungefähr in dem Maß länger, in dem die Fehlerquote eines Schritts 1 − q sinkt.

Dieselbe Größe (die Länge einer Aufgabe, die ein Agent in 50 % der Fälle schafft) misst METR — nur nicht in Schritten, sondern in der Zeit, die die Aufgabe einen Menschen kosten würde (Thomas Kwa u. a., Measuring AI Ability to Complete Long Tasks, 2025). Unsere Formel ist ein vereinfachtes Modell mit unabhängigen Schritten, nicht ihre Methode.