Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Agentic Coding med Tool Calling

Lektion 6 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Hvad er agentic coding?
  2. Den agentiske cyklus
  3. Gennemarbejdet eksempel: Fix af en bug
  4. Tool-brug i praksis
  5. Agentisk løkke med flere omgange
  6. Vigtige pointer

Lektion opdateret 2. november 2026. De oprindelige eksempler brugte Devstral, som blev fjernet fra API’et den 31. juli 2026. De bruger nu Mistral Small 4 (mistral-small-2603), og den agentiske løkke følger Mistral-dokumentationsmodellen (alle tool-kald i et svar behandles indtil det endelige svar). Kilde: Function calling.

Hvad er agentic coding?

Agentic coding ændrer karakteren af det, du beder modellen om at gøre. I stedet for at anmode om ét kodeudsnit, derefter et andet, så et tredje, og selv sy dem sammen, tildeler du en komplet opgave. Modellen løser den ved at kæde trinene sammen på egen hånd: udforskning, planlægning, implementering og verifikation. Du forbliver beslutningstageren for, hvad der skal gøres, men du holder op med at mikrostyre hvert eneste træk.

Devstral-modeller blev bygget til denne workflow; nuværende generelle modeller, anført af Mistral Small 4, håndterer det gennem tool calling. En agent svarer ikke bare på et spørgsmål; den handler på repository’et.

Den agentiske cyklus

Fase 1 — Forstå

Agenten starter altid med at orientere sig. Den læser mappe- og filstrukturen, identificerer filer, der er relevante for den anmodede opgave, sporer afhængigheder mellem moduler for at se, hvad en ændring kan påvirke, og noterer eksisterende konventioner – navngivning, testorganisering og tilbagevendende mønstre. Denne fase ser uproduktiv ud, fordi den ikke skriver nogen kode, men det er her, det afgøres, om den resulterende kode vil ligne din eller en fremmeds.

Fase 2 — Planlæg

Før den skriver en eneste linje, formulerer agenten en plan. Den opdeler opgaven i ordnede delopgaver, skelner mellem filer, der skal modificeres, og dem, der skal oprettes, forudser bivirkninger og regressionsrisici og fastlægger en teknisk tilgang. Det er her, din indgriben er billigst: at rette en plan tager tredive sekunder; at rette ti filer, du allerede har skrevet, tager meget længere tid.

Fase 3 — Udfør

Implementeringen udfolder planen trin for trin. Agenten redigerer eksisterende filer, opretter nye, når strukturen kræver det, opdaterer imports og afhængigheder, der er forskudt af dens ændringer, og justerer konfigurationsfiler undervejs. Konsistens på tværs af disse ændringer er præcis det, en completions-model ikke kan garantere.

Fase 4 — Verificér

Til sidst kommer beviset på, at arbejdet holder. Agenten kører den eksisterende testsuite, skriver nye tests for den kode, den lige har tilføjet, sikrer, at buildet består, og gennemgår sit eget diff for fejl eller utilsigtede ændringer. En agent, der springer denne fase over, producerer plausibel kode, ikke korrekt kode.

Gennemarbejdet eksempel: Fix af en bug

Antag, at du fortæller agenten: „Brugere får en 500-fejl, når de indsender en formular med en e-mail, der indeholder et ’+’.” Cyklussen tager derefter denne form:

1. FORSTÅ
   -> Søg efter filer relateret til formularen (søg efter "email" i koden)
   -> Læs controlleren, der håndterer indsendelsen
   -> Læs e-mail-valideringsfunktionen
   -> Identificer det regex, der afviser '+'

2. PLANLÆG
   -> Modificer validerings-regexet til at acceptere '+'
   -> Tilføj en unit-test for e-mails med '+'
   -> Verificér, at ingen anden del af koden filtrerer '+' fra

3. UDFØR
   -> Modificér src/validators/email.py: fix regex-mønsteret
   -> Opret tests/test_email_validation.py: tilføj cases med '+'
   -> Modificér src/controllers/form.py: tilføj en log til debugging

4. VERIFICÉR
   -> Kør pytest -> alle tests består
   -> Tjek diff -> ændringerne er konsistente og minimale

Bemærk den tredje linje i planen: Agenten fixer ikke bare dér, hvor bugen manifesterer sig; den tjekker, at intet andet filter afviser tegnet andre steder. Denne søgen efter rodårsagen, snarere end bare symptomet, er det, der adskiller en agentisk fix fra en lapning på stedet.

Tool-brug i praksis

Agenten handler på sit miljø gennem funktionskald. Du erklærer de tilgængelige tools i anmodningen, inklusive deres navn, beskrivelse og parameterskema; modellen vælger, hvilke den skal kalde, og med hvilke argumenter.

# Eksempel på en agentisk samtale
messages = [
    {
        "role": "user",
        "content": "Add strong password validation to the auth module."
    }
]

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the content of a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "File path"}
                },
                "required": ["path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write or modify a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Execute a shell command",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string"}
                },
                "required": ["command"]
            }
        }
    }
]

response = client.chat.complete(
    model="mistral-small-2603",
    messages=messages,
    tools=tools,
    tool_choice="auto",   # standardværdi: modellen beslutter, om den skal kalde et tool
)

For denne anmodning starter den typiske sekvens med read_file("src/auth/validators.py") for at forstå den eksisterende kode, fortsætter med read_file("tests/test_auth.py") for at se formatet på de nuværende tests, og går derefter videre til skrivning: write_file("src/auth/validators.py", ...) med den tilføjede valideringsregel, write_file("tests/test_auth.py", ...) med de nye cases, og endelig run_command("pytest tests/test_auth.py") for at verificere. Rækkefølgen betyder noget: Ved at åbne begge filer, før den rører et eneste tegn, opsamler agenten dine konventioner og reproducerer dem, i stedet for at importere nogle, den har set andre steder.

Agentisk løkke med flere omgange

Intet af dette sker i et enkelt kald. Hjertet i agentic coding er løkken med flere omgange: modellen foreslår en handling, din kode udfører den, og du sender resultatet tilbage, så den kan beslutte næste skridt. Du beholder kontrollen med den faktiske eksekvering, hvilket også fungerer som din sikkerhedsforanstaltning.

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):   # sikkerhedsforanstaltning: en agent må aldrig løkke uendeligt
    tool_calls = response.choices[0].message.tool_calls
    if not tool_calls:
        break         # ingen flere tool-kald: det endelige svar er ankommet
    for tool_call in tool_calls:   # et svar kan indeholde flere kald
        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)

Tre detaljer er vigtige. Agentens besked og hvert tool-resultat injiceres igen i historikken, parret via tool_call_id: udelad enten, og agenten mister tråden og kalder de samme tools i en løkke. Et enkelt svar kan indeholde flere tool-kald, da parallelle kald er tilladt som standard (parallel_tool_calls=False forbyder dem): behandl dem alle. Begræns endelig antallet af omgange, og lad et menneske validere shell-kommandoer og filskrivninger: en agent, der eksekverer alt, den foreslår, er en risiko, ikke en tidsbesparelse.

Vigtige pointer

  • Agentic coding følger en cyklus: forstå, planlæg, udfør, verificér
  • Agenten handler på repository’et via tool calling (tools, tool_choice)
  • Løkken med flere omgange lader agenten iterere indtil fuld løsning
  • Agenten modificerer flere filer konsistent i en enkelt opgave
  • Verifikationsfasen (tests, build) er essentiel for pålidelighed