KI-Agenten für zukünftige Ingenieure: Speicher, Werkzeuge und Steuerungsschleifen
Eine praktische Karte der Bausteine für Agenten – Planung, Werkzeuge, Speicher und Bewertung – ohne übertriebenes Fachjargon, der die Gestaltung verdeckt.
Dieser Leitfaden erstellt erneut einen nutzbaren Weg für: Alles, was künftige KI-Entwickler über KI-Agenten wissen müssen. Der Fokus liegt auf Verträgen, Überprüfungen sowie Code, den man ohne Rückschluss auf die Absicht in ein Repository einfügen kann. Zur Übersicht sollten vor der Codeänderung Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
Wie Agenten handeln
Für „Wie Agenten handeln“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Begrenzen Sie die Schemata der Tools streng. Weite Freitextargumente ermöglichen Injection-Angriffe und machen Audits kostspielig.
import requests
def search_web(query: str) -> list[dict]:
response = requests.get(
"https://serpapi.com/search",
params={"q": query, "api_key": "YOUR_API_KEY", "num": 5},
)
results = response.json()["organic_results"]
return [
{"title": r["title"], "url": r["link"], "snippet": r["snippet"]}
for r in results
]
results = search_web("best sourdough recipe")
for r in results:
print(r["title"], "-", r["url"])
import anthropic
client = anthropic.Anthropic()
# The menu of tools the model can choose from
tools = [
{
"name": "web_search",
"description": "Search the web for current information.",
"input_schema": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query"}
},
"required": ["query"],
},
}
]
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[{"role": "user", "content": "What's the weather in Seattle right now?"}],
)
print(response.content)
# [ToolUseBlock(name='web_search', input={'query': 'Seattle weather today'})]
# 1. Parse the LLM response to find the tools it wants to run
tool_calls = [block for block in response.content if block.type == "tool_use"]
# 2. Run the functions directly, OUTSIDE of the LLM
# (this is our search_web function from earlier -- plain Python,
# the model never sees this code)
tool_results = []
for call in tool_calls:
if call.name == "web_search":
output = search_web(call.input["query"])
tool_results.append(
{
"type": "tool_result",
"tool_use_id": call.id,
"content": str(output),
}
)
# 3. Hand the results back -- from the model's perspective,
# the answer just shows up in the chat
final = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[
{"role": "user", "content": "What's the weather in Seattle right now?"},
{"role": "assistant", "content": response.content},
{"role": "user", "content": tool_results},
],
)
print(final.content[0].text)
# "It's 62 and cloudy in Seattle."
Mehrschrittige Aufgaben
Für mehrstufige Aufgaben sollten die Eingaben, der Verantwortliche für jede Stufe sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Bediener sollten in der Lage sein, die jeweilige Stufe von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Zeiten und Kosten sollten neben den funktionalen Ergebnissen aufgezeichnet werden. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt. Tool-Schemata müssen streng begrenzt werden – weit gefasste Argumente im Freitext-Format ermöglichen Angriffe durch Dateninjektionen und machen Audits teuer.
# The ReAct loop
while True:
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=messages,
)
messages.append({"role": "assistant", "content": response.content})
# If the model didn't ask for any tools, it's done -- that's its final answer
if response.stop_reason != "tool_use":
break
# Otherwise: run the tools, append the results, and go around again
tool_results = []
for block in response.content:
if block.type == "tool_use":
output = run_tool(block.name, block.input)
tool_results.append(
{"type": "tool_result", "tool_use_id": block.id, "content": str(output)}
)
messages.append({"role": "user", "content": tool_results})
print(response.content[0].text)
# "Booked it into your calendar -- cheapest flight was the 9:15am Alaska
# departure Friday at $138. Event added from 9:15am to 11:30am."
Toverlässige Ausgaben
Zur Gewährleistung zuverlässiger Ausgaben sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den Operator:innen überprüfen können, ohne den gesamten Ablauf durchzulesen. Tool-Schemata sollten streng begrenzt werden. Weite Freitextargumente fördern Injection-Angriffe und erschweren die Überprüfungen. Zur Gewährleistung zuverlässiger Ausgaben sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
system_prompt = """You have access to a web_search tool.
To use it, respond with JSON in this format:
{"name": "web_search", "input": {"query": "..."}}
CRITICAL: You MUST respond with ONLY valid JSON. NO other text.
NO markdown. NO code fences. NO explanations before or after.
Your ENTIRE response must be parseable by json.loads().
DO NOT FORGET THE COMMAS. CHECK YOUR BRACKETS.
If you output anything that is not valid JSON, the system WILL CRASH.
THIS IS EXTREMELY IMPORTANT. VALID JSON ONLY.
"""
Hochwertige Eingaben
Für hochwertige Eingaben sollten die Eingabedaten, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingabedaten und den validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Erstellen Sie einen Checkpoint nach teuren Modellaufrufen, damit ein erneuter Versuch nicht denselben Aufwand nochmals berechnet.
tools = [
{
"name": "web_search",
"description": "Search the web for current information.",
"input_schema": {
"type": "object",
"properties": {"query": {"type": "string"}},
"required": ["query"],
},
},
{
"name": "add_calendar_event",
"description": "Add an event to the user's calendar.",
"input_schema": {
"type": "object",
"properties": {
"title": {"type": "string"},
"start_time": {"type": "string"},
},
"required": ["title", "start_time"],
},
},
# ...plus read_email, send_email, get_flights, book_flight,
# read_file, write_file, run_code, and 20 more
]
Ihr Agent vertrauen
Für das Vertrauen in Ihren Agenten sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erfassen Sie die Laufzeiten und Kosten zusammen mit den funktionalen Ergebnissen. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt. Legen Sie einen Checkpoint nach teuren Modellaufrufen an, damit ein erneuter Versuch nicht denselben Aufwand nochmals berechnet.
Operative Checkliste
Für die operative Checkliste sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Checkpoint nach teuren Modellaufrufen, damit ein erneuter Versuch nicht denselben Vorgang erneut berechnet.
Fügen Sie bei ausreichendem Budget einen Smoke-Test hinzu, der den kritischen Pfad in CI mit Fixtures testet.
Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
Checkpoint nach teuren Modellaufrufen, damit ein erneuter Versuch nicht denselben Vorgang erneut berechnet.
Vor der Einführung des Stack sollten Versionen eingefroren werden, ein „goldener“ Transkript für den kritischen Pfad aufgenommen und Rollback-Schritte bestätigt werden. Gemeinsame Umgebungen benötigen Rate Limits, Überprüfungen der Nutzungsrechte sowie einen klaren Verantwortlichen für die Rotation von Geheimnissen. Ziehen Sie langweilige Zuverlässigkeit vor cleveren, einmaligen Demonstrationen.
Zur Sicherheitshinweis 0: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.
Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Laufzeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt.
Beschränken Sie die Schemata der Tools streng. Weite Freitextargumente begünstigen Angriffe durch Dateninjektionen und machen Audits teuer.
Zur Sicherheitshinweis 1: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.
Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallablauf gemeinsam. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Checkpoint nach teuren Modellaufrufen, damit ein erneuter Versuch nicht denselben Vorgang erneut berechnet.
Zur Stärkung der Sicherheit gemäß Hinweis 2 sollten Eingaben, Verantwortliche für die Schritte sowie Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
Trennen Sie Planung von Tool-Exekution. Der Planer schlägt vor; der Ausführende führt aus; der Überprüfer prüft die Ergebnisse im Vergleich zum Ziel.
Zur Stärkung der Sicherheit gemäß Hinweis 3 sollten Eingaben, Verantwortliche für die Schritte sowie Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Halten Sie die Konfiguration außerhalb des Anwendungscode. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den die Betreiber überprüfen können, ohne den gesamten Ablauf durchlesen zu müssen.
Beschränken Sie die Schemata der Tools streng. Weite Argumente im Freitextformat ermöglichen Injection-Angriffe und erschweren die Überprüfungen erheblich.
Zur Absicherung beachten Sie Punkt 4: Definieren Sie vor dem Codeändern die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen raten zu müssen.
Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
Führen Sie nach teuren Modellaufrufen einen Checkpoint durch, damit ein erneuter Versuch nicht denselben Aufwand nochmals verursacht.
Zur Festigkeitsmaßnahme Nummer 5 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Laufzeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt.
Trennen Sie Planung von der Ausführung mit Tools. Der Planer schlägt vor; der Ausführende führt aus; der Überprüfer prüft die Ergebnisse im Vergleich zum Ziel.
Zur Festigkeitsmaßnahme Nummer 6 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallablauf gemeinsam. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Binden Sie die Toolschemata streng zusammen. Weite Freitextargumente ermöglichen Injection-Angriffe und machen Audits teuer.
Zur Absicherung gemäß Hinweis 7 sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Codeändern definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab.
Führen Sie einen Checkpoint nach teuren Modellaufrufen durch, damit ein Neversuch nicht denselben Aufwand erneut verursacht.
Zur Absicherung gemäß Hinweis 8 sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Codeändern definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Halten Sie die Konfiguration außerhalb des Anwendungscode. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Betreiber überprüfen können, ohne den gesamten Ablauf durchlesen zu müssen.
Trennen Sie die Planung von der Ausführung der Tools. Der Planer schlägt vor; der Ausführende führt aus; der Überprüfer prüft die Ergebnisse im Vergleich zum Ziel.
Zur Stärkung der Sicherheit sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen raten zu müssen.
Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
Beschränken Sie die Schemata der Tools streng. Weite Freitexteingaben ermöglichen Angriffe durch Injection und erschweren die Überprüfungen erheblich.
Zur Sicherheitshinweis 10 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Zeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt.
Führen Sie einen Checkpoint nach teuren Modellaufrufen durch, damit ein erneuter Versuch nicht denselben Aufwand nochmals berechnet.
Zur Sicherheitshinweis 11 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen.
Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallablauf gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.
Trennen Sie die Planung von der Ausführung des Tools. Der Planer schlägt vor; der Ausführende führt aus; der Überprüfer prüft die Ergebnisse im Vergleich zum Ziel.
Zur Stärkung der Sicherheit gemäß Hinweis 12 sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.
Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
Beschränken Sie die Schemata der Tools streng. Weite Freitextargumente ermöglichen Injection-Angriffe und machen Audits kostspielig.
Zur Stärkung der Sicherheit gemäß Hinweis 13 sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.
Halten Sie die Konfiguration außerhalb des Anwendungscode. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den die Betreiber überprüfen können, ohne den gesamten Ablauf durchlesen zu müssen.
Führen Sie nach teuren Modellaufrufen einen Checkpoint durch, damit ein erneuter Versuch nicht dieselbe Arbeit erneut ausführt.
Zu Punkt 14 zur Stärkung der Sicherheit: Definieren Sie vor dem Codeändern die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen raten zu müssen.
Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf.
Trennen Sie Planung von Tool-Exekution. Der Planer schlägt vor; der Ausführende führt aus; der Überprüfer prüft die Ergebnisse im Vergleich zum Ziel.
Zur Festigungshinweis 15 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.
Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Laufzeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen, wenn der Prozess von Demonstrationsumgebungen in gemeinsam genutzte Umgebungen übergeht.
Beschränken Sie die Schemata der Tools streng. Weite Freitextargumente begünstigen Injection-Angriffe und machen Audits teuer.