Claude Architect · Les

Wat een systeem agentisch maakt

Autonomie, toolgebruik en iteratieve besluitvorming

Les 1 van 413 stappen

Wat een systeem agentisch maakt is een gratis Claude Architect-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.

Wat is een agentisch systeem?

Een normaal programma volgt een vast script. Een agentisch systeem werkt anders: je geeft het een doel en het model bepaalt de stappen om dat doel te bereiken.

Drie eigenschappen maken een systeem agentisch:

Autonomie — het model kiest wat het vervolgens doet, niet je code.
Gebruik van hulpmiddelen — het kan handelen in de wereld (zoeken, bestanden lezen, API's aanroepen).
Iteratie — het herhaalt een lus: handelen, het resultaat observeren en opnieuw beslissen.

In het Claude Certified Architect-traject staan deze drie ideeën centraal in Agent Architecture & Orchestration, het grootste examendomein (27%).

Het model bewaart geen status

Elke aanroep van de Claude API is stateloos. Het model onthoudt niets tussen beurten. Je moet bij elke beurt de volledige berichtgeschiedenis meesturen.

Een verzoek bevat deze velden:

model — welk Claude-model je wilt gebruiken.
max_tokens — de limiet voor de uitvoer.
system — instructies en rol.
messages — het volledige gesprek tot nu toe.
tools — wat het model mag aanroepen.

Omdat er geen verborgen geheugen is, beheer je de lus die messages in de loop van de tijd uitbreidt. Die lus verandert één antwoord in agentisch gedrag.

import anthropic

client = anthropic.Anthropic()

messages = [{"role": "user", "content": "Check today's open orders."}]

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system="You are an operations assistant.",
    messages=messages,  # the FULL history, every single turn
    tools=TOOLS,
)

Autonomie: beslissingen worden door het model gestuurd

De kern van autonomie is eenvoudig: het model beslist, je code voert uit.

Je codeert niet hard dat het eerst moet zoeken, daarna samenvatten en vervolgens antwoorden. Je beschrijft het doel en de beschikbare hulpmiddelen, waarna Claude het pad bepaalt — ook wanneer het genoeg informatie heeft verzameld om te antwoorden.

Gebruik hardgecodeerde logica voor zaken die je moet garanderen (een terugbetalingslimiet, een identiteitscontrole). Al het overige is een beslissing van het model. Een te strak voorgeschreven pad doet het doel van een agent teniet.

Gebruik van hulpmiddelen: handelen in de wereld

Autonomie is nutteloos als het model alleen kan praten. Met hulpmiddelen kan Claude echte acties uitvoeren: een klant opzoeken, een bestand lezen of een query uitvoeren.

Je definieert elk hulpmiddel met een name, een description en een input_schema. De beschrijving is het belangrijkste selectiemechanisme — Claude leest deze om te bepalen wanneer het hulpmiddel van toepassing is. Namen zijn veel minder belangrijk.

Een goede beschrijving vermeldt het doel, de retourwaarden, de invoerformaten en randgevallen. Houd elke agent gericht: 4-5 hulpmiddelen per agent is optimaal; vanaf ongeveer 18 hulpmiddelen neemt de betrouwbaarheid van de selectie af.

TOOLS = [{
    "name": "lookup_order",
    "description": (
        "Fetch an order by its ID. Use when the user references a "
        "specific order. Returns status, items, and total. "
        "order_id format: 'ORD-' followed by 6 digits, e.g. ORD-001234. "
        "Returns an empty result if the order does not exist."
    ),
    "input_schema": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"],
    },
}]

Het signaal stop_reason

Na elk verzoek retourneert Claude een stop_reason. Zo laat het model weten wat er vervolgens moet gebeuren:

end_turn — Claude is klaar. De taak is voltooid.
tool_use — Claude wil een of meer hulpmiddelen uitvoeren en daarna doorgaan.
max_tokens — de uitvoer is afgekapt door je limiet.
stop_sequence — er is een aangepaste stopreeks bereikt.

De agentische lus is volledig opgebouwd rond het inspecteren van dit veld. Je hoeft nooit te raden wat het model bedoelde — het vertelt het rechtstreeks.

De agentische lus

Voeg de onderdelen samen en je krijgt de agentische lus:

Stuur het verzoek.
Inspecteer stop_reason.
Als dit tool_use is: voer de hulpmiddelen uit, voeg de resultaten toe aan messages en herhaal de lus.
Als dit end_turn is: stop — de taak is klaar.

Dit is iteratieve besluitvorming in actie. Bij elke ronde ziet het model de nieuwe resultaten van de hulpmiddelen en kiest het de volgende stap. De gespreksgeschiedenis groeit totdat Claude besluit dat het klaar is.

while True:
    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        messages=messages,
        tools=TOOLS,
    )
    messages.append({"role": "assistant", "content": response.content})

    if response.stop_reason == "end_turn":
        break  # the model says it is done

    if response.stop_reason == "tool_use":
        results = run_requested_tools(response.content)
        messages.append({"role": "user", "content": results})

Beëindig op stop_reason, niet op tekst

Dit is een van de meest getoetste beslissingen op het examen. Je beëindigt de lus op stop_reason — nooit door in de tekst van het model te zoeken naar woorden als 'klaar', 'voltooid' of 'af'.

Waarom? Tekst parseren is kwetsbaar: het model kan zeggen 'ik ben nog niet klaar' of 'bijna klaar', waarna een eenvoudige trefwoordmatch te vroeg stopt of eindeloos blijft herhalen. Het veld stop_reason is het expliciete, gestructureerde signaal van het model — het laat geen ruimte voor verwarring.

Tekst parseren op signalen dat iets voltooid is, is een klassiek anti-patroon. Als je dit in een antwoordoptie ziet, is die bijna altijd fout.

Iteratielimieten zijn een veiligheidsnet

Het is verstandig om het aantal iteraties van de lus te begrenzen — maar begrijp de rol ervan. Een iteratielimiet is een veiligheidsnet dat op hol geslagen lussen opvangt. Het is niet de primaire manier waarop de lus eindigt.

Het primaire stopmechanisme is altijd stop_reason == "end_turn". De limiet treedt alleen in werking als er iets misgaat en het model nooit tot een oplossing komt.

Een willekeurige limiet, bijvoorbeeld 'altijd stoppen na 3 beurten', gebruiken als belangrijkste besturingslogica is een anti-patroon. Laat het model de leiding nemen en houd de limiet als vangnet achter de hand.

MAX_TURNS = 10  # safety net, not the primary exit

for turn in range(MAX_TURNS):
    response = client.messages.create(
        model="claude-opus-4-8", max_tokens=1024,
        messages=messages, tools=TOOLS,
    )
    messages.append({"role": "assistant", "content": response.content})
    if response.stop_reason == "end_turn":
        break  # PRIMARY exit — the model decided
    handle_tool_use(response)
else:
    escalate("Loop hit the safety cap without converging.")

Garanties horen in code

Beslissingen van modellen zijn krachtig maar probabilistisch — bij sturing door een prompt zijn ze ongeveer 90% betrouwbaar. Voor alles met financiële, juridische of veiligheidsgevolgen is dat niet genoeg.

Wanneer je een garantie van 100% nodig hebt, gebruik je deterministische code in plaats van instructies in een prompt:

Een hook kan een actie die beleid schendt blokkeren voordat deze wordt uitgevoerd (bijvoorbeeld een terugbetaling van meer dan $500).
Een programmatic precondition kan vereisen dat de identiteit van een klant is geverifieerd voordat een hulpmiddel voor terugbetalingen wordt uitgevoerd.

Prompts sturen; code garandeert. Weten welke je moet gebruiken is een kerntaak van een architect.

def process_refund(order_id, amount, verified_customer_id):
    # Deterministic precondition — a prompt cannot guarantee this
    if verified_customer_id is None:
        raise PermissionError("Identity must be verified before refunds.")
    if amount > 500:
        return escalate_to_human(order_id, amount)  # hook-style hard rule
    return issue_refund(order_id, amount)

De keuze van hulpmiddelen bepaalt de autonomie

Met tool_choice kun je per verzoek instellen hoeveel vrijheid het model heeft:

"auto" — Claude beslist of het in tekst antwoordt of een hulpmiddel aanroept. Dit is de standaard en de meest agentische optie.
"any" — Claude moet een hulpmiddel aanroepen. Handig wanneer je gestructureerde uitvoer wilt afdwingen.
{"type": "tool", "name": "X"} — dwing één specifiek hulpmiddel af.

Een agentisch systeem draait normaal op "auto": het model heeft de vrijheid nodig om te beslissen wanneer het handelt en wanneer het klaar is. Hulpmiddelen bij elke beurt afdwingen zou het natuurlijke signaal end_turn verstoren.

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=messages,
    tools=TOOLS,
    tool_choice={"type": "auto"},  # let the model choose to act or finish
)

Van één agent naar meerdere

Zodra één agentische lus werkt, kun je dezelfde ideeën opschalen. Een systeem met meerdere agents gebruikt een hub-en-spaakstructuur: een coördinator splitst de taak op, delegeert werk aan subagents en voegt hun resultaten samen.

Voor het examen is één regel cruciaal: subagents nemen de gespreksgeschiedenis van de coördinator niet over. De context van elke subagent moet expliciet in diens prompt worden meegegeven. Er is geen gedeeld geheugen tussen hen.

Elke subagent draait nog steeds zijn eigen autonome, iteratieve lus waarin hulpmiddelen worden gebruikt — het bouwblok dat je net hebt geleerd, samengesteld op grotere schaal.

Korte controle: de lus beëindigen

Een architect bouwt een Claude-agent die hulpmiddelen aanroept om ondersteuningstickets op te lossen. Hoe moet de lus bepalen wanneer de agent klaar is met een verzoek?

Beantwoord dit in de interactieve les

Samenvatting: de bouwblokken van agentische systemen

Je hebt nu de basis van elke Claude-agent:

Autonomie — het model bepaalt het pad; je code voert het uit. Gebruik hardgecodeerde logica alleen voor garanties.
Gebruik van hulpmiddelen — beschrijvingen bepalen de selectie; houd het bij 4-5 gerichte hulpmiddelen per agent.
Iteratie — de lus voert uit: verzoek → stop_reason inspecteren → hulpmiddelen uitvoeren → herhalen.
Beëindig op stop_reason (end_turn), nooit door tekst te parseren. Iteratielimieten zijn alleen een veiligheidsnet.
De status is van jou — het model bewaart niets; stuur bij elke beurt de volledige geschiedenis.

Als je deze principes beheerst, kun je redeneren over elke agent op het examen — met één agent of met meerdere agents in een hub-en-spaakstructuur.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 26
Lessen: 104

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Wat een systeem agentisch maakt” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Wat een systeem agentisch maakt”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.

Wat leer ik in “Wat een systeem agentisch maakt”?

Autonomie, toolgebruik en iteratieve besluitvorming Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Claude Architect te beginnen?

Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Wat een systeem agentisch maakt”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Claude Architect?

Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Wat een systeem agentisch maakt
Modelgestuurde versus hardgecodeerde beslissingen
Wanneer u een agent gebruikt
Overzicht van de agentische lus

← Terug naar Claude Architect