# Wie ein Agent Werkzeuge und Gedächtnis nutzt
> Die Schleife, eine Ebene tiefer: wie das Modell ein Werkzeug anfordert, warum sein ganzes Gedächtnis nur das wachsende Protokoll ist und warum lange mehrstufige Aufgaben zerfallen.
Source: https://rfriedmann.de/de/blog/how-an-agent-uses-tools-and-memory/ · English: https://rfriedmann.de/blog/how-an-agent-uses-tools-and-memory/
Published: 2026-06-17 · Track: learn · Level: Advanced
[Ein Agent ist ein Sprachmodell in einer Schleife mit Werkzeugen](/de/blog/what-is-an-ai-agent/):
denken, handeln, beobachten, wiederholen. Das ist die Form. Dieser Beitrag öffnet die
zwei Teile, die entscheiden, ob ein Agent in der Praxis nützlich ist oder nur
in einer Demo: wie ein Tool-Aufruf tatsächlich funktioniert und was der Agent als
Gedächtnis benutzt.
## Wie das Modell ein Werkzeug anfordert
Zu Beginn einer Aufgabe gibt der Runner dem Modell eine Speisekarte: Das sind deine
Werkzeuge, das tut jedes, und diese Argumente nimmt jedes entgegen. In der Praxis ist
das eine maschinenlesbare Liste, ein Eintrag pro Werkzeug:
```json
{
"name": "read_file",
"description": "Return the text contents of a file.",
"arguments": { "path": "string, the file to read" }
}
```
Wenn das Modell eines nutzen will, schreibt es keinen Satz darüber. Es gibt eine
[strukturierte Anfrage](/de/blog/constrained-decoding-valid-json/) aus, die der Runner exakt parsen kann:
```json
{ "tool": "read_file", "arguments": { "path": "downloads/report.pdf" } }
```
Der Runner prüft die Anfrage (gibt es dieses Werkzeug wirklich? haben die Argumente die
richtige Form?), führt sie aus und hängt das Ergebnis als neuen Eintrag an das Gespräch
an, meist mit einer `tool`-Rolle markiert, damit das Modell seine eigenen Worte von dem
unterscheiden kann, was aus der Welt zurückkam. Dann ist das Modell wieder dran. Dieser
Handschlag, Modell schlägt vor, Runner führt aus, Ergebnis kommt zurück, ist jeder
Schritt der Schleife. Woher die Speisekarte und der Code hinter jedem Werkzeug kommen,
regelt ein eigener Standard, [MCP](/de/blog/what-is-mcp/).
## Das Gedächtnis ist nur das Protokoll
Innerhalb einer Aufgabe hat ein Agent kein Gedächtnis außer dem Protokoll. Woran er
sich mitten in einer Aufgabe „erinnert“, ist einfach der bisherige Text, das Ziel plus
jedes Denken, Handeln und Beobachten, alles aneinandergehängt und bei jeder einzelnen
Runde wieder eingespeist. Gedächtnisdateien und Memory-Tools, die Fakten über Aufgaben
hinweg tragen, funktionieren genauso: Sie laden Text zurück ins Protokoll.
Stell dir das Fenster als Streifen fester Breite vor, den die laufende Aufgabe langsam
von links füllt:
Das Kontextfenster füllt sich, während die Aufgabe läuft
[diagram omitted — see the page for the chart]Sich selbst überlassen wächst das Protokoll nur, also geht einer ausreichend langen Aufgabe irgendwann der Platz aus.
„Gedächtnis“ und „der Prompt“ sind also dasselbe. In jeder Runde baut der Runner das
ganze Protokoll neu auf, und das Modell liest es von vorn. (Die Engine cacht die
schwere Mathematik, sodass das erneute Lesen billig ist, das ist die Geschichte vom
[KV-Cache](/de/blog/kv-cache-and-long-context/), aber konzeptionell beginnt das Modell jede
Runde damit, alles noch einmal zu lesen.)
Das ist ein einfaches Design und zugleich die zentrale Einschränkung. Das Protokoll wächst nur: Eine
Aufgabe mit zwanzig Schritten schleppt zwanzig Schritte Werkzeugausgabe mit sich. Zwei
Dinge gehen schief, wenn es sich füllt.
Eine kurze Aufgabe
Ziel und ein paar Werkzeugergebnisse passen locker hinein
Das Modell sieht in jeder Runde die ganze Historie
Jede Entscheidung fällt mit voller Information
Eine lange Aufgabe
Das Protokoll wächst über das Kontextfenster hinaus
Frühe Schritte müssen raus oder zusammengefasst werden
Das Modell beginnt, sein eigenes Ziel zu vergessen
## Das Gedächtnis länger halten
Weil das Fenster endlich ist, lassen praxistaugliche Agents das Protokoll nicht
ungebremst wachsen. Die üblichen Abhilfen:
Alte Runden zusammenfassen
Wird die Historie lang, die frühen Schritte zu einer kurzen Zusammenfassung verdichten und nur diese behalten. Der Agent tauscht Detail gegen Platz zum Weitermachen.
Einen Notizzettel führen
Den Agent seinen Plan und seine Erkenntnisse in eine kleine laufende Notiz schreiben lassen, eine Datei oder eine To-do-Liste, damit der wichtige Zustand in ein paar Zeilen steht, statt in Seiten von Werkzeugausgabe begraben zu sein.
Außerhalb speichern, bei Bedarf holen
Große Dinge (Dokumente, frühere Ergebnisse) in einen externen Speicher legen und dem Agent ein search-Werkzeug geben. Jetzt holt er nur die wenigen relevanten Teile, wenn er sie braucht, statt alles auf einmal mitzuschleppen.
Das Letzte ist der Grund, warum so viele Agents ein Such- oder Retrieval-Werkzeug
mitbringen: Es macht aus „alles merken“ ein „bei Bedarf nachschlagen“, und das skaliert
weit besser.
## Warum lange Pläne zerfallen
Das erklärt, warum lang laufende Agents scheitern. Jeder Schritt
ist ein frischer Tipp, bedingt auf ein Protokoll, das mit jeder Runde länger und
verrauschter wird. Drei Dinge schaukeln sich auf:
- **Fehler stapeln sich.** Eine kleine falsche Abzweigung in Schritt 3 wird zum
Kontext, dem das Modell in Schritt 4 vertraut, und der Fehler wird Teil des Plans.
- **Das Ziel verblasst.** Während sich Werkzeugausgabe anhäuft, wird die ursprüngliche
Anweisung ein immer kleinerer Anteil dessen, was das Modell liest. Spät in einem
langen Lauf kann es tatsächlich den Faden verlieren.
- **Geschwätzige Werkzeuge verdrängen das Signal.** Ein Werkzeug, das Tausende Zeilen
Ausgabe auskippt, verbraucht das Kontextbudget und verdeckt die relevante
Information. Gute Agent-Werkzeuge liefern die Antwort, nicht alle Rohdaten.
Nichts davon heißt, dass Agents nicht funktionieren. Es heißt, dass die, die
funktionieren, eng eingegrenzt sind: kleine, klar umrissene Aufgaben, Werkzeuge, die
wenig zurückgeben, und eine Prüfung am Ende statt ungeprüftem Vertrauen in eine Kette
aus zwanzig Schritten. Entscheidend ist weniger der Prompt als eine Schleife, die so
kurz bleibt, dass jeder Schritt geerdet ist.
Werkzeuge schaffen auch eine Angriffsfläche. Text, den ein Werkzeug zurückbringt, landet im selben
Kontext wie deine Anweisungen, und genau dort beginnt [Prompt Injection](/de/blog/prompt-injection/).
Das führt zu der Frage, die zählt, sobald ein Agent echte Systeme anfassen kann:
[wann du ihn selbstständig handeln lässt und wann ein Mensch die Kontrolle
behält](/de/blog/letting-an-agent-loose/).