Agentic Coding met Tool Calling
Op deze pagina
Les bijgewerkt op 2 november 2026. De oorspronkelijke voorbeelden gebruikten Devstral, dat op 31 juli 2026 uit de API is verwijderd. Ze gebruiken nu Mistral Small 4 (
mistral-small-2603), en de agentic-lus volgt het model van de Mistral-documentatie (alle tool-aanroepen in een antwoord worden verwerkt tot het definitieve antwoord). Bron: Function calling.
Wat is agentic coding?
Agentic coding verandert de aard van wat u het model vraagt te doen. In plaats van eerst het ene fragment aan te vragen, dan het volgende, en vervolgens een derde, om ze zelf aan elkaar te plakken, wijst u een volledige taak toe. Het model lost deze op door de stappen zelf te ketenen: verkenning, planning, implementatie en verificatie. U blijft de beslisser over wat er moet gebeuren, maar u stopt met het micromanagen van elke beweging.
Devstral-modellen zijn gebouwd voor deze workflow; huidige algemene modellen, onder leiding van Mistral Small 4, behandelen dit via tool calling. Een agent beantwoordt niet alleen een vraag; hij handelt op de repository.
De agentic-cyclus
Fase 1 — Begrijpen
De agent begint altijd met het bepalen van zijn positie. Hij leest de map- en bestandsstructuur, identificeert bestanden die relevant zijn voor de gevraagde taak, traceert afhankelijkheden tussen modules om te zien wat een wijziging zou kunnen beïnvloeden, en noteert bestaande conventies—naamgeving, testorganisatie en terugkerende patronen. Deze fase lijkt onproductief omdat er geen code wordt geschreven, toch bepaalt deze of de resulterende code eruitziet als de uwe of als die van een vreemde.
Fase 2 — Plannen
Voordat hij een enkele regel schrijft, formuleert de agent een plan. Hij breekt de taak op in geordende subtaken, onderscheidt bestanden die gewijzigd moeten worden van die welke gemaakt moeten worden, anticipeert op neveneffecten en regressierisico’s, en kiest een technische aanpak. Dit is het moment waarop uw interventie het goedkoopst is: het corrigeren van een plan kost dertig seconden; het corrigeren van tien bestanden die u al heeft geschreven, kost veel langer.
Fase 3 — Uitvoeren
De implementatie rolt het plan stap voor stap uit. De agent bewerkt bestaande bestanden, maakt nieuwe aan wanneer de structuur dit vereist, werkt imports en afhankelijkheden bij die door zijn wijzigingen zijn verschoven, en past onderweg configuratiebestanden aan. Consistentie across deze wijzigingen is precies wat een completion-model niet kan garanderen.
Fase 4 — Verifiëren
Tot slot komt het bewijs dat het werk standhoudt. De agent voert de bestaande testsuite uit, schrijft nieuwe tests voor de code die hij zojuist heeft toegevoegd, zorgt ervoor dat de build slaagt, en bekijkt zijn eigen diff op fouten of verdwaalde wijzigingen. Een agent die deze fase overslaat, produceert aannemelijke code, geen correcte code.
Uitgewerkt voorbeeld: een bug oplossen
Stel dat u de agent vertelt: “Gebruikers krijgen een 500-fout wanneer ze een formulier indienen met een e-mailadres dat een ’+’ bevat.” De cyclus neemt dan deze vorm aan:
1. BEGRIJPEN
-> Zoek naar bestanden gerelateerd aan het formulier (zoek "email" in code)
-> Lees de controller die de indiening afhandelt
-> Lees de e-mailvalidatiefunctie
-> Identificeer de regex die '+' afwijst
2. PLANNEN
-> Wijzig de validatie-regex om '+' te accepteren
-> Voeg een unit-test toe voor e-mails met '+'
-> Verifieer dat geen ander deel van de code '+' eruit filtert
3. UITVOEREN
-> Wijzig src/validators/email.py: fix het regex-patroon
-> Maak tests/test_email_validation.py: voeg cases met '+' toe
-> Wijzig src/controllers/form.py: voeg een log toe voor debugging
4. VERIFIËREN
-> Voer pytest uit -> alle tests slagen
-> Controleer diff -> wijzigingen zijn consistent en minimaal
Merk de derde regel van het plan op: de agent lost niet alleen op waar de bug zich manifesteert; hij controleert of geen ander filter het teken elders afwijst. Deze zoektocht naar de oorzaak, in plaats van alleen naar het symptoom, is wat een agentic-oplossing onderscheidt van een lapmiddel.
Tool-gebruik in de praktijk
De agent handelt op zijn omgeving via functieaanroepen. U declareert de beschikbare tools in het verzoek, inclusief hun naam, beschrijving en parameterschema; het model kiest welke het aanroept en met welke argumenten.
# Voorbeeld van een agentic-conversatie
messages = [
{
"role": "user",
"content": "Voeg sterke wachtwoordvalidatie toe aan de auth-module."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Lees de inhoud van een projectbestand",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Bestandspad"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Schrijf of wijzig een projectbestand",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Voer een shell-commando uit",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # standaardwaarde: het model beslist of het een tool aanroept
)
Voor dit verzoek begint de typische reeks met read_file("src/auth/validators.py") om de bestaande code te begrijpen, gaat verder met read_file("tests/test_auth.py") om het formaat van de huidige tests te zien, en gaat dan over tot schrijven: write_file("src/auth/validators.py", ...) met de toegevoegde validatieregel, write_file("tests/test_auth.py", ...) met de nieuwe cases, en tot slot run_command("pytest tests/test_auth.py") om te verifiëren. Volgorde is belangrijk: door beide bestanden te openen voordat hij ook maar één teken aanraakt, pikt de agent uw conventies op en reproduceert hij deze, in plaats van die te importeren die hij elders heeft gezien.
Agentic-lus met meerdere beurten
Niets hiervan gebeurt in een enkele aanroep. Het hart van agentic coding is de lus met meerdere beurten: het model stelt een actie voor, uw code voert deze uit, en u stuurt het resultaat terug zodat het de volgende stap kan bepalen. U houdt de controle over de daadwerkelijke uitvoering, wat ook dient als uw veiligheidsrail.
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): # veiligheidsrail: een agent mag nooit oneindig loopen
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # geen tool-aanroepen meer: het definitieve antwoord is gearriveerd
for tool_call in tool_calls: # een antwoord kan meerdere aanroepen bevatten
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)
Drie details zijn belangrijk. Het bericht van de agent en elk tool-resultaat worden opnieuw in de geschiedenis geïnjecteerd, gekoppeld via de tool_call_id: laat er een weg, en de agent raakt de draad kwijt, waarbij hij dezelfde tools in een lus blijft aanroepen. Een enkel antwoord kan meerdere tool-aanroepen bevatten, aangezien parallelle aanroepen standaard zijn toegestaan (parallel_tool_calls=False verbiedt ze): verwerk ze allemaal. Begrens tot slot het aantal beurten en laat een mens shell-commando’s en bestandswrites valideren: een agent die alles uitvoert wat hij voorstelt, is een risico, geen tijdwinst.
Belangrijkste punten
- Agentic coding volgt een cyclus: begrijpen, plannen, uitvoeren, verifiëren
- De agent handelt op de repository via tool calling (
tools,tool_choice) - De lus met meerdere beurten laat de agent itereren tot volledige oplossing
- De agent wijzigt meerdere bestanden consistent binnen één taak
- De verificatiefase (tests, build) is essentieel voor betrouwbaarheid