Agentic Coding mit Tool-Calling
Auf dieser Seite
Lektion aktualisiert am 2. November 2026. Die ursprünglichen Beispiele verwendeten Devstral, das am 31. Juli 2026 aus der API entfernt wurde. Sie verwenden nun Mistral Small 4 (
mistral-small-2603), und der agentische Zyklus folgt dem Modell der Mistral-Dokumentation (alle Tool-Aufrufe in einer Antwort werden verarbeitet, bis die endgültige Antwort vorliegt). Quelle: Function calling.
Was ist agentic coding?
Agentic coding verändert die Art und Weise, wie Sie dem Modell Aufgaben stellen. Statt einzelne Codeabschnitte nacheinander zu bitten und diese selbst zu verknüpfen, weisen Sie eine vollständige Aufgabe zu. Das Modell löst sie, indem es die Schritte eigenständig verknüpft: Erkundung, Planung, Implementierung und Verifizierung. Sie bleiben der Entscheidungsträger für das, was getan werden muss, aber Sie entlasten das Modell von der Mikrosteuerung jedes einzelnen Schrittes.
Devstral-Modelle wurden für diesen Workflow entwickelt; aktuelle allgemeine Modelle, angeführt von Mistral Small 4, bewältigen dies durch Tool-Calling. Ein Agent beantwortet nicht nur eine Frage; er handelt direkt im Repository.
Der agentische Zyklus
Phase 1 — Verstehen
Der Agent beginnt stets damit, sich im Kontext zu orientieren. Er liest die Ordner- und Dateistruktur, identifiziert Dateien, die für die angeforderte Aufgabe relevant sind, verfolgt Abhängigkeiten zwischen Modulen, um zu sehen, was eine Änderung beeinflussen könnte, und notiert bestehende Konventionen – Benennung, Testorganisation und wiederkehrende Muster. Diese Phase wirkt unproduktiv, da kein Code geschrieben wird, doch sie bestimmt, ob der resultierende Code wie Ihr eigener wirkt oder wie der eines Fremden.
Phase 2 — Planen
Bevor eine einzige Zeile geschrieben wird, formuliert der Agent einen Plan. Er zerlegt die Aufgabe in geordnete Teilaufgaben, unterscheidet zwischen Dateien, die geändert werden sollen, und solchen, die neu erstellt werden müssen, antizipiert Nebenwirkungen und Risiken von Regressionen und entscheidet sich für einen technischen Ansatz. Dies ist der Zeitpunkt, an dem Ihre Intervention am kostengünstigsten ist: Die Korrektur eines Plans dauert etwa dreißig Sekunden; die Korrektur von zehn bereits geschriebenen Dateien dauert viel länger.
Phase 3 — Ausführen
Die Implementierung entfaltet den Plan Schritt für Schritt. Der Agent bearbeitet bestehende Dateien, erstellt neue, wenn die Struktur dies erfordert, aktualisiert Imports und Abhängigkeiten, die durch seine Änderungen verschoben wurden, und passt Konfigurationsdateien entsprechend an. Die Konsistenz dieser Änderungen ist genau das, was ein Completion-Modell nicht garantieren kann.
Phase 4 — Verifizieren
Schließlich kommt der Beweis, dass die Arbeit standhält. Der Agent führt die bestehende Testsuite aus, schreibt neue Tests für den von ihm hinzugefügten Code, stellt sicher, dass der Build erfolgreich ist, und prüft seinen eigenen Diff auf Fehler oder ungewollte Änderungen. Ein Agent, der diese Phase überspringt, produziert plausible, aber nicht korrekte Code.
Arbeitsbeispiel: Fehlerbehebung
Nehmen Sie an, Sie sagen dem Agenten: „Benutzer erhalten einen 500-Fehler, wenn sie ein Formular mit einer E-Mail-Adresse einreichen, die ein ’+’ enthält.” Der Zyklus nimmt dann folgende Form an:
1. VERSTEHEN
-> Suche nach Dateien, die mit dem Formular zusammenhängen (Suche "email" im Code)
-> Lies den Controller, der die Einreichung verarbeitet
-> Lies die E-Mail-Validierungsfunktion
-> Identifiziere den Regex, der '+' ablehnt
2. PLANEN
-> Passe den Validierungs-Regex an, um '+' zu akzeptieren
-> Füge eine Unit-Test für E-Mails mit '+' hinzu
-> Verifiziere, dass kein anderer Teil des Codes '+' filtert
3. AUSFÜHREN
-> Bearbeite src/validators/email.py: korrigiere das Regex-Muster
-> Erstelle tests/test_email_validation.py: füge Fälle mit '+' hinzu
-> Bearbeite src/controllers/form.py: füge ein Log für die Fehlersuche hinzu
4. VERIFIZIEREN
-> Führe pytest aus -> alle Tests bestehen
-> Prüfe den Diff -> Änderungen sind konsistent und minimal
Beachten Sie die dritte Zeile des Plans: Der Agent repariert nicht nur dort, wo der Fehler zum Vorschein kommt; er prüft, dass kein anderer Filter das Zeichen an anderer Stelle ablehnt. Diese Suche nach der Ursache statt nur des Symptoms unterscheidet eine agentische Reparatur von einer lokalen Pflasterung.
Tool-Nutzung in der Praxis
Der Agent greift auf seine Umgebung über Function Calls zu. Sie deklarieren die verfügbaren Tools in der Anfrage, einschließlich ihres Namens, ihrer Beschreibung und ihres Parameterschemas; das Modell wählt aus, welche davon aufgerufen werden sollen und mit welchen Argumenten.
# Beispiel für eine agentische Konversation
messages = [
{
"role": "user",
"content": "Fügen Sie eine strenge Passwortvalidierung in das Auth-Modul ein."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Liest den Inhalt einer Projektdatei",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Dateipfad"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Schreibt oder modifiziert eine Projektdatei",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Führt einen Shell-Befehl aus",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # Standardwert: das Modell entscheidet, ob ein Tool aufgerufen wird
)
Für diese Anfrage beginnt die typische Sequenz mit read_file("src/auth/validators.py"), um den bestehenden Code zu verstehen, setzt sich mit read_file("tests/test_auth.py") fort, um das Format der aktuellen Tests zu sehen, und bewegt sich dann zum Schreiben: write_file("src/auth/validators.py", ...) mit der hinzugefügten Validierungsregel, write_file("tests/test_auth.py", ...) mit den neuen Fällen und schließlich run_command("pytest tests/test_auth.py") zur Verifizierung. Die Reihenfolge ist wichtig: Indem beide Dateien vor dem Berühren eines einzelnen Zeichens geöffnet werden, nimmt der Agent Ihre Konventionen auf und reproduziert sie, statt solche zu importieren, die er an anderer Stelle gesehen hat.
Mehrstufiger agentischer Zyklus
Alles dies geschieht nicht in einem einzigen Aufruf. Das Herzstück des agentic coding ist der mehrstufige Zyklus: Das Modell schlägt eine Aktion vor, Ihr Code führt sie aus, und Sie senden das Ergebnis zurück, damit es den nächsten Schritt entscheiden kann. Sie behalten die Kontrolle über die tatsächliche Ausführung, was auch als Ihre Sicherheitsvorkehrung dient.
import json
TOOLS = {"read_file": read_file, "write_file": write_file, "run_command": run_command}
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
for _ in range(30): # Sicherheitsvorkehrung: Ein Agent darf niemals unendlich in einer Schleife bleiben
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # Keine weiteren Tool-Aufrufe: die endgültige Antwort ist eingetroffen
for tool_call in tool_calls: # Eine Antwort kann mehrere Aufrufe enthalten
name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
result = TOOLS[name](**arguments)
messages.append({
"role": "tool",
"name": name,
"content": str(result),
"tool_call_id": tool_call.id,
})
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
print(response.choices[0].message.content)
Drei Details sind wichtig. Die Nachricht des Agenten und jedes Tool-Ergebnis werden in die Historie zurückgespeist, gepaart durch die tool_call_id: Fehlt eines davon, verliert der Agent den Faden und ruft dieselben Tools in einer Schleife auf. Eine einzelne Antwort kann mehrere Tool-Aufrufe enthalten, da parallele Aufrufe standardmäßig erlaubt sind (parallel_tool_calls=False verbietet dies): Verarbeiten Sie alle. Schränken Sie schließlich die Anzahl der Durchläufe ein und lassen Sie einen Menschen Shell-Befehle und Dateischreibungen validieren: Ein Agent, der alles ausführt, was er vorschlägt, ist ein Risiko, kein Zeitersparnis.
Kernaussagen
- Agentic coding folgt einem Zyklus: verstehen, planen, ausführen, verifizieren
- Der Agent greift auf das Repository über Tool-Calling zu (
tools,tool_choice) - Der mehrstufige Zyklus ermöglicht es dem Agenten, bis zur vollständigen Lösung zu iterieren
- Der Agent modifiziert mehrere Dateien konsistent in einer einzigen Aufgabe
- Die Verifizierungsphase (Tests, Build) ist für die Zuverlässigkeit unerlässlich