Okay, Leute, Alex Petrov hier, zurück bei agntai.net. Es ist März 2026, und wenn ihr so seid wie ich, sind eure Slack-Kanäle und Twitter-Feeds voller Diskussionen über KI-Agenten. Nicht nur die abstrakten „Was wäre wenns“, sondern die sehr realen, sehr chaotischen „Wie man es macht“ mit diesen Dingen, um tatsächlich etwas Nützliches zu erreichen, ohne dass sie sich in ein teures, halluzinierendes Papiergewicht verwandeln.
Heute möchte ich über etwas sprechen, das mich quält und ehrlich gesagt auch einige meiner Beratungskunden: der stille Killer der Leistung von KI-Agenten – das Management des Kontextfensters. Wir konzentrieren uns alle so darauf, den „besten“ LLM auszuwählen, das perfekte Prompt zu erstellen oder ausgeklügelte Multi-Agenten-Systeme zu entwerfen, dass wir oft die anstrengende Arbeit übersehen, unsere Agenten fokussiert und effizient zu halten. Es ist nicht glanzvoll, aber glaubt mir, es ist der Ort, wo ein erheblicher Teil eurer Leistung (und eures Budgets) lebt oder stirbt.
Vor kurzem hatte ich einen Kunden, nennen wir sie „Acme Corp“, die einen Agenten wollten, um Kundensupport-Transkripte zu analysieren, wiederkehrende Probleme zu identifizieren und Zusammenfassungsberichte zu erstellen. Hätte einfach genug geklungen. Sie begannen mit einem ziemlich leistungsstarken LLM, gaben ihm Zugang zu einer Menge historischer Daten und erwarteten Magie. Was sie bekamen, war viel „Und es geht nicht nur um das Raw-Token-Limit eures gewählten LLM. Es geht darum, wie ihr die Informationen, die ihr ihm gebt, *strukturiert*, wie ihr sie *abruft* und entscheidend, wie ihr sie *zusammenfasst und filtert*, um den Agenten innerhalb seines kognitiven Sweet Spots arbeiten zu lassen.
Die versteckten Kosten von zu vielen Informationen
Wir waren alle schon mal dort. Ihr baut einen Agenten, ihr wollt, dass er schlau ist, also werft ihr ihm alles, außer dem Küchenspülbecken, zu. „Hier ist das gesamte Produktmanual, alle 500 FAQ für den Kundensupport und jedes vorherige Gespräch für den Kontext!“
Mein erster Versuch mit einem internen Agenten zur Ideenfindung für Blogbeiträge war aufgrund dessen eine Katastrophe. Ich fütterte ihn mit meinem gesamten Blogarchiv, in dem Glauben, dass er meinen Stil „lernen“ würde. Was er lernte, war zu schwafeln, verwirrt zu sein und häufig Themen vorzuschlagen, die ich bereits dreimal behandelt hatte. Es war, als würde man versuchen, ein kohärentes Gespräch mit jemandem zu führen, der gleichzeitig jedes Buch in einer Bibliothek liest. Informationsüberladung ist nicht nur ein menschliches Problem; es ist auch ein Problem für KI-Agenten.
Hier gibt es zwei Hauptprobleme:
- Token-Limits: Das ist das Offensichtliche. Jedes LLM hat ein maximales Kontextfenster. Überschreitet man es, erhält man entweder einen Fehler oder das Modell schneidet stillschweigend eure Eingabe ab und verliert wertvolle Informationen.
- Kognitive Last (für das LLM): Selbst innerhalb des Token-Limits macht ein größeres Kontext es dem LLM schwieriger, sich auf die wirklich relevanten Teile zu konzentrieren. Es ist, als würde man einen Menschen bitten, eine Nadel im Heuhaufen zu finden; je größer der Heuhaufen, desto länger dauert es und je höher ist die Wahrscheinlichkeit, dass man sie verpasst. Dies hat direkte Auswirkungen auf die Qualität der Antworten und oft auf die Fähigkeit des Agenten, komplexe Anweisungen zu befolgen.
Und lasst uns die Kosten nicht vergessen. Diese Tokens sind nicht kostenlos! Große Textmengen wiederholt zu füttern, kann euren Agenten schnell wirtschaftlich unhaltbar machen.
Strategien für intelligenteres Kontextmanagement
Wie lösen wir das? Es geht nicht darum, euren Agenten von Informationen zu verhungern; es geht darum, die *richtigen* Informationen zur *richtigen* Zeit im *richtigen* Format bereitzustellen. Hier sind ein paar praktische Strategien, die ich oft in Kombination verwende, um meine Agenten schlank und fokussiert zu halten.
1. Progressive Informationsoffenlegung
Anstatt alles auf einmal auszuwerfen, denkt an euren Agenten wie an einen Detektiv. Gebt ihm die sofort erforderlichen Fallinformationen, lasst es nach weiteren Informationen fragen, falls nötig, oder liefert ergänzende Details, während sich die Aufgabe entwickelt. Dies ist ein grundlegendes Prinzip in vielen agentic Rahmenwerken, wird aber oft schlecht umgesetzt.
Beispiel: Kundensupport-Agent
Anstatt ihm zu Beginn jeder Interaktion die gesamte Kundenhistorie und das Produktmanual zu geben, könntet ihr mit Folgendem beginnen:
- Der aktuellen Kundenanfrage.
- Eine kurze Zusammenfassung ihrer letzten Interaktion (wenn verfügbar und relevant).
- Zugriff auf Werkzeuge, um Produktinformationen oder frühere Tickets *nur bei Bedarf* nachzuschlagen.
Wenn der Kunde fragt: „Wie setze ich mein Passwort zurück?“, muss der Agent nicht über die Garantiebedingungen oder das neueste Software-Update Bescheid wissen. Er braucht das Verfahren zur Passwortzurücksetzung, das er über ein Tool oder eine stark fokussierte RAG-Abfrage abrufen kann.
2. Intelligente Zusammenfassung und Verdichtung
Das ist wahrscheinlich die wirkungsvollste Technik, die ich bei langlaufenden Agentenaufgaben gesehen habe. Anstatt ganze Gespräche oder Dokumente zwischen Schritten oder Runden weiterzugeben, fasst sie zusammen. Es geht nicht nur darum, Wörter zu kürzen; es geht darum, die *relevanten Punkte* zu extrahieren, die für zukünftige Schritte entscheidend sind.
Kommen wir zurück zum Transkriptionanalyse-Agenten von Acme Corp. Anfangs versuchten sie, ganze Transkripte in einen einzigen LLM-Aufruf für die Analyse einzufügen. Das stieß schnell auf Token-Limits. Mein Vorschlag war, es aufzuteilen:
- Schritt 1: Erste Durchsicht des Transkripts und Extraktion: Für jedes Transkript lässt man einen kleineren, spezialisierten Agenten (oder sogar ein Prompt für den Haupt-LLM) Schlüsselentitäten (Produktnamen, Kundensentiment, Problematypen) identifizieren und das Kernproblem sowie die Lösung zusammenfassen. Diese Ausgabe ist viel kleiner als das ursprüngliche Transkript.
- Schritt 2: Aggregieren & Synthese: Diese extrahierten Zusammenfassungen (nicht die ursprünglichen Transkripte!) an einen übergeordneten Agenten zur Mustererkennung und Berichtserstellung weitergeben.
Hier ist eine vereinfachte Python-Implementierung, die zeigt, wie man ein Transkript für die spätere Verwendung zusammenfassen könnte:
from openai import OpenAI
client = OpenAI()
def summarize_transcript(transcript_text: str) -> str:
"""Fasst ein Kundensupport-Transkript zusammen, um Schlüsselprobleme und Lösungen zu extrahieren."""
prompt = f"""
Du bist ein Experte für Zusammenfassungen von Kundensupport-Interaktionen.
Lese das folgende Transkript und gib eine kurze Zusammenfassung (unter 200 Wörtern), die
das Kernproblem des Kunden, die Schritte zur Lösung und das endgültige Ergebnis identifiziert.
Konzentriere dich auf umsetzbare Einblicke zur Produktverbesserung oder häufige Kundenbeschwerden.
Transkript:
---
{transcript_text}
---
Zusammenfassung:
"""
response = client.chat.completions.create(
model="gpt-4o", # Oder welches Modell auch immer du für Zusammenfassungen bevorzugst
messages=[
{"role": "system", "content": "Du bist ein hilfreicher Assistent."},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=250 # Kontrolle der Zusammenfassungsgröße
)
return response.choices[0].message.content.strip()
# Beispielnutzung:
# with open("sample_transcript_001.txt", "r") as f:
# sample_transcript = f.read()
# condensed_info = summarize_transcript(sample_transcript)
# print(f"Ursprüngliche Länge: {len(sample_transcript)} Zeichen")
# print(f"Kondensierte Länge: {len(condensed_info)} Zeichen")
# print(condensed_info)
Dieser einfache Zusammenfassungsschritt kann den Kontext um Größenordnungen reduzieren, wodurch die nachfolgende Analyse viel effizienter und effektiver wird.
3. Rekursive Zusammenfassung für langlaufende Gespräche
Für Agenten, die an mehrteiligen Gesprächen (wie einem persönlichen Assistenten oder einem ausgeklügelten Chatbot) beteiligt sind, wird das Kontextfenster schnell zum Problem. Jede neue Nachricht fügt sich der Historie hinzu. Die Lösung? Rekursive Zusammenfassung.
Nach einer bestimmten Anzahl von Runden (sagen wir 5-10 Nachrichten) nehmt ihr den aktuellen Gesprächsverlauf und fragt das LLM nach den wichtigsten Punkten, die bisher besprochen wurden, wobei entscheidende Details wie getroffene Entscheidungen, offene Fragen oder spezifische Benutzeranforderungen beibehalten werden. Dann könnt ihr die ältere, ausführliche Historie verwerfen und durch diese prägnante Zusammenfassung ersetzen, wodurch das Kontextfenster effektiv erfrischt wird.
Denkt daran, dass es so ist, als würde man während eines langen Meetings Notizen machen. Ihr transkribiert nicht jedes Wort; ihr haltet die wichtigsten Erkenntnisse und Aktionen fest.
Hier ist ein konzeptioneller Ablauf für die rekursive Zusammenfassung:
conversation_history = [] # Speichert (Rolle, Inhalt) Tupel
summary = ""
def add_to_history(role, content):
global conversation_history
conversation_history.append({"role": role, "content": content})
# Überprüfen, ob die Historie zu lang wird
if len(str(conversation_history)) > MAX_HISTORY_LENGTH_THRESHOLD:
global summary
# Vorhandene Zusammenfassung zur Historie hinzufügen, bevor zusammengefasst wird
full_context_to_summarize = [{"role": "system", "content": f"Zusammenfassung des vorherigen Gesprächs: {summary}"}] if summary else []
full_context_to_summarize.extend(conversation_history)
# LLM mit dem kombinierten Kontext verwenden
summarization_prompt = [
{"role": "system", "content": "Du bist ein prägnanter Zusammenfasser. Fasse die wichtigsten Punkte des bisherigen Gesprächs zusammen, mit Fokus auf Entscheidungen, Anforderungen und offene Fragen. Halte es unter 200 Wörtern."},
*full_context_to_summarize
]
# Dieser Teil würde einen tatsächlichen LLM-Aufruf erfordern
new_summary_response = client.chat.completions.create(
model="gpt-4o",
messages=summarization_prompt,
temperature=0.2,
max_tokens=200
)
summary = new_summary_response.choices[0].message.content.strip()
conversation_history = [] # Historie zurücksetzen, basierend auf der neuen Zusammenfassung
print("Historie zusammengefasst und zurückgesetzt!")
# Beispielinteraktion:
# add_to_history("user", "Ich muss eine Reise nach Rom nächsten Monat für 3 Personen planen.")
# add_to_history("assistant", "Okay, ich kann dir dabei helfen. Was sind deine bevorzugten Daten?")
# # ... mehrere Runden ...
# add_to_history("user", "Wir haben uns auf den 15.-22. März geeinigt. Wir möchten ein Hotel in der Nähe des Kolosseums.")
# # An diesem Punkt könnte add_to_history die Zusammenfassung auslösen, wenn MAX_HISTORY_LENGTH_THRESHOLD erreicht ist
# # Die neue 'Zusammenfassung' würde "Reise nach Rom, 15.-22. März, 3 Personen, Hotel in der Nähe des Kolosseums." enthalten
# # Die 'conversation_history' wäre leer oder würde nur die aktuellsten Runden enthalten.
Der Trick hier besteht darin, sicherzustellen, dass der Zusammenfassungsaufforderung die *wichtigsten* Informationen für zukünftige Runden korrekt identifiziert und beibehält, nicht nur eine allgemeine Übersicht.
4. Zielgerichtete Retrieval-unterstützte Generierung (RAG)
RAG ist eine grundlegende Technik, aber ihre Anwendung im Kontextmanagement wird oft unterschätzt. Anstatt ganze Dokumente einzubetten, solltest du *Chunks* von Dokumenten einbetten, und, was noch wichtiger ist, solltest du klug darüber nachdenken, *was* du abrufst.
Meine größte Lernkurve mit RAG war die Erkenntnis, dass es oft nicht ausreicht, einfach eine Benutzeranfrage an eine Vektordatenbank zu richten und die Top-N Chunks zurückzuholen. Du musst die Anfrage vorverarbeiten oder sogar ein LLM verwenden, um zunächst eine bessere Suchanfrage zu generieren. Zum Beispiel, wenn ein Benutzer fragt: „Wie behebe ich den Fehlercode 101 an meinem ACME-2000 Drucker?“, könnte eine einfache semantische Suche nach „Fehler 101 beheben“ allgemeine Fehlersuche zurückbringen. Aber wenn du zuerst ein LLM bittest, „Gerät: ACME-2000 Drucker“ und „Fehlercode: 101“ zu extrahieren, kannst du eine viel genauere RAG-Anfrage formulieren.
Außerdem solltest du darüber nachdenken, *was* du chunkst und einbettet. Für die Analyse des Acme Corp Transkripts haben wir anstelle von vollständigen Transkripten die *Zusammenfassungen* verwendet, die in Schritt 1 erstellt wurden. Das bedeutet, dass das RAG-System viel prägnantere, höherwertige Informationen abruft, was die übergebene Kontextinformation an den endgültigen Analyse-Agenten drastisch reduziert.
5. Schema-gesteuerte Informationsextraktion
Wenn du spezifische Informationen aus einem größeren Text benötigst, verlasse dich nicht darauf, dass das LLM „es einfach herausfindet.“ Gib ihm ein Schema. Dies ist besonders nützlich, um strukturierte Daten aus unstrukturiertem Text zu extrahieren, die dann viel effizienter weiterverarbeitet werden können als reiner Text.
Wenn du beispielsweise Bewerbungen bearbeitest, kannst du anstelle des gesamten Lebenslaufs das LLM auffordern, „Name“, „E-Mail“, „Jahre der Erfahrung“, „Schlüsselqualifikationen“, „Letzte Position“ usw. in ein JSON-Objekt zu extrahieren. Diese strukturierten Daten sind kompakt, eindeutig und leicht von nachfolgenden Agentenschritten oder externen Systemen zu verarbeiten.
Es geht hierbei nicht nur darum, Tokens zu sparen; es geht darum, Mehrdeutigkeit zu reduzieren und die Zuverlässigkeit des Informationsaustauschs zwischen Agentmodulen oder -tools zu verbessern.
Handlungsorientierte Erkenntnisse für dein nächstes Agentenprojekt
Okay, das war viel. Aber die Kernbotschaft ist diese: Behandle das Kontextfenster deines LLM wie kostbaren Grundbesitz. Jedes Token kostet Geld und belastet das kognitive System.
- Gestalte einen durchdachten Informationsfluss: Schütte nicht einfach Daten aus. Überlege, welche Informationen wirklich notwendig sind bei jedem Schritt des Prozesses deines Agenten.
- Nutze Zusammenfassungen (aggressiv): Für jede langwierige Aufgabe oder mehrteilige Konversation sollte die Zusammenfassung ein zentraler Bestandteil deiner Agentenarchitektur sein. Experimentiere mit verschiedenen Zusammenfassungsaufforderungen, um herauszufinden, was für deinen Anwendungsfall am besten funktioniert.
- Chunk intelligent, abrufen noch intelligenter: Bei RAG konzentriere dich sowohl auf die Qualität deiner Chunks (sind sie bedeutungsvolle, eigenständige Einheiten?) als auch auf die Präzision deiner Abrageanfragen. Erwäge, ein LLM zu verwenden, um die Anfragen zu verfeinern, bevor du deine Vektordatenbank anfragst.
- Verwende Schemata für strukturierte Extraktion: Wenn du genau weißt, welche Art von Informationen du benötigst, sage dem LLM dies eindeutig mit JSON-Schemata oder klaren Formatierungsanweisungen. Das reduziert Rauschen und verbessert die nachgelagerte Verarbeitung.
- Überwache die Token-Nutzung: Nimm dies ernst; integriere die Token-Zählung in die Protokollierung deines Agenten. Es ist der einzige Weg, um wirklich zu verstehen, wo dein Kontextfenster genutzt wird und wo Optimierungen erforderlich sind. Werkzeuge wie LangChain oder LlamaIndex bieten oft Hooks dafür.
Ich weiß, dass es verlockend ist zu denken, dass größere Kontextfenster neuerer Modelle all diese Probleme lösen werden. Und ja, sie helfen. Aber selbst mit massiven Kontextfenstern bleiben die Prinzipien des effizienten Informationsmanagements entscheidend. Ein Kontextfenster von 1M Tokens bedeutet nicht, dass du es mit irrelevanten Inhalten füllen solltest. Es bedeutet nur, dass du mehr Kapazität für *relevante, hochwertige* Informationen hast.
Also, das nächste Mal, wenn du an einem Agenten debuggen musst, der verwirrt, halluziniert oder einfach nur langsam ist, schau dir sein Kontextfenster genau an. Es könnte der stille Killer sein, den du übersiehst.
Bis zum nächsten Mal, baue weiterhin intelligentere Agenten! Alex Petrov, abgemeldet.
Verwandte Artikel
- AI-Regulierungsnachrichten: Ansätze der USA vs. der EU und warum das wichtig ist
- Erklärung der Komponenten der KI-Agentenarchitektur
- Agentenbenchmarking: So misst man die echte Leistung
🕒 Published: