Claude Tool Use: Wie ich meinen KI-Agenten echte Fähigkeiten gebe

Inhaltsverzeichnis

Aktualisiert Juli 2026.

TL;DR: Claude Tool Use ermöglicht es Ihrem Agenten, Aktionen auszuführen — nicht nur Text zu generieren. Sie definieren Tools als JSON-Schemata, Claude entscheidet, wann er sie aufruft, und Ihr Code führt die reale Aktion aus. Die Schleife hat drei Schritte: Nachricht senden → tool_use-Block empfangen → ausführen und Ergebnis zurückgeben. Ich habe dies in 15+ Produktions-Agenten auf Cloudflare Workers eingesetzt. Der Fehler liegt fast nie bei der KI — sondern bei uneindeutigen Tool-Ergebnissen.

[Praxisbericht] Ich betreibe 30+ KI-Agenten im Produktionsbetrieb für eine Unternehmensberatung und Pickleland, eine Pickleball-Anlage in Pflugerville, TX. Etwa die Hälfte davon verwendet Tool Use — die Claude-API-Funktion, mit der das Modell Funktionen aufrufen kann, die Ihr Code definiert. Hier ist das Muster, auf das ich nach dem Produktionseinsatz und dem Iterieren konvergiert bin.

Warum Tool Use verändert, was ein Agent leisten kann

Ohne Tools kann ein Agent nur Text generieren. Das ist nützlich für Zusammenfassungen, Entwürfe und Klassifizierungen — aber das ist nicht das, was die meisten Geschäftsautomatisierungen wirklich brauchen. Geschäftsautomatisierungen müssen Informationen nachschlagen, in Datenbanken schreiben, APIs aufrufen, Nachrichten senden.

Tool Use ist die Methode, mit der Sie Claude diesen Zugriff geben. Sie definieren eine Reihe von Tools als JSON-Schemata. Claude liest die Schemata, entscheidet, welches Tool mit welchen Argumenten aufgerufen werden soll, und gibt einen strukturierten tool_use-Inhaltsblock zurück. Ihr Code führt die eigentliche Funktion aus. Claude erhält das Ergebnis und entscheidet, was als Nächstes zu tun ist — einschließlich des Aufrufs eines weiteren Tools oder der Erzeugung einer abschließenden Textantwort.

Der Schlüssel: Claude entscheidet, wann und ob ein Tool aufgerufen wird. Sie definieren die Fähigkeiten. Das Modell schlussfolgert, wann es sie einsetzt.

Wie der API-Ablauf funktioniert

Die Tool-Use-Schleife hat drei Schritte. Sie durchlaufen diese Schleife je nach Anzahl der Tool-Aufrufe des Modells einmal oder mehrmals.

Schritt 1: Senden Sie Ihre Nachricht mit definierten Tools

const response = await anthropic.messages.create({
  model: "claude-haiku-4-5-20251001",
  max_tokens: 1024,
  tools: [
    {
      name: "check_court_availability",
      description:
        "Check if a court is available at a given date, time, and duration",
      input_schema: {
        type: "object",
        properties: {
          date: {
            type: "string",
            description: "Date in YYYY-MM-DD format",
          },
          time: {
            type: "string",
            description: "Start time in HH:MM format (24h)",
          },
          duration_minutes: {
            type: "number",
            description: "Duration of the booking in minutes",
          },
        },
        required: ["date", "time", "duration_minutes"],
      },
    },
  ],
  messages: [
    {
      role: "user",
      content: "Is a court available tomorrow at 2pm for 90 minutes?",
    },
  ],
});

Schritt 2: Prüfen Sie, ob Claude ein Tool aufrufen möchte

if (response.stop_reason === "tool_use") {
  const toolUseBlock = response.content.find(
    (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
  );

  if (!toolUseBlock) throw new Error("Expected tool_use block");

  // Run your actual function
  const toolResult = await checkCourtAvailability(
    toolUseBlock.input as CourtAvailabilityInput
  );

  // Step 3: Return the result to Claude
  const finalResponse = await anthropic.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 1024,
    tools: [
      /* same tools as before */
    ],
    messages: [
      {
        role: "user",
        content: "Is a court available tomorrow at 2pm for 90 minutes?",
      },
      { role: "assistant", content: response.content },
      {
        role: "user",
        content: [
          {
            type: "tool_result",
            tool_use_id: toolUseBlock.id,
            content: JSON.stringify(toolResult),
          },
        ],
      },
    ],
  });

  // finalResponse.content now has the text answer
}

Das ist das gesamte Muster. Drei API-Interaktionen pro Tool-Aufruf: Tools definieren → tool_use-Block empfangen → Ergebnis zurückgeben.

Echtes Beispiel: der Pickleland-Verfügbarkeitsprüfer

Pickleland ist eine Pickleball-Anlage. Wir erhalten Buchungsanfragen auf Facebook Messenger, in Kommentaren und über einen Chatbot. Die Frage ist fast immer eine Variation von „Seid ihr am Samstag um 15 Uhr geöffnet?” oder „Kann ich einen Court für meine 8-köpfige Gruppe buchen?”

Der Verfügbarkeitsprüfer-Agent verwendet Tool Use, um das eigentliche Buchungssystem in Echtzeit abzufragen, anstatt eine vorgefertigte Antwort zu geben.

Hier ist der vollständige Agent — vereinfacht, aber produktionsgetreu:

// workers/availability-checker.ts
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

const AVAILABILITY_TOOLS: Anthropic.Tool[] = [
  {
    name: "check_availability",
    description:
      "Check court availability for a date, time, and group size. Returns available courts and their prices.",
    input_schema: {
      type: "object",
      properties: {
        date: { type: "string", description: "YYYY-MM-DD" },
        start_time: { type: "string", description: "HH:MM (24h)" },
        duration_minutes: { type: "number" },
        players: { type: "number", description: "Number of players" },
      },
      required: ["date", "start_time", "duration_minutes"],
    },
  },
  {
    name: "get_pricing",
    description:
      "Get current pricing for court rentals and open play sessions",
    input_schema: {
      type: "object",
      properties: {
        session_type: {
          type: "string",
          enum: ["court_rental", "open_play", "clinics"],
        },
      },
      required: ["session_type"],
    },
  },
];

export async function handleInquiry(
  userMessage: string,
  env: Env
): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];

  // Agentic loop — keep going until stop_reason is "end_turn"
  while (true) {
    const response = await anthropic.messages.create({
      model: "claude-haiku-4-5-20251001",
      max_tokens: 512,
      system:
        "You are the booking assistant for Pickleland, a pickleball facility in Pflugerville, TX. " +
        "Use the tools to look up real availability and pricing. Never make up availability or prices. " +
        "If the customer wants to book, direct them to pickleland.com/book.",
      tools: AVAILABILITY_TOOLS,
      messages,
    });

    // Push the assistant's response into message history
    messages.push({ role: "assistant", content: response.content });

    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find(
        (b): b is Anthropic.TextBlock => b.type === "text"
      );
      return (
        textBlock?.text ??
        "I wasn't able to answer that — please call us directly."
      );
    }

    if (response.stop_reason === "tool_use") {
      // Process ALL tool calls in this response (Claude can request multiple at once)
      const toolResults: Anthropic.ToolResultBlockParam[] = [];

      for (const block of response.content) {
        if (block.type !== "tool_use") continue;

        let result: unknown;

        switch (block.name) {
          case "check_availability":
            result = await checkAvailability(
              block.input as AvailabilityInput,
              env
            );
            break;
          case "get_pricing":
            result = await getPricing(block.input as PricingInput, env);
            break;
          default:
            result = { error: `Unknown tool: ${block.name}` };
        }

        toolResults.push({
          type: "tool_result",
          tool_use_id: block.id,
          content: JSON.stringify(result),
        });
      }

      // Return all tool results in a single user message
      messages.push({ role: "user", content: toolResults });
    }
  }
}

Zwei Dinge möchte ich hier hervorheben.

Die agentische Schleife. Ich mache weiter, bis stop_reason === "end_turn". Claude könnte check_availability aufrufen, entscheiden, dass er auch Preise braucht, get_pricing aufrufen, und dann die endgültige Antwort erzeugen — das sind drei API-Aufrufe für eine einzige Benutzernachricht. Die Schleife verarbeitet dies ohne spezielle Logik.

Mehrere Tool-Aufrufe pro Runde. Claude kann mehrere tool_use-Blöcke in einer einzigen Antwort zurückgeben. Ich verarbeite sie alle und gebe alle Ergebnisse in einer einzigen user-Nachricht zurück. Wenn Sie sie einzeln verarbeiten und zurückgeben, unterbrechen Sie den Gesprächsfluss und verschwenden Tokens.

Echtes Beispiel: der Lead-Recherche-Agent

Meine Beratungsmarke verwendet einen Recherche-Agenten, der eingehende Leads anreichert, bevor ich mit ihnen spreche. Wenn jemand das Kontaktformular ausfüllt, recherchiert der Agent das Unternehmen und extrahiert, was ich vor dem Anruf wissen muss.

Die Tool-Definitionen dafür beinhalten ein Schreib-Tool — und hier wird das Muster interessant:

const RESEARCH_TOOLS: Anthropic.Tool[] = [
  {
    name: "search_company",
    description: "Search for information about a company",
    input_schema: {
      type: "object",
      properties: {
        company_name: { type: "string" },
        website: { type: "string", description: "Company website if known" },
      },
      required: ["company_name"],
    },
  },
  {
    name: "save_research",
    description:
      "Save the completed research summary to Airtable. Call this when all research is complete.",
    input_schema: {
      type: "object",
      properties: {
        company_summary: { type: "string" },
        estimated_size: {
          type: "string",
          enum: ["1-10", "11-50", "51-200", "200+"],
        },
        likely_use_case: { type: "string" },
        priority: { type: "string", enum: ["high", "medium", "low"] },
        notes: { type: "string" },
      },
      required: [
        "company_summary",
        "estimated_size",
        "likely_use_case",
        "priority",
      ],
    },
  },
];

save_research ist das, was ich ein Schreib-Tool nenne — sein Zweck ist nicht, Informationen zu holen, sondern Claudes Ausgabe in strukturierter Form in einer Datenbank zu speichern. Ich verwende dieses Muster anstatt zu versuchen, JSON aus einer Textantwort zu parsen. Claude weiß, wann die Recherche abgeschlossen ist, und ruft save_research mit korrekt typisierten Feldern auf. Ich schreibe nie einen Parser.

Das ist die sauberste Anwendung von Tool Use: Definieren Sie ein Tool für eine „finale Aktion” mit dem genauen Schema, das Sie wollen, und Claude liefert strukturierte Ausgabe über den Tool-Aufruf. Kein Text-Parsing, keine Regex, keine JSONSchema-Validierung von Freitext-Ausgaben.

Ein Tool vs. viele

Der Instinkt beim Start mit Tool Use ist, ein riesiges Tool zu bauen, das alles tut. Widerstehen Sie dem. Kleine, fokussierte Tools sind aus drei Gründen besser:

1. Claude schlussfolgert besser über kleine Tools. Ein Tool namens get_court_status, das Verfügbarkeit zurückgibt, ist leichter für das Modell zu verarbeiten als ein Tool namens manage_facility, das einen mode-Parameter nimmt und intern verzweigt.

2. Kleine Tools sind einfacher zu testen. Jedes Tool ist eine TypeScript-Funktion, die Sie unabhängig vom LLM unit-testen können. Das sollten Sie — Tool-Fehler sind in einem aktiven Gespräch schwer zu debuggen.

3. Claude kann kleine Tools parallelisieren. Wenn zwei Tools nicht voneinander abhängen, kann Claude sie in derselben Antwort aufrufen, und Sie verarbeiten sie parallel. Das funktioniert nur, wenn die Tools wirklich unabhängig sind.

Die Ausnahme: Tools, die Zugang zu viel gemeinsamem internen Zustand benötigen. Wenn die Funktion 10 Variablen aus derselben Datenquelle braucht, schlägt ein Tool mit einem umfangreicheren Schema 10 Tools, die jeweils separat auf die Datenbank zugreifen.

Meine Faustregel: Beginnen Sie mit einem Tool pro eigenständiger Fähigkeit. Fusionieren Sie Tools nur, wenn Sie sehen, dass Claude sie bei jeder Anfrage zusammen aufruft.

Kostenimplikationen

Tool Use fügt Tokens hinzu. Jede Tool-Definition geht in den System-Prompt-Kontext. Jeder tool_use- und tool_result-Block verbraucht Tokens im Gesprächsverlauf. Für eine agentenbasierte Multi-Runden-Schleife summiert sich das schnell.

Für den Pickleland-Verfügbarkeitsprüfer führt ein typisches Gespräch insgesamt 3–4 API-Aufrufe durch (erste Nachricht + 1–2 Tool-Aufrufe + Abschlussantwort), jeder verarbeitet 600–900 Tokens. Zu Haiku-Preisen kostet das unter 0,001 $ pro Anfrage. Wie ich im Beitrag zur KI-Agenten-Kostenrechnung erkläre, verarbeitet Haiku gut definierte Tool-Aufrufe zuverlässig und ist 10× günstiger als Sonnet für dasselbe Token-Volumen.

Der Lead-Recherche-Agent läuft auf Sonnet, weil die Urteilsentscheidungen — einen Lead priorisieren, die Eignung einschätzen — mehr Reasoning-Kapazität erfordern, als Haiku bei offenen Eingaben zuverlässig liefert. Die Rechnung stimmt trotzdem, weil er selten läuft (einige Male pro Woche, nicht tausende pro Tag). Die Modellwahl folgt der Aufgabenkomplexität, nicht persönlicher Vorliebe.

Der Fehler, über den niemand spricht

Der häufigste Fehler, den ich beim Tool Use in der Produktion sehe, ist nicht Claude, der das falsche Tool aufruft. Es ist das Tool, das etwas zurückgibt, über das Claude nicht klar schlussfolgern kann.

Wenn Ihr Tool ein rohes Datenbankobjekt mit 40 Feldern zurückgibt, wird Claude verwirrt, welche Felder wichtig sind. Wenn Ihr Tool eine Ausnahme wirft (die als Worker-Absturz erscheint statt als Tool-Ergebnis), bricht die Schleife still ab. Wenn Ihr Tool null zurückgibt, wenn es „keine Ergebnisse” meint, weiß Claude nicht, ob er erneut versuchen oder aufgeben soll.

Drei Regeln für Tool-Ergebnisse:

Geben Sie knappe, explizite Ergebnisse zurück. { available: true, courts: ["Court 3", "Court 5"], price_per_hour: 20 } — nicht die vollständige Datenbankzeile.

Fangen Sie Fehler innerhalb der Tool-Funktion ab und geben Sie sie als strukturierte Ergebnisse zurück. { error: "booking system timeout", retry: true } — keine geworfene Ausnahme, die den Worker zum Absturz bringt.

Machen Sie „keine Ergebnisse” explizit. { available: false, next_available: "2026-07-23T14:00:00Z" } — nicht null oder ein leeres Array ohne Kontext.

Claude schlussfolgert viel besser über klare Signale als über mehrdeutige Rückgabewerte. Jede Stunde, die ich mit dem Debuggen von Tool Use in der Produktion verbracht habe, betraf unklare Ergebnisse, nicht das Reasoning des Modells.

Das Fazit des Operators

Tool Use ist die Funktion, die Claude von einem Text-Generator in einen Operator verwandelt. Definieren Sie fokussierte Tools mit klaren Eingabe-Schemata. Verarbeiten Sie alle tool_use-Blöcke in einer einzigen Antwort an das Modell. Führen Sie die agentische Schleife aus, bis stop_reason === "end_turn". Geben Sie saubere, knappe Ergebnisse aus Ihren Tool-Funktionen zurück — keine rohen Datenobjekte, keine geworfenen Ausnahmen, keine mehrdeutigen Nulls.

Das Modell übernimmt das Reasoning. Ihr Code übernimmt die realen Aktionen. Halten Sie diese beiden Aufgaben klar getrennt, und die Architektur bleibt wartbar, auch wenn Sie Tools hinzufügen.

Wenn Sie Ihren ersten Tool-Use-Agenten bauen, beginnen Sie mit dem Verfügbarkeitsprüfer-Muster oben — ein Tool, ein Zweck, eine agentische Schleife. Deployen Sie das. Dann fügen Sie das zweite Tool hinzu.

Verwandt: Der Agent-Stack, den ich für 30+ Produktions-Agenten verwende · Haiku vs. Sonnet: die Kostenrechnung für Agenten-Aufgaben · Event-gesteuerte vs. geplante Agenten: welches Muster für welche Aufgabe

Sie bauen einen Tool-Use-Agenten und kommen nicht weiter? Kontaktieren Sie mich — ich entwerfe und baue Produktions-Agenten-Architekturen für Operator-Teams.

FAQ

Funktioniert Claude Tool Use mit allen Modellen?

Ja — Tool Use wird von allen aktuellen Claude-Modellen unterstützt. Claude Haiku verarbeitet klar definierte Tools mit klaren Schemata zuverlässig und ist die günstigste Option für aufgabenintensive Typen mit hohem Volumen. Sonnet verarbeitet mehrdeutigere oder offenere Tool-Aufruf-Entscheidungen besser. Beginnen Sie mit Haiku; steigen Sie auf, wenn die Ausgabequalität unzureichend ist.

Was ist der Unterschied zwischen Claude Tool Use und OpenAI Function Calling?

Mechanisch identisch. OpenAI hat „function calling” geprägt; Anthropic nennt es „tool use”. In beiden Fällen: Sie definieren JSON-Schemata, das Modell gibt strukturierte Aufrufe zurück, Ihr Code führt die Funktion aus. Die API-Form unterscheidet sich, aber das Konzept ist dasselbe.

Kann Claude mehrere Tools in einer einzigen Antwort aufrufen?

Ja. Claude kann mehrere tool_use-Blöcke in einer einzigen assistant-Antwort zurückgeben. Verarbeiten Sie alle und geben Sie alle Ergebnisse in einer einzigen user-Nachricht zurück. Sehen Sie das agentische Schleifen-Muster im Pickleland-Beispiel oben — die for-Schleife über response.content behandelt dies korrekt.

Wie viele Tools sollte ich pro Agent definieren?

Ich bleibe unter 8–10 Tools pro Agent. Darüber hinaus habe ich gesehen, dass Claude gelegentlich beim ersten Versuch das falsche Tool auswählt, was Tokens in einer Korrekturschleife verschwendet. Wenn Sie mehr als 10 Fähigkeiten benötigen, teilen Sie den Agenten in mehrere Agenten mit spezialisierten Tool-Sets auf, anstatt einen Agenten zu bauen, der alles weiß.

Sollte ich Tool Use für strukturierte Ausgaben verwenden?

Ja — das save_research-Schreib-Tool-Muster ist sauberer, als Claude zu bitten, JSON in einem Textblock zurückzugeben und es dann zu parsen. Definieren Sie ein Tool für eine „finale Aktion” mit dem genauen Schema, das Sie wollen. Claude ruft es mit korrekt typisierten Feldern auf, wenn es fertig ist. Kein Parser notwendig.