Was ein Tool ist

Ihre bestehenden Workflows verlassen sich auf viele verschiedene Technologien — Projektmanagement-Software, Datenbanken, Dateien. Claude kann diese Dinge nicht einfach selbst überprüfen. Stattdessen verlässt er sich auf Tools, die Claude Zugriff auf externe Daten und Aktionen geben.

Einfach ausgedrückt ist ein Tool eine Funktion, die Sie definieren und Claude zur Verfügung stellen. Sie beschreiben, was es tut und welche Eingaben es benötigt, und Claude entscheidet, wann es aufgerufen werden soll.

Hier ist das Wichtigste zum Verinnerlichen: Claude führt das Tool nicht aus — Ihr Code tut es. Der Ablauf sieht so aus:

Claude fordert einen Tool-Aufruf an.
Ihr Code führt die Funktion aus.
Das Ergebnis geht zurück zu Claude, und es geht weiter.

Wie Tools definiert werden

Tools sind JSON-Schemas mit drei Teilen: einem Namen, einer Beschreibung und einem Input-Schema. Sie übergeben sie Claude im Request-Body als tools Array.

Die Beschreibung ist das, was Claude liest, um zu entscheiden, ob das Tool aufgerufen werden soll. Wenn Sie eine vage Beschreibung schreiben, erhalten Sie schlechte Tool-Nutzung. Dies ist der Hauptgrund, warum Agenten fehlschlagen oder die verfügbaren Tools nicht nutzen. Seien Sie spezifisch.

So sieht eine Tool-Definition aus:

{ "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"] } }

Was passiert also, wenn wir das verwenden? Sagen wir, wir senden einem Agenten einen Compliance-Bericht. In der ersten Runde kommt Claude mit stop_reason: "tool_use" zurück — das ist unser Signal. So sieht diese Antwort aus:

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

Unsere Schleife ruft lookup_building_code mit dem Parameter auf, den Claude angefordert hat, und speist das Ergebnis dann als Tool-Ergebnis zurück — eine Benutzernachricht mit einem tool_result Block, der an die ID des Tool-Aufrufs gebunden ist:

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

Und Claude geht weiter. An diesem Punkt können wir Tools weiterhin aufrufen und Ergebnisse an Claude zurückgeben, bis es hat, was es braucht.

Mehrere Tools: Claude die Wahl lassen

Ein Tool ist nützlich, aber der interessante Teil ist, Claude mehrere Tools zu geben und zu beobachten, wie es auswählt, welches es verwenden soll und in welcher Reihenfolge.

Stellen Sie sich dieses Szenario vor: Sie packen für eine dreitägige Reise nach Denver und möchten sowohl das heutige Wetter als auch die Vorhersage für die nächsten Tage. Also deklarieren wir zwei Tools statt einem:

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"] } } ];

Die Schleife ist identisch mit den Agent-Schleifen, die wir bereits gesehen haben. Das einzige neue Element ist eine runTool Funktion, die nach dem Tool-Namen dispatcht mit einer Switch-Anweisung — dieser Code-Block ist einfach der Ort, an dem Ihr Code tatsächlich ausgeführt wird:

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 }); }

Und das ist das ganze Muster. Möchten Sie ein drittes Tool? Fügen Sie es zum Array hinzu, fügen Sie einen Fall zum Switch hinzu, und Sie sind fertig.

Führen Sie das aus, und Sie werden sehen, dass Claude get_weather und dann get_forecast aufruft — manchmal in derselben Runde, manchmal nacheinander. Dann antwortet es: Schichten packen, heute Schneeflöckchen erwartet, die Woche über wärmer werdend.

Beachten Sie jetzt wie Claude gewählt hat. Es las die Beschreibungen, ordnete Ihren Prompt „heutiges Wetter" und „die nächsten Tage" zu und wählte das richtige Tool für jeden aus. Deshalb sind Ihre Tool-Beschreibungen wirklich wichtig.

Der Tool-Runner: Boilerplate überspringen

Sie haben wahrscheinlich bereits zwei rote Flaggen bei dem bemerkt, was wir gerade geschrieben haben:

Das ist viel Code für zwei einfache Lookups.
In einer echten Codebasis möchten Sie nicht JSON-Schemas von Hand schreiben für jede Funktion, die Sie haben. Es ist wie, Ihren Code zweimal zu schreiben.

Hier kommt der Tool-Runner ins Spiel. Er wird im Claude SDK für TypeScript, Python und Ruby ausgeliefert. Der Runner nimmt Ihre tatsächlichen Funktionen, liest die Typen und Dokumentation, um das Schema für Sie zu erstellen, und verwaltet die gesamte Tool-Use / Tool-Result-Schleife intern.

Ihr Code schrumpft auf: Tool beschreiben, Prompt senden, auf das Ergebnis warten. Hier ist die gleiche Zwei-Tool-Wetter-Demo über den Tool-Runner verdrahtet:

// 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();

Gleiches Szenario, ein Bruchteil des Codes:

Keine While-Schleife, kein Stop-Reason-Switch, kein manuelles Zurückdrücken von Tool-Ergebnissen in Nachrichten — der Runner verwaltet das alles.
Keine JSON-Schemas, also schreiben Sie Dinge nicht zweimal.
Die zwei Funktionen sind die gleichen Lookups, die wir vor einer Minute von Hand ausgeführt haben, nur einfaches TypeScript.
runner. untilDone() gibt die endgültige Assistenten-Nachricht zurück, sobald alles sich beruhigt hat.

Führen Sie es aus, und Sie erhalten die gleiche Antwort.

Echte Tools umhüllen Ihren bestehenden Code

In der Praxis würden Ihre Tools nicht hartcodierte Wetterdaten sein. Sie würden tatsächliche Funktionen umhüllen, die bereits in Ihrer Anwendung vorhanden sind.

Nehmen Sie einen Compliance-Review-Agenten: Seine Tools sind dünne Wrapper um lookup_building_code und search_building_code Funktionen, die bereits in der Codebasis vorhanden sind. Mit dem Tool-Runner übergeben Sie diese Funktionen direkt, und der Agent zitiert spezifische Code-Abschnitte in jedem Befund, den er schreibt — keine Schema-Schreiberei erforderlich:

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

Zusammenfassung

**Tools geben Claude Zugriff auf Ihre Systeme. ** Ein Tool ist eine Funktion, die Sie definieren und zur Verfügung stellen; Claude entscheidet, wann es aufgerufen werden soll, und Ihr Code führt es aus.
Tools sind JSON-Schemas mit einem Namen, einer Beschreibung und einem Input-Schema, die im Request als tools Array übergeben werden.
**Schreiben Sie spezifische Beschreibungen. ** Vage Beschreibungen sind der Hauptgrund, warum Agenten fehlschlagen.
stop_reason: "tool_use" ist Ihr Signal, das Tool auszuführen und das Ergebnis als Tool-Ergebnis zurückzugeben.
Für mehrere Tools, dispatchen Sie nach dem Tool-Namen. Ein Tool hinzuzufügen bedeutet, zum Array hinzuzufügen und einen Fall hinzuzufügen.
Der Tool-Runner des SDK (TypeScript, Python, Ruby) erstellt Schemas aus Ihren tatsächlichen Funktionen und verwaltet die ganze Schleife — oder Sie können die Schleife selbst ausführen.
Sie führen aus, oder Sie delegieren die Schleife. Am anderen Ende dieses Spektrums delegieren verwaltete Agenten den ganzen Agenten an Anthropic.