Dein KI-Agent arbeitet die ersten 10 Schritte großartig.
Dann, etwa um Schritt 15, wird er schlampig.
Falsche Tool-Aufrufe. Vergisst deine ursprünglichen Anweisungen. Ergebnisse von geringer Qualität.
Die meisten geben dem Modell die Schuld.
Es liegt fast nie am Modell.
Es liegt daran, was das Modell sieht.
Die Organisation dessen, was das Modell sieht, nennt man Kontext-Engineering.
Es entwickelt sich schnell zur wichtigsten Fähigkeit für jeden, der KI-Agenten entwickelt.
Hier ist das vollständige Playbook.
Prompt-Engineering ist tot. Kontext-Engineering ist jetzt das, worauf es ankommt.
Du hast von Prompt-Engineering gehört.
Klare Anweisungen schreiben. Gute Beispiele geben. Dem Modell sagen, welche Rolle es spielen soll.
Das funktioniert perfekt für einen Chatbot.
Es hört auf zu funktionieren, sobald du einen Agenten entwickelst.
Hier ist der Grund.
Ein Chatbot beantwortet eine Frage und hört auf.
Ein Agent führt Aktionen aus – im Internet surfen, APIs aufrufen, Code schreiben, Befehle ausführen – Schritt für Schritt, manchmal über Dutzende von Schritten.
Jeder einzelne Schritt produziert eine Ausgabe, die zum Kontext des Modells hinzugefügt wird.
Und dieser Kontext ist endlich.
Das Engineering-Team von Anthropic definiert es so:
"Kontext ist die Menge der Tokens, die enthalten sind, wenn du von einem LLM sampelst. Kontext-Engineering ist die Optimierung des Nutzens dieser Tokens, um konsistent ein gewünschtes Ergebnis zu erzielen."
Einfach ausgedrückt: Stelle sicher, dass dein Agent die richtigen Informationen im richtigen Format zum richtigen Zeitpunkt sieht.
Prompt-Engineering ist eine Teilmenge des Kontext-Engineerings.
Kontext-Engineering ist alles.
Das Kontextfenster deines Agenten ist RAM. Und es füllt sich.
LangChain hat die richtige Analogie dafür.
Stell dir ein LLM wie eine neue Art von Betriebssystem vor.
Das Modell ist die CPU – es übernimmt das Denken.
Das Kontextfenster ist der RAM – der Arbeitsspeicher, in dem alles lebt, was das Modell derzeit sehen und logisch verarbeiten kann.
So wie dein Computer langsamer wird, wenn der RAM voll ist, verschlechtert sich die Denkfähigkeit deines Agenten, wenn das Kontextfenster überfüllt ist.
Dies wird als Kontextverfall bezeichnet.
Chroma hat eine Studie durchgeführt, die 18 führende Modelle evaluiert hat – GPT-4.1, Claude 4, Gemini 2.5, Qwen3 und andere.
Bei jedem einzelnen Modell ließ die Leistung nach, wenn die Eingabelänge zunahm.
Nicht erst an der harten Grenze. Deutlich davor.
Ein Modell mit einem 200.000-Token-Fenster könnte bereits bei 50.000 Tokens eine signifikante Verschlechterung zeigen.
Der Rückgang ist kontinuierlich. Keine Klippe.
Warum? Transformer funktionieren, indem jeder Token auf jeden anderen Token achtet – was n-quadratische Beziehungen erzeugt. Wenn der Kontext wächst, nimmt die Fähigkeit des Modells, all diese Beziehungen aufrechtzuerhalten, ab.
Und dann gibt es noch das "Lost in the Middle"-Problem.
LLMs zeigen eine U-förmige Aufmerksamkeitskurve.
→ Anfang des Kontexts: gut erinnert
→ Ende des Kontexts: gut erinnert
→ Mitte: weitgehend ignoriert
Forscher haben einen Genauigkeitsabfall von über 30 Prozentpunkten gemessen, wenn relevante Informationen vom Anfang des Kontexts in die Mitte verschoben wurden.
Deine ursprünglichen Anweisungen – begraben unter 50.000 Tokens von Tool-Ausgaben – verschwinden effektiv.
Claude Code-Nutzer haben festgestellt, dass die Ausgabequalität bei 40–60 % der Kontextkapazität nachlässt. Deutlich vor jeder harten Grenze.
Was konkurriert eigentlich um den Platz im Kontext deines Agenten?
7 Kategorien. Alle kämpfen um dasselbe endliche Fenster.
1. System-Prompt
Die Identität des Agenten. Verhaltensregeln. Kontrollflusslogik. Anweisungen für verschiedene Aufgabentypen. In einem Agenten ist das nicht nur "sei hilfreich". Es kann die gesamte Architektur definieren.
2. Tool-Definitionen
Jedes Tool, das der Agent aufrufen könnte, benötigt ein Schema, das beschreibt, was es tut, welche Parameter es benötigt und wann es verwendet werden soll.
3. Tool-Aufrufergebnisse
Jeder Tool-Aufruf fügt seine Ausgabe zum Kontext hinzu. Ein Abruf einer Webseite: 5.000–10.000 Tokens. Ein Dateilesevorgang: ähnlich. Das summiert sich schnell.
4. Abgerufenes Wissen (RAG)
Dokumente aus Vektordatenbanken, Suchergebnisse, API-Antworten – alles, was abgerufen wird, um die Entscheidungen des Agenten zu informieren.
5. Gesprächsverlauf
Das vollständige Transkript von allem, was passiert ist. Benutzernachrichten, Agentenantworten, Gedankengänge, frühere Entscheidungen. Wächst mit jeder Runde linear.
6. Gedächtnis
Kurzzeitgedächtnis aus der aktuellen Sitzung. Langzeitgedächtnis aus früheren Sitzungen – Benutzerpräferenzen, frühere Ergebnisse, erlernte Muster.
7. Agentenzustand
Aktueller Plan, Aufgabenliste, Fortschrittsmarkierungen, Notizen im Scratchpad. Die Metainformationen, die verfolgen, wo sich der Agent in einer mehrstufigen Aufgabe befindet.
Alle 7 konkurrieren um dasselbe Fenster.
Kontext-Engineering bedeutet zu entscheiden, was gewinnt.
Die 4 Kernstrategien
LangChain hat das Framework veröffentlicht, das jede Technik des Kontext-Engineerings in 4 Kategorien einordnet.
Jede Technik, die du jemals lernen wirst, passt in eine davon.
Schreiben. Auswählen. Komprimieren. Isolieren.
Strategie 1 – Schreiben (Agenten vergessen. Gib ihnen eine Möglichkeit, sich zu erinnern.)
Wenn sich das Kontextfenster eines Agenten füllt und komprimiert wird, gehen Informationen verloren.
Wenn der Agent vorher nichts aufgeschrieben hat – sind diese Informationen für immer verloren.
Schreiben bedeutet, dem Agenten Möglichkeiten zu geben, Informationen außerhalb des Kontextfensters zu speichern.
Drei Formen:
Scratchpads
Gib dem Agenten ein Tool, mit dem er während einer Aufgabe Notizen machen kann. Zwischenergebnisse. Getroffene Entscheidungen. Informationen, von denen er weiß, dass er sie später brauchen wird.
Anthropic hat ein "Think"-Tool entwickelt – einen speziellen Bereich, in dem Claude Probleme durcharbeiten kann.
Im tau-bench-Benchmark verbesserte dies die Leistung bei bestimmten Aufgaben um bis zu 54%.
Regeldateien
Persistentes prozedurales Gedächtnis.
Wenn du Claude Code verwendet hast, hast du CLAUDE.md gesehen.
Anweisungen, die zu Beginn jeder Sitzung geladen werden – Projektarchitektur, Konventionen, wie man Tests ausführt, worauf man achten muss.
Der Agent liest es jedes Mal, wenn er startet.
Er vergisst nie die Grundlagen.
Memory-Extraktion
Der Agent speichert Fakten, Benutzerpräferenzen und erlernte Muster, um sie über Sitzungen hinweg abrufen zu können.
Lebt vollständig außerhalb des Kontextfensters.
Informationen, die der Agent morgen braucht, warten dort, wenn morgen kommt.
Strategie 2 – Auswählen (Gib dem Agenten nicht alles. Gib ihm, was er gerade jetzt braucht.)
Ein Agent mit 40 Tools, einer großen Wissensbasis und mehreren Sitzungen Verlauf kann nicht alles auf einmal laden.
Etwas muss entscheiden, was für diesen Schritt relevant ist.
Traditionelles RAG: Das System entscheidet.
Benutzer fragt → Dokumente abrufen → in den Prompt einfügen → erledigt.
Statisch. Einmalig. Das Modell hat kein Mitspracherecht.
Agentisches RAG: Der Agent entscheidet. Er sucht, was er braucht, verfeinert Abfragen, wählt Tools aus, bestimmt, wann er genug Informationen hat.
Abruf als iterativer Prozess, nicht als einmalige Pipeline.
Das ist wichtig, weil sich die Relevanz bei jedem Schritt ändert – und nur der Agent weiß, was er als nächstes braucht.
Das Problem der Tool-Auswahl ist das, worüber die meisten stolpern.
Wenn dein Agent 40+ Tools hat, sind das potenziell 10.000 Tokens an Tool-Definitionen im Kontext, bevor überhaupt eine Arbeit beginnt.
Die Lösung: RAG über Tool-Beschreibungen.
Anstatt alle Tool-Definitionen in jeden Aufruf zu packen, verwende eine semantische Suche, um nur die Tools hervorzuheben, die für den aktuellen Schritt relevant sind.
Ein Paper namens RAG-MCP hat das getestet.
Genauigkeit der Tool-Auswahl: 14 % → 43 % (3-fache Verbesserung). Token-Nutzung: etwa halbiert.
Anthropic nennt es eine Hybridstrategie: Lade wesentlichen Kontext vorab (wie CLAUDE.md), lass den Agenten alles andere bei Bedarf abrufen.
Die Grundlagen vorab laden. Den Rest bei Bedarf abrufen.
Strategie 3 – Komprimieren (Kontext sammelt sich an. Behalte die Bedeutung, reduziere die Tokens.)
Selbst bei guter Auswahl sammelt sich Kontext an.
Jeder Tool-Aufruf, jedes abgerufene Dokument und jede Entscheidung bleibt im Fenster.
Stell dir vor, dein Agent hat 20 Tool-Aufrufe getätigt.
Kontext: 80.000 Tokens an angesammelten Tool-Ausgaben, Gesprächsverlauf und Gedankengängen.
Das meiste davon ist nicht mehr relevant. Der Agent hat bereits darauf reagiert.
Aber es ist immer noch da, nimmt Platz weg, beeinträchtigt die Aufmerksamkeit, treibt Kosten und Latenz in die Höhe.
Du kannst an 3 Punkten komprimieren.
Bevor Informationen in den Kontext gelangen:
→ Große Dokumente vor dem Abruf in zusammenhängende Stücke aufteilen (Chunking)
→ Neu bewerten (Reranking), sodass nur die nützlichsten Teile hineinkommen
→ Tool-Ausgaben während des Abrufs zusammenfassen, bevor sie in den Hauptkontext gelangen
Während der Agent arbeitet:
→ Fortlaufende Zusammenfassung des Gesprächsverlaufs – kontinuierlich aktualisiert
→ Beliebter Hybrid: die letzten 10 Nachrichten wörtlich behalten + alles Ältere zusammenfassen
→ Hartes Trimmen: ältere Nachrichten entfernen, sobald der Kontext eine Größenordnungsschwelle erreicht
→ Auto-Kompaktierung von Claude Code: wird bei 95 % Kapazität ausgelöst, fasst automatisch die gesamte Trajektorie zusammen
Nachdem der Agent auf etwas reagiert hat:
→ Löschen von Tool-Ergebnissen: Sobald ein Tool-Ergebnis vor 15 Schritten verwendet wurde, entfernen
→ Durch eine einzeilige Zusammenfassung ersetzen oder vollständig entfernen
→ Der Agent braucht nicht den vollständigen Text einer Webseite, die er vor 20 Schritten abgerufen hat
Das Ziel: die Token-Anzahl reduzieren. Bewahren, was wirklich wichtig ist.
Strategie 4 – Isolieren (Die wirkungsvollste Strategie. Ermöglicht Multi-Agenten-Systeme.)
Hier ist das tiefere Problem bei langen Agentenläufen.
Es geht nicht nur um Platz. Es geht um Kontamination.
Die detaillierten Dateisuchen aus der Recherchephase befinden sich noch im Kontext, wenn der Agent dazu übergeht, Code zu schreiben.
Dieser alte Recherchekontext ist jetzt Rauschen. Er lenkt das Modell während einer Phase ab, in der es sich auf eine saubere Implementierung konzentrieren muss.
Isolierung bedeutet, verschiedenen Teilen der Arbeit ihre eigenen separaten Kontextfenster zu geben.
Sub-Agenten
Ein übergeordneter Agent delegiert eine gezielte Teilaufgabe – "durchsuche die Codebasis nach allen authentifizierungsbezogenen Dateien" – an einen Sub-Agenten.
Der Sub-Agent arbeitet in seinem eigenen sauberen Kontextfenster.
Wenn er zurückmeldet, gibt er nur eine komprimierte Zusammenfassung.
Alle chaotischen Suchoperationen bleiben im Kontext des Sub-Agenten isoliert und verunreinigen nie den übergeordneten Agenten.
Zustandsschema-Isolierung (LangGraphs Ansatz)
Gestalte den Zustand des Agenten so, dass verschiedene Felder verschiedene Arten von Kontext speichern.
Das LLM sieht nur die Felder, die für den aktuellen Schritt relevant sind.
Tool-Ergebnisse liegen in einem "Backstage"-Feld – unsichtbar für das Modell, bis sie explizit hervorgehoben werden.
Fein abgestimmte Kontrolle darüber, was der Agent bei jedem Schritt sieht, ohne separate Sub-Agenten zu starten.
Isolierung ist das, was komplexe mehrstufige Arbeitsabläufe tatsächlich zuverlässig macht.
Verschiedene Aufgaben. Verschiedene Kontextfenster. Keine Kontamination.
4 Arten, wie Agenten scheitern (Benenne das Scheitern. Behebe es.)
Drew Breunig hat vier verschiedene Fehlermodi identifiziert, wenn der Agentenkontext wächst.
Jeder kaputte Agent, den du je gesehen hast, fällt in eine dieser Kategorien.
Fehler 1: Kontextvergiftung
Eine Halluzination oder ein Fehler gelangt in den Kontext.
Der Agent bezieht sich in nachfolgenden Schritten immer wieder darauf.
Schlechte Daten aus Schritt 5 potenzieren sich in jedem Schritt danach.
Behebung: Validiere Tool-Ausgaben, bevor sie in den Kontext gelangen. Nach der Erholung von einem Fehler komprimiere die Historie des fehlgeschlagenen Versuchs. Hinterlasse keine 10 Schritte einer Sackgassen-Debuggings, wenn nur die Lösung relevant ist.
━━━
Fehler 2: Kontextablenkung
Der Kontext wird so lang, dass das Modell beginnt, sich übermäßig auf die jüngste Geschichte zu verlassen.
Anstatt einen neuartigen Plan zu entwickeln, wiederholt es nur, was es kürzlich getan hat.
Es hört auf zu denken. Es beginnt zu wiederholen.
Behebung: Fasse aggressiv zusammen und schneide weg. Selbst wenn ein großes Kontextfenster verfügbar ist. Ein großes Fenster bedeutet nicht, es zu füllen.
━━━
Fehler 3: Kontextverwirrung
Überflüssiger Inhalt führt das Modell zu Entscheidungen von geringer Qualität.
Klassisches Beispiel: Ein Modell fällt bei einem Benchmark durch, wenn es 46 Tools erhält – obwohl der Kontext deutlich innerhalb der Grenzen lag –, funktioniert aber einwandfrei mit nur 19 Tools.
Die Tools waren nicht zu viele, als dass der Kontext sie hätte aufnehmen können.
Sie waren zu viele, als dass das Modell klar darüber hätte nachdenken können.
Behebung: Dynamisches Tool-Management. Verwende RAG-MCP, um nur die für den aktuellen Schritt relevanten Tools hervorzuheben. Halte das Tool-Set auf die aktuelle Phase abgestimmt.
━━━
Fehler 4: Kontextkollision
Neue Informationen widersprechen etwas, das bereits im Kontext ist.
Der System-Prompt sagt das eine. Ein abgerufenes Dokument sagt etwas anderes.
Der Agent kann den Widerspruch nicht auflösen. Produziert inkonsistentes Verhalten.
Behebung: Etabliere eine klare Autoritätsreihenfolge. System-Prompt > abgerufene Fakten > Gesprächsverlauf. Validiere neue Informationen gegen den bestehenden Kontext, bevor du sie einfügst. Verwende XML-Tags und klare Überschriften, damit das Modell weiß, welcher Quelle es vertrauen soll.
Wie man System-Prompts für Agenten schreibt (Nicht für Chatbots. Für Agenten.)
Ein Chatbot-System-Prompt gibt einen Ton an.
"Du bist ein hilfreicher Assistent. Sei präzise und freundlich."
Ein Agenten-System-Prompt definiert Architektur.
Er spezifiziert den Kontrollfluss – wie man Aufgabentypen angeht, welche Tools wann zu verwenden sind, was bei Fehlern zu tun ist, welche Leitplanken zu befolgen sind.
Es ist eher das Schreiben einer Stellenbeschreibung für einen autonomen Mitarbeiter als ein Persönlichkeits-Prompt.
Anthropic nennt es Schreiben auf der "richtigen Höhe".
Zu vorschreibend: "Wenn der Benutzer die Abrechnung erwähnt UND eine Rückerstattung erwähnt UND der Betrag über 100 $ liegt, rufe Tool X auf." Zerbrechlich. Bricht bei jedem Randfall, den du nicht vorhergesehen hast.
Zu vage: "Sei hilfreich und verwende die geeigneten Tools." Gibt dem Agenten nichts. Er kann keine guten autonomen Entscheidungen ohne konkrete Signale treffen.
Der optimale Bereich: Spezifisch genug, um autonomes Verhalten zu leiten. Flexibel genug, damit das Modell in neuen Situationen sein Urteilsvermögen anwenden kann. Starke Heuristiken. Keine starren Regeln.
Praktische Tipps:
→ Mit XML-Tags oder Markdown-Überschriften organisieren – Hintergrund, Anweisungen, Tool-Anleitung
→ Minimal beginnen und bei Fehlern iterieren – versuche nicht, jeden Randfall im Voraus zu antizipieren
→ Minimal bedeutet nicht kurz – ein komplexer Agenten-System-Prompt kann Tausende von Tokens umfassen, und das ist in Ordnung, solange jeder Token seinen Platz verdient
→ Wenige-Beispiele (Few-Shot) verwenden – zeige dem Agenten, wie gutes Verhalten aussieht, anstatt zu versuchen, jede Regel in Worten zu beschreiben
Der KV-Cache: Der $$$ -Grund, sich um die Kontextreihenfolge zu kümmern
Die meisten Agentenentwickler wissen nicht, dass es das gibt.
Wenn du Tokens an ein LLM sendest, berechnet das Modell Schlüssel-Wert-Repräsentationen für jeden Token.
Rechenintensiv.
Daher cachen Inferenzanbieter diese Repräsentationen.
Wenn der Anfang deines Kontexts – das Präfix – zwischen API-Aufrufen gleich bleibt, verwendet der Anbieter die gecachten Berechnungen wieder und verarbeitet nur die neuen Tokens am Ende.
Schnell. Günstig.
Aber wenn du den frühen Teil deines Kontexts zwischen Aufrufen umstellst oder änderst – machst du den Cache ungültig. Der Anbieter berechnet alles von Grund auf neu.
Der Kostenunterschied bei Claude Sonnet:
→ Gecachte Eingabe-Tokens: 0,30 $ pro Million
→ Nicht gecachte Eingabe-Tokens: 3,00 $ pro Million
10-facher Unterschied.
Für einen Agenten, der 30–40 API-Aufrufe pro Aufgabe tätigt, summiert sich das schnell.
Praktische Regeln für KV-Cache-Effizienz:
→ Stabiler Inhalt kommt an den ANFANG des Kontexts – System-Prompt, Tool-Definitionen, alles, was sich zwischen den Runden nicht ändert
→ Dynamischer Inhalt kommt ans ENDE – Gesprächsverlauf, aktueller Schritt, Agentenzustand
→ Füge Tools nicht dynamisch hinzu und entferne sie nicht während eines Gesprächs – das macht den Cache ungültig
→ Verwende Tool-Masking anstelle von Tool-Entfernung – behalte alle Tool-Definitionen stabil im Präfix (gecacht), markiere irrelevante einfach als für die aktuelle Phase nicht verfügbar
Der Workflow, der 35.000 Zeilen Code in 7 Stunden ausliefert
Dex Horthy (CEO von HumanLayer) hat dies auf dem AI Engineer Code Summit vorgestellt.
Sein Team hat Berichten zufolge damit ~35.000 Zeilen Code in einer großen Rust-Codebasis in einer einzigen 7-stündigen Sitzung ausgeliefert.
Die Methode: Häufige beabsichtigte Kompaktierung.
Strukturierte Agentenarbeit in Phasen. Jede Phase produziert ein kompaktiertes Artefakt. Jede neue Phase beginnt mit einem frischen Kontextfenster, das nur dieses Artefakt enthält.
Bleibe zu jeder Zeit bewusst unter 40–60 % des Kontextfensters.
Phase 1 – Recherche
Sub-Agenten erkunden die Codebasis. Lesen Dateien. Verfolgen Datenflüsse. Kartieren die Architektur.
Alle chaotischen Grep-Ergebnisse und Dateiinhalte bleiben in den Kontexten der Sub-Agenten. Berühren nie den übergeordneten Agenten. (Isolieren)
Ausgabe: eine kompakte research.md – Dateipfade, Funktionssignaturen, Muster, Fallstricke. (Schreiben)
Kontext-Reset: Die rohe Recherche nutzte 60–80 % des Fensters. Das Recherche-Artefakt komprimiert es auf 15–20 %. (Komprimieren)
Phase 2 – Planung
Neues Kontextfenster. Enthält nur: Recherchedokument + Problemdefinition.
Agent erstellt einen detaillierten Implementierungsplan.
Dies ist der wichtigste menschliche Überprüfungspunkt.
Fange Logikfehler hier, wo die Behebung einfach und kostenlos ist. Später kostet es Stunden.
Phase 3 – Implementierung
Ein weiteres frisches Kontextfenster. Enthält nur: den Plan.
Agent folgt ihm Schritt für Schritt.
Bei komplexen Aufgaben: eine progress.md verfolgt, was abgeschlossen wurde und was noch zu tun ist. (Schreiben)
Das Ergebnis: ein sauberer, fokussierter Agent in jeder Phase. Keine Kontamination. Kein Kontextverfall. Kein "schlampiger Schritt 20."
Wie die besten Plattformen das anders handhaben
Claude Code
Hybride Abfrage. CLAUDE.md wird vorab geladen. Tools wie glob und grep erledigen die just-in-time Navigation durch die Codebasis.
Auto-Kompaktierung bei 95 % – bewahrt Architekturentscheidungen und die 5 zuletzt aufgerufenen Dateien.
Kann Sub-Agenten für komplexe Teilaufgaben starten, jeder mit seinem eigenen sauberen Kontext.
Philosophie: "Tue das Einfachste, was funktioniert." Lass das Modell intelligent darüber sein, was es braucht, und gib ihm Werkzeuge, um es zu finden.
Manus
KV-Cache-bewusste Kontextanordnung: stabiles Präfix, dynamisches Suffix. Tool-Masking, keine Entfernung.
Beobachtungskomprimierungspipeline – jede Tool-Ausgabe wird verarbeitet, bevor sie in den Agentenkontext gelangt.
Persistente Aufgabenliste für die Zustandsverfolgung.
Dateisystem als Überlaufspeicher für entfernten Kontext.
Für Skalierung gebaut. Bedient Hunderttausende von Benutzern, bei denen Effizienz ein Kostenproblem ist.
ChatGPT-Agent
Visuell-orientierter Ansatz. Der Agent interagiert mit einem GUI-Browser.
Screenshots werden als visuelle Schnappschüsse zum Kontext hinzugefügt. Das Modell denkt über das nach, was es sieht.
Visuelle Tokens sind teuer, daher ist der Agent bei der Anzahl der Screenshots selektiv.
Verstärkungslernen (RL) wird verwendet, um optimale Strategien für die Tool-Nutzung in Tausenden von virtuellen Maschinen zu erlernen, anstatt sie explizit zu programmieren.
Google ADK
Der prinzipientreueste architektonische Ansatz.
Drei Designprinzipien:
- Trenne Speicherung von Präsentation – dauerhafter Zustand ist nicht dasselbe wie das, was in jedem API-Aufruf erscheint
- Explizite Transformationen – benannte, geordnete Prozessoren, die den Kontext in testbaren, zusammensetzbaren Schritten transformieren
- Kontext standardmäßig eingrenzen – jeder Modellaufruf sieht nur die minimal erforderlichen Informationen
Ingenieursdisziplin vor Prompt-Formulierung.
Die universelle Agenten-Umlauf-Pipeline
Jede ernsthafte Plattform läuft auf denselben 5-Schritte-Zyklus pro Agentenrunde hinaus:
→ Sammeln – Benutzereingabe, Gesprächsverlauf, Tool-Ergebnisse, abgerufene Dokumente, Agentenzustand
→ Auswählen – was für diesen Schritt innerhalb des verbleibenden Token-Budgets relevant ist
→ Komprimieren – zusammenfassen, kürzen oder umstrukturieren, um in den Kontext zu passen
→ Anordnen – stabiler Inhalt zuerst (Cache), dynamischer Inhalt zuletzt
→ Zusammenstellen + aufrufen – endgültiger Kontext → API-Aufruf → Ausgabe erhalten → Schleife
Dies ist die Schleife, die in jedem Produktionsagenten läuft, den du je verwendet hast.
Sie zu verstehen, unterscheidet Entwickler, die zuverlässige Agenten bauen, von denen, die sich fragen, warum ihr Agent bei Schritt 15 schlampig wird.
Die Zusammenfassung
Kontextverfall ist real und beginnt weit vor deiner Kontextgrenze.
Die 4 Strategien, die es beheben:
→ Schreiben – Informationen außerhalb des Kontexts speichern, damit Agenten nicht vergessen
→ Auswählen – nur das für diesen Schritt Nötige einbeziehen
→ Komprimieren – Tokens reduzieren, Bedeutung behalten, proaktiv statt reaktiv
→ Isolieren – separate Kontexte für separate Aufgaben, keine Kontamination
Die 4 Fehlermodi, auf die du achten solltest:
→ Vergiftung – schlechte Daten potenzieren sich durch jeden Schritt
→ Ablenkung – lange Historie lässt Agenten wiederholen statt denken
→ Verwirrung – zu viele Tools verschlechtern die Entscheidungsqualität
→ Kollision – Widersprüche erzeugen inkonsistentes Verhalten
Der KV-Cache bringt 10-fache Kosteneinsparung. Setze stabilen Inhalt an den Anfang.
Der beste Workflow: recherchieren → kompaktieren → planen → kompaktieren → implementieren. Frischer Kontext in jeder Phase.
Kontext-Engineering ist für ernsthafte Agentenarbeit nicht optional.
Es ist die Arbeit.
Falls dies nützlich war:
→ Teile es als Repost mit jedem Agentenentwickler, den du kennst
→ Folge @sairahul1 für weitere Systeme, die funktionieren, während du schläfst
→ Setze ein Lesezeichen – du wirst auf das Framework der 4 Strategien zurückkommen
Ich schreibe über KI, Produktentwicklung und Systeme, die tatsächlich funktionieren.
