Wat een tool is

Uw bestaande workflows zijn afhankelijk van veel verschillende technologieën — projectmanagementsoftware, databases, bestanden. Claude kan deze dingen niet zelf controleren. In plaats daarvan vertrouwt het op tools, die Claude toegang geven tot externe gegevens en acties.

Simpel gezegd is een tool een functie die u definieert en aan Claude beschikbaar stelt. U beschrijft wat het doet en welke invoer het nodig heeft, en Claude besluit wanneer het moet worden aangeroepen.

Dit is het belangrijkste om te begrijpen: Claude voert de tool niet uit — uw code doet dat. De flow ziet er als volgt uit:

Claude vraagt een tool call aan.
Uw code voert de functie uit.
Het resultaat gaat terug naar Claude, en het gaat verder.

Hoe tools worden gedefinieerd

Tools zijn JSON schemas met drie onderdelen: een naam, een beschrijving en een input schema. U geeft ze aan Claude door in de request body als een tools array.

De beschrijving is wat Claude leest om te beslissen of de tool moet worden aangeroepen. Als u een vage beschrijving schrijft, krijgt u slecht tool gebruik. Dit is de nummer één reden waarom agents mislukken of de beschikbare tools niet gebruiken. Wees specifiek.

Dit is hoe een tool definitie eruit ziet:

{ "name": "lookup_building_code", "description": "Look up a specific building code section by its identifier. Returns the full text of that code section. ", "input_schema": { "type": "object", "properties": { "section": { "type": "string", "description": "The building code section to look up" } }, "required": ["section"] } }

Wat gebeurt er als we dit gebruiken? Stel dat we een agent een compliance rapport sturen. In de eerste beurt komt Claude terug met stop_reason: "tool_use" — dat is ons signaal. Dit is hoe die response eruit ziet:

An API response with stop_reason set to tool_use, containing a tool_use content block that names the tool and the input Claude wants to call it with

Onze loop roept lookup_building_code aan met de parameter die Claude aanvraagde, en voert het resultaat vervolgens in als een tool result — een user message met een tool_result blok gekoppeld aan de tool call's id:

A user message containing a tool_result block with the tool_use_id and the looked-up building code text as its content

En Claude gaat verder. Op dat moment kunnen we tools blijven aanroepen en resultaten aan Claude teruggeven totdat het heeft wat het nodig heeft.

Meerdere tools: Claude laten kiezen

Eén tool is nuttig, maar het interessante deel is Claude meerdere tools geven en kijken welke het kiest, in welke volgorde.

Stel je dit scenario voor: je pakt in voor een driedaagse reis naar Denver, en je wilt zowel het weer van vandaag als de voorspelling voor de komende dagen. Dus we declareren twee tools in plaats van één:

const tools = [ { name: "get_weather", description: "Get today's current weather for a city. ", input_schema: { type: "object", properties: { city: { type: "string", description: "The city to check" } }, required: ["city"] } }, { name: "get_forecast", description: "Get the weather forecast for the next few days for a city. ", input_schema: { type: "object", properties: { city: { type: "string", description: "The city to check" } }, required: ["city"] } } ];

De loop is identiek aan de agent loops die we al hebben gezien. Het enige nieuwe onderdeel is een runTool functie die dispatcht op de tool naam met een switch statement — dit blok code is gewoon waar uw code daadwerkelijk wordt uitgevoerd:

function runTool(name, input) { switch (name) { case "get_weather": return getWeather(input. city); case "get_forecast": return getForecast(input. city); } }

while (true) { const response = await client. messages. create({ model: "claude-sonnet-4-6", max_tokens: 1024, messages, tools, });

if (response. stop_reason ! == "tool_use") { // Claude is done — this is the final answer break; }

messages. push({ role: "assistant", content: response. content });

const toolResults = response. content filter((block) => block. type === "tool_use") .map((block) => ({ type: "tool_result", tool_use_id: block. id, content: runTool(block. name, block. input), }));

messages. push({ role: "user", content: toolResults }); }

En dat is het hele patroon. Wil je een derde tool? Voeg het toe aan de array, voeg een case toe aan de switch, en je bent klaar.

Voer dit uit, en je zult zien dat Claude get_weather aanroept en vervolgens get_forecast — soms in dezelfde beurt, soms achter elkaar. Vervolgens antwoordt het: pak lagen, verwacht vandaag sneeuwvlagen, opwarmend door de week.

Merk nu op hoe Claude koos. Het las de beschrijvingen, koppelde uw prompt aan "vandaag's weer" en "de komende dagen", en koos de juiste tool voor elk. Daarom zijn uw tool beschrijvingen echt belangrijk.

De tool runner: sla de boilerplate over

Je hebt waarschijnlijk al twee rode vlaggen opgemerkt met wat we zojuist hebben geschreven:

Dat is veel code voor twee eenvoudige lookups.
In een echte codebase wil je niet handmatig JSON schemas schrijven voor elke functie die je hebt. Het is alsof je je code twee keer schrijft.

Daar komt de tool runner om de hoek. Het wordt geleverd in de Claude SDK voor TypeScript, Python en Ruby. De runner neemt uw werkelijke functies, leest de types en docs om het schema voor u te bouwen, en verwerkt de hele tool use / tool result loop intern.

Uw code krimpt in tot: beschrijf de tool, stuur de prompt, wacht op het resultaat. Hier is dezelfde twee-tool weersdemo via de tool runner:

// The same two lookups we ran by hand — just plain TypeScript functions function getWeather(city: string) { // ... existing lookup }

function getForecast(city: string) { // ... existing lookup }

const runner = client. beta. messages. toolRunner({ model: "claude-sonnet-4-6", max_tokens: 1024, messages: [ { role: "user", content: "I'm packing for a three-day trip to Denver. What's the weather today and over the next few days? ", }, ], tools: [getWeather, getForecast], });

// Returns the final assistant message after all the tool ping-pong has settled const finalMessage = await runner. untilDone();

Hetzelfde scenario, een fractie van de code:

Geen while loop, geen stop reason switch, geen handmatig tool results terug in messages duwen — de runner verwerkt dat allemaal.
Geen JSON schemas, dus je schrijft dingen niet twee keer.
De twee functies zijn dezelfde lookups die we zojuist handmatig hebben uitgevoerd, gewoon plain TypeScript.
runner. untilDone() retourneert het uiteindelijke assistant message zodra alles is opgelost.

Voer het uit, en je krijgt hetzelfde antwoord.

Echte tools verpakken uw bestaande code

In werkelijkheid zouden uw tools niet hardcoded weergegevens zijn. Ze zouden werkelijke functies verpakken die al in uw applicatie bestaan.

Neem een compliance review agent: zijn tools zijn dunne wrappers rond lookup_building_code en search_building_code functies die al in de codebase bestaan. Met de tool runner geeft u die functies rechtstreeks door, en de agent citeert specifieke codesecties in elke bevinding die het schrijft — geen schema schrijven nodig:

A compliance review app showing a structural report alongside agent findings, each flagged item citing the specific building code section it checked

Samenvatting

**Tools geven Claude toegang tot uw systemen. ** Een tool is een functie die u definieert en beschikbaar stelt; Claude besluit wanneer het moet worden aangeroepen, en uw code voert het uit.
Tools zijn JSON schemas met een naam, een beschrijving en een input schema, doorgegeven in de request als een tools array.
**Schrijf specifieke beschrijvingen. ** Vage beschrijvingen zijn de nummer één reden waarom agents mislukken.
stop_reason: "tool_use" is uw signaal om de tool uit te voeren en het resultaat terug te voeren als een tool result.
Voor meerdere tools, dispatch op de tool naam. Een tool toevoegen betekent toevoegen aan de array en toevoegen van een case.
De SDK's tool runner (TypeScript, Python, Ruby) bouwt schemas uit uw werkelijke functies en verwerkt de hele loop — of u kunt de loop zelf uitvoeren.
U voert uit, of u delegeert de loop. Aan het andere uiteinde van dat spectrum delegeert managed agents de hele agent aan Anthropic.