Zum Hauptinhalt springen
Inhaltsverzeichnis

20.11.2026 · Zuletzt aktualisiert: 22.11.2026 · 7 Min. Lesezeit

Context Engineering für Coding Agents: was in den Kontext gehört und was nicht

Ein Coding Agent baut nach der Zusammenfassung eine verworfene Variante wieder ein. Mit Context Engineering verhindert eine nachprüfbare Fortschrittsnotiz das.

Dr. Matthias Klinger

Von den Expert:innen

Dr. Matthias Klinger

7 Min. Lesezeit

Context Engineering: gültige Entscheidung und Code-Stand verbunden (KI-generiert)
Visualisierung (KI)

Am Dienstag hat das Team entschieden, das neue Lieferfenster in der Bestell-API als optionales Feld einzuführen. Ein Pflichtfeld hätte eine ältere Version der Händler-App gebrochen, die jede Antwort gegen ein festes Schema prüft. Am Mittwoch startet der Coding Agent eine neue Sitzung und baut das Feld wieder als Pflichtfeld ein. Die Entscheidung stand im Gesprächsverlauf vom Dienstag, und von diesem Verlauf ist nach der automatischen Zusammenfassung nur noch ein Satz übrig.

Der Agent hat dabei nichts falsch verstanden. Er hat mit den Informationen gearbeitet, die ihm im neuen Arbeitsschritt vorlagen. Context Engineering ist die Disziplin, diese Informationen für jeden Schritt bewusst zusammenzustellen und am aktuellen Arbeitsstand zu halten, damit ein längerer Auftrag über mehrere Sitzungen nachvollziehbar weiterläuft.

Das Wichtigste in Kürze

  • Context Engineering bezeichnet die laufende Auswahl und Pflege aller Informationen, die ein Modell bei der Arbeit sieht. Der Startprompt ist davon nur ein Teil.
  • Eine Arbeitsmappe je Teilauftrag bündelt Ziel, gültige Entscheidungen, betroffenen Code, Prüfergebnisse und offene Fragen.
  • Quelle, Stand und Gültigkeit gehören an jede Information. Eine verworfene Variante wird als verworfen gekennzeichnet.
  • Nach einer Compaction prüft der Agent zuerst Code-Stand und Tests, bevor er den nächsten Teilauftrag wählt.
  • Ein Token-Budget macht Zielkonflikte sichtbar, etwa zwischen ausführlichen Testausgaben und dem Verlauf früherer Schritte.

Was gehört beim Context Engineering zum Kontext?

Zum Kontext eines Coding Agents gehört alles, was das Modell bei einem Arbeitsschritt sieht: Anweisungen, Werkzeugbeschreibungen, Dateiauszüge, Werkzeugresultate und der bisherige Verlauf. Anthropic beschreibt Context Engineering als natürliche Weiterentwicklung des Prompt Engineerings. Gemeint sind Strategien, mit denen die bestmögliche Menge an Informationen während der Arbeit des Modells zusammengestellt und gepflegt wird, einschließlich allem, was außerhalb des Prompts in den Kontext gelangt.[1]

Im Lieferfenster-Auftrag sieht der Agent Ihre Auftragsbeschreibung, die Beschreibung seiner Werkzeuge zum Lesen und Ändern von Dateien, Auszüge aus dem Code der Bestell-API, die Ausgaben der Testläufe und die Nachrichten der bisherigen Sitzung. Welche dieser Teile wann in welchem Umfang auftauchen, hängt von der Anwendung ab, die den Agenten steuert. Ein Teil davon wird erst während der Arbeit nachgeladen. Anthropic nennt das Just-in-time-Ansatz: Der Agent hält leichte Verweise wie Dateipfade bereit und lädt die Inhalte erst, wenn er sie braucht.[1]

Daraus folgt der Grund, warum der Begriff eine eigene Disziplin bezeichnet. Ein gut formulierter Startprompt bleibt über einen langen Auftrag gleich, während sich alles andere verändert. Dateien und Tests ändern sich mit jedem Schritt, und Entscheidungen fallen oder werden wieder revidiert. Wer nur den Startprompt pflegt, überlässt den wachsenden Rest dem Zufall. Was zum Kontextfenster eines Modells gehört und warum es begrenzt ist, erläutert Anthropic in seiner Dokumentation.

Die Arbeitsmappe für ein neues API-Feld

Nehmen Sie den Auftrag aus dem Einstieg als durchgehendes Beispiel. Die Antwort der Schnittstelle GET /orders/{id} soll ein Feld delivery_window erhalten, das Lieferfenster einer Bestellung. Bevor der Agent damit beginnt, stellt sich eine einfache Frage: Was muss er wissen, um ohne Rückfrage anzufangen, und was darf er auf keinen Fall übersehen?

Eine brauchbare Arbeitsmappe für diesen Teilauftrag hat fünf Bestandteile:

  • Schnittstellenvertrag: die aktuelle Beschreibung der Bestellantwort, etwa als OpenAPI-Datei, mit Stand und Fundort im Repository.
  • Aktuelle Implementierung: die zwei Dateien, in denen die Antwort zusammengebaut und serialisiert wird.
  • Einschlägige Tests: die Vertragstests der Bestell-API und der Test, der ältere Antwortformate prüft.
  • Kompatible Alt-Clients: der Hinweis, dass die ältere Händler-App Antworten streng gegen ihr Schema prüft.
  • Offene Produktfrage: ob das Feld fehlen oder den Wert null tragen soll, wenn kein Lieferfenster bekannt ist.

Auffällig ist, was in dieser Mappe fehlt. Das vollständige Repository steht nicht darin, ebenso wenig der gesamte Verlauf vom Dienstag. Den ersten Vorschlag des Agenten, das Feld als Pflichtfeld delivery_date einzuführen, führt die Mappe nur noch mit dem Vermerk „verworfen am Dienstag, bricht die ältere Händler-App“. Dieser Vermerk hätte die Wiederholung vom Mittwoch verhindert, und er nimmt eine Zeile ein. Die Mappe ist ein Vorschlag aus unserer redaktionellen Arbeit an diesem Fall; eine gemessene Wirkung behaupten wir dafür nicht.

Jede Information braucht Funktion, Quelle und Stand

Jede Information in der Arbeitsmappe bekommt eine Funktion, eine Quelle, einen Stand und eine Gültigkeit. Ohne diese Angaben sieht der Agent einen alten Vorschlag und eine gültige Entscheidung gleichrangig nebeneinander. Fünf Funktionen genügen für die meisten Coding-Aufträge:

FunktionBeispiel im API-FallQuelle und StandGültigkeit

Verbindliches Ziel

optionales Feld delivery_window

Auftrag vom Montag

bis zur Abnahme

Gültige Entscheidung

Feld bleibt optional

Teamrunde Dienstag

bis zum Widerruf

Bearbeiteter Code

Serialisierer der Bestellantwort

Commit vom Dienstag

bis zum nächsten Commit

Nachgewiesenes Prüfergebnis

Vertragstests grün

Testlauf nach dem Commit

nur für diesen Commit

Ungeklärte Frage

fehlen oder null?

offen, bei der Produktverantwortung

bis zur Antwort

Die Spalte „Gültigkeit“ verhindert die häufigste Verwechslung. Ein grüner Testlauf von gestern gilt nicht mehr, sobald danach Code geändert wurde. Er bleibt als Information erhalten, wandert aber vom Prüfergebnis zur Vorgeschichte.

Warum Ordnung wichtiger ist als Menge, legen zwei Befunde nahe. Die Studie „Lost in the Middle“ fand 2023 bei den damals untersuchten Sprachmodellen, dass die Leistung oft am höchsten war, wenn relevante Information am Anfang oder Ende eines langen Kontexts stand, und in der Mitte deutlich abfiel.[2] Für heutige Modelle ist das kein gesichertes Verhalten, als Warnung vor ungeordneten Langtexten taugt es weiterhin. Anthropic beschreibt außerdem „context rot“: Mit wachsender Tokenzahl im Kontextfenster sinkt laut Needle-in-a-Haystack-Studien die Fähigkeit, Informationen daraus genau abzurufen.[1] Daraus leitet der Hersteller als Leitlinie ab, die kleinstmögliche Menge aussagekräftiger Informationen zu finden, die das gewünschte Ergebnis am wahrscheinlichsten macht.

Wie setzt der Agent nach einer Compaction richtig fort?

Compaction heißt, einen Verlauf kurz vor der Grenze des Kontextfensters zusammenzufassen und mit dieser Zusammenfassung in einem neuen Kontextfenster weiterzuarbeiten.[1] Das hilft, löst aber das Problem vom Mittwoch nicht von selbst. Anthropic schreibt, die Kunst liege in der Auswahl dessen, was bleibt, denn eine zu aggressive Zusammenfassung könne subtile, aber entscheidende Informationen verlieren, deren Bedeutung sich erst später zeigt.

In einem eigenen Versuchsaufbau mit langlaufenden Coding-Agenten kam Anthropic zu dem Schluss, dass Compaction allein nicht ausreicht.[3] Die erste Sitzung legte dort eine Fortschrittsdatei und einen ersten Git-Commit an, jede weitere Sitzung arbeitete an genau einer Funktion und hinterließ einen beschreibenden Commit samt Eintrag in der Fortschrittsdatei. Zu Beginn jeder Sitzung las der Agent Git-Log und Fortschrittsdatei, um den Stand der Arbeit zu erfassen, und wählte erst dann die nächste offene Aufgabe. Das ist ein Hersteller-Setup aus dem Jahr 2025 und kein Beleg für jedes Repository. Die Reihenfolge lässt sich aber direkt auf den API-Fall übertragen.

Fortsetzung nach Compaction: Stand lesen, Tests prüfen, nächste Aufgabe wählen (KI-generiert)
Eine Fortsetzung beginnt mit dem Abgleich von Fortschrittsnotiz, Commit und Testergebnis, erst danach folgt der nächste Teilauftrag.

Für den Mittwoch ergeben sich daraus vier Schritte. Der Agent liest zuerst den letzten bestätigten Commit und die Fortschrittsnotiz. Dann lässt er die Vertragstests laufen und vergleicht das Ergebnis mit dem, was die Notiz behauptet. Stimmt beides überein, wählt er genau einen nächsten Teilauftrag, etwa die Dokumentation des Feldes in der OpenAPI-Datei; weicht es ab, klärt er zuerst die Abweichung. Erst danach ändert er Code.

Eine Fortschrittsnotiz muss auf bestätigten Code und Prüfergebnisse verweisen; reine Selbstbeschreibungen reichen nicht. Ein Satz wie „Feld eingebaut, alles getestet“ beschreibt, was der Agent zu wissen glaubt. Die folgende Fassung lässt sich in der nächsten Sitzung nachprüfen:

1Teilauftrag: delivery_window in GET /orders/{id}
2Bestätigter Stand: Commit a3f9c12 (Serialisierer, Vertragstest ergänzt)
3Prüfergebnis: Vertragstests grün auf a3f9c12; Alt-Format-Test grün
4Gültige Entscheidung: Feld optional (Teamrunde Dienstag)
5Verworfen: Pflichtfeld delivery_date (bricht ältere Händler-App)
6Offen: fehlen oder null bei unbekanntem Fenster? Wartet auf Produktverantwortung
7Nächster Schritt: OpenAPI-Beschreibung ergänzen

Für die nächste Sitzung ist damit festgehalten, worauf der Agent aufsetzt und was er zuerst prüfen muss. Ob die Notiz trägt, zeigt sich, wenn ein anderer Agent oder eine Kollegin den Auftrag mit diesen sieben Zeilen übernimmt.

Coding Agents einsetzen

Fortschrittsnotizen für Ihre Coding-Aufträge aufsetzen

Sie lassen Coding Agents an längeren Aufträgen arbeiten? Im Erstgespräch klären wir, welche Angaben Ihre Fortschrittsnotiz braucht und wie die nächste Sitzung sie prüft.

Erstgespräch vereinbaren

Ein Kontextbudget von 24.000 Tokens durchgerechnet

Ein angenommenes Budget von 24.000 Tokens zeigt, warum jede Verschiebung zulasten eines anderen Postens geht. Tokens sind die Texteinheiten, in denen Sprachmodelle ihre Eingabe zählen. Das Budget ist ausdrücklich ein Rechenbeispiel. Es beschreibt keine Grenze eines bestimmten Modells und keine gemessene ideale Verteilung.

PostenTokensAnteilInhalt im API-Fall

Relevante Dateien

8.000

33,3 Prozent

Schnittstellenvertrag, Serialisierer, Tests

Auftrag und Entscheidungen

3.000

12,5 Prozent

Ziel, Arbeitsmappe, Fortschrittsnotiz

Werkzeugresultate

5.000

20,8 Prozent

Testläufe, Suchergebnisse

Verlauf

4.000

16,7 Prozent

letzte Schritte dieser Sitzung

Reserve

4.000

16,7 Prozent

Nachladen bei Bedarf

Summe

24.000

100 Prozent

alle Posten

Die Rechnung 8.000 + 3.000 + 5.000 + 4.000 + 4.000 = 24.000 Tokens geht auf. Nun lässt der Agent die vollständige Testsuite laufen, und die ungefilterte Ausgabe umfasst angenommen 12.000 Tokens. Sie übersteigt den Posten Werkzeugresultate um 7.000 Tokens. Diese 7.000 Tokens müssten aus Verlauf und Reserve kommen, die zusammen 8.000 Tokens umfassen; übrig blieben 1.000 Tokens, und die letzten Arbeitsschritte der Sitzung wären praktisch verdrängt.

Die bessere Lösung liegt beim Werkzeug. Anthropic empfiehlt für Werkzeugantworten, nur aussagekräftige Informationen zurückzugeben und große Ausgaben mit Seitenaufteilung, Filtern oder Kürzung zu begrenzen.[4] Fehlermeldungen sollen dabei konkrete, umsetzbare Hinweise geben, wo sonst undurchsichtige Fehlercodes oder Stacktraces stünden. Für den Testlauf heißt das: Die gekürzte Ausgabe nennt die Zahl der Tests, die fehlgeschlagenen Tests mit ihrer Fehlermeldung und den Pfad zum vollständigen Protokoll. Wiederholte Erfolgszeilen fallen weg, Fehler, Einschränkungen und Referenzen bleiben erhalten.

Wo die Produktfrage beim Menschen bleibt

Die offene Produktfrage gehört in die Arbeitsmappe, die Antwort darauf gehört zu einem Menschen. Ob das Lieferfenster bei unbekanntem Wert fehlt oder null trägt, ist eine Entscheidung über das Verhalten Ihres Produkts gegenüber Händlern. Der Agent kann beide Varianten vorbereiten und ihre Folgen für die Tests beschreiben. Festlegen sollte sie die zuständige Produktverantwortung.

Die vier Bausteine agentischer Arbeit geben jedem Teil der Arbeitsmappe seinen Ort. Der Aufgabenbrief liefert Ziel und Abnahmekriterium, also das optionale Feld und die grünen Vertragstests. Die Verantwortungsgrenze trennt Codearbeit von Produktentscheidung. Die Eskalationskante greift, wenn der Schnittstellenvertrag fehlt oder einer gültigen Entscheidung widerspricht; dann hält der Agent an und fragt nach. Der Review-Rhythmus sichert nach jedem Teilauftrag den neuen Stand: Commit, Prüfergebnis und aktualisierte Fortschrittsnotiz.

Arbeitsteilung im API-Fall
  • Agent: stellt die Arbeitsmappe zusammen, ändert den Code, lässt die Tests laufen und schreibt die Fortschrittsnotiz mit Commit-Verweis.
  • Mensch: entscheidet die Produktfrage, nimmt den Teilauftrag ab und bestätigt, welche Entscheidungen weiter gelten.

Welche Coding-Aufgaben sich für einen Agenten überhaupt eignen, behandelt der Beitrag zu Aufgaben für Coding Agents. Für den Einstieg reicht ein überschaubarer Auftrag wie das Lieferfenster. Legen Sie für ihn eine Arbeitsmappe und eine Fortschrittsnotiz nach dem Muster oben an und prüfen Sie nach der zweiten Sitzung, ob der Agent ohne Rückfrage am richtigen Stand weitergemacht hat.

Coding Agents einsetzen

Wenn Ihr Coding Agent über mehrere Sitzungen am richtigen Stand weiterarbeiten soll

Im Erstgespräch wählen wir einen Teilauftrag aus Ihrem Repository und legen fest, welche Arbeitsmappe, Fortschrittsnotiz und Abnahme er braucht.

Erstgespräch vereinbaren

Häufige Fragen zu Context Engineering

Was unterscheidet Context Engineering von Prompt Engineering?

Prompt Engineering formuliert und ordnet die Anweisungen an ein Modell. Context Engineering pflegt zusätzlich alles andere, was während der Arbeit in den Kontext gelangt, etwa Dateiauszüge, Werkzeugresultate und Verlauf.

Reicht die automatische Zusammenfassung eines Coding-Tools aus?

Für kurze Aufträge oft. Bei längeren Aufträgen kann eine Zusammenfassung entscheidende Details verlieren. Eine Fortschrittsnotiz mit Commit-Verweis und Prüfergebnis macht den Stand zusätzlich nachprüfbar.

Wie groß sollte das Kontextbudget sein?

Eine allgemein ideale Größe gibt es nicht. Ein angenommenes Budget hilft, Zielkonflikte zu erkennen, etwa wenn ungefilterte Testausgaben den Verlauf früherer Schritte verdrängen.

Sollte der Agent das ganze Repository im Kontext haben?

In der Regel genügen die für den Teilauftrag relevanten Dateien und Verweise auf weitere. Der Agent kann zusätzliche Inhalte gezielt nachladen, wenn er sie braucht.

Quellen

  1. [1]Anthropic: Effective context engineering for AI agents, Engineering-Blog, 29. September 2025. https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
  2. [2]Liu, Nelson F. et al.: Lost in the Middle: How Language Models Use Long Contexts, arXiv:2307.03172, 2023. https://arxiv.org/abs/2307.03172
  3. [3]Anthropic: Effective harnesses for long-running agents, Engineering-Blog, 26. November 2025. https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents
  4. [4]Anthropic: Writing effective tools for agents, with agents, Engineering-Blog, 11. September 2025. https://www.anthropic.com/engineering/writing-tools-for-agents
KI-Unterstützung
Text
Claude Sonnet 5
Bilder
OpenAI GPT Image

Redaktionell geprüft von Dr. Matthias Klinger

Mehr erfahren

Textentwürfe, Strukturvorschläge und Recherchezusammenfassungen entstanden mit Claude Sonnet 5 (Recherche: Claude Sonnet 5) und wurden von Dr. Matthias Klinger vor der Veröffentlichung redaktionell geprüft und freigegeben. Bilder wurden mit OpenAI GPT Image generiert und kuratorisch ausgewählt. Die inhaltliche Verantwortung für Richtigkeit und Vollständigkeit liegt bei der Quandes GmbH.

Unsere KI-Transparenz-Erklärung
Context Engineering: Kontext für Coding Agents pflegen