Wat een agent eigenlijk is

Je hebt API-aanroepen gedaan, maar een enkele aanroep retourneert slechts één antwoord. Als je een workflow wilt automatiseren, moet Claude handelen, naar het resultaat kijken, beslissen wat volgt, en doorgaan. Dit patroon is wat mensen bedoelen met agentic workflows.

Een agent is een autonome versie van Claude, die beide zijden van de berichtenlus zonder een mens ertussenin uitvoert. Een agent ontvangt een taak, kiest een tool, en voert code in een lus uit totdat Claude besluit dat de taak klaar is.

De eenvoudigste manier om een agentlus te implementeren ziet er als volgt uit:

Stuur een bericht naar Claude met beschikbare tools.
Claude reageert met ofwel een definitief antwoord ofwel een verzoek om een tool die je hebt gedefinieerd te gebruiken.
Je code voert die tool uit.
Je stuurt het resultaat terug naar Claude.
Herhaal totdat de stop reason end_turn is.

Denk eraan als een gesprek waarbij de beurten afwisselen: de gebruiker begint, de agent roept een tool aan, de tool retourneert een resultaat, en de agent gaat door totdat het een antwoord heeft.

Een minimaal werkend voorbeeld

Om deze lus van begin tot eind uit te voeren zonder een database of UI erbij te slepen, verbinden we een nep-tool genaamd get_weather en vragen Claude wat je vandaag in Austin moet dragen. Claude kan het weer niet zelf weten, dus het moet de tool aanroepen, het resultaat lezen, en je dan een antwoord geven.

Hier is het hele script:

import anthropic

client = anthropic. Anthropic()

tools = [ { "name": "get_weather", "description": "Get the current weather for a city. ", "input_schema": { "type": "object", "properties": { "city": { "type": "string", "description": "The city to get weather for", } }, "required": ["city"], }, } ]

def run_tool(name, tool_input): if name == "get_weather": return f"Weather in {tool_input['city']}: 95F, sunny" raise ValueError(f"Unknown tool: {name}")

messages = [ {"role": "user", "content": "What should I wear in Austin today? "} ]

while True: response = client. messages. create( model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages, )

if response. stop_reason == "end_turn":

for block in response. content: if block. type == "text": print(block. text) break

if response. stop_reason == "tool_use":

tool_results = [] for block in response. content: if block. type == "tool_use": result = run_tool(block. name, block. input) tool_results. append( { "type": "tool_result", "tool_use_id": block. id, "content": result, } )

messages. append({"role": "assistant", "content": response. content}) messages. append({"role": "user", "content": tool_results})

Drie dingen om op te merken:

De tools array vertelt Claude wat beschikbaar is: een naam, een beschrijving, en een JSON schema voor de invoer.
run_tool is gewoon een hardcoded lookup. In een echte app zou dit je database, een API, wat dan ook aanroepen.
De lus is de agentlus. Elke iteratie stuurt de berichten naar Claude en schakelt op basis van de stop reason van het antwoord. Op end_turn is Claude klaar — print de uiteindelijke tekst en break. Op tool_use, zoek de tool use blokken, voer elk uit, push het antwoord van de assistent en je tool resultaten terug in messages, en loop opnieuw zodat Claude kan antwoorden.

Het uitvoeren

Wanneer je het script uitvoert, zie je twee beurten:

Beurt één: de stop reason is tool_use. Claude vraagt get_weather voor Austin aan, en je code retourneert de temperatuur en omstandigheden.
Beurt twee: de stop reason is end_turn, en Claude vertelt je iets lichts en ademends te dragen.

Terminal output van de agentlus: beurt 1 stopt met tool_use en roept get_weather voor Austin aan, vervolgens stopt beurt 2 met end_turn en print Claude zijn uiteindelijke kledingaanbevelingen

Twee API-aanroepen, één tool-uitvoering, één definitief antwoord. Dat is de hele lus. Alles wat je met de Claude API bouwt zal vergelijkbaar zijn met dit.

Dezelfde lus in productie

In een echte omgeving drijft dezelfde lus iets als een auto-review endpoint: een compliance agent die een structureel rapport leest, relevante bouwcodes via een tool opzoekt, en risicoevindingen één voor één terug naar de database schrijft terwijl het werkt.

Een compliance review dashboard met geüploade structurele rapporten, elk met een Run auto-review knop die de agent start

De vorm van de lus is identiek aan wat je zojuist hebt uitgevoerd. De verschillen zijn:

Echte tools in plaats van een mock weervoorspelling.
Resultaten streamen terug naar de UI als server-sent events.
Bevindingen worden opgeslagen in een risk-finding tabel.

Het review trace van een draaiende compliance agent: tientallen tool calls die de bouwcode bibliotheek doorzoeken en specifieke codesecties opzoeken terwijl de lus itereert

Samenvatting

Een agent is Claude in een lus: observeren, beslissen, handelen, herhalen.
De lus is eenvoudig: berichten met tools sturen, elke tool die Claude aanvraagt uitvoeren, het resultaat terugvoeren, en stoppen wanneer de stop reason end_turn is.
Jij bezit de lus en de tools. Claude bezit de redenering.
Dezelfde lusvorm schaalt van een mock weerDemo tot een production compliance agent — alleen de tools en leidingen veranderen.
Wanneer je de lus niet wilt bezitten, voeren managed agents deze exacte lus voor je uit op Anthropic's infrastructuur.