Was ist Function Calling 2026? So rufen OpenAI, Gemini und Claude APIs per JSON auf

Function Calling (Tool Calling) ist 2026 das Standardprotokoll für Agents: Modelle tun nicht mehr so, als riefen sie APIs in Prosa auf. Sie geben JSON unter einem vereinbarten Schema aus, und Ihr Code holt Wetter, fragt Datenbanken ab, ändert Dateien oder startet Tests. Der Unterschied ist nicht, wer besser plaudert, sondern ob Schema validiert, Ausführung auditiert und Seiteneffekte isoliert sind.

Stand 18. August 2026. Feldnamen in SDKs driften; die Schleife nicht: Anfrage → Ausführen → Rückspeisen. Werkzeuge, die die Platte ändern, gehören zu einem Agent-Dateisystem-Sandbox. Präferenzen über Sitzungen gehören in Memory, nicht in das nächste arguments-Blob.

Warum Freitext-Prompts nicht reichen (Why)

Früher: „bitte get_weather(city=Beijing) aufrufen“ plus Regex. Demos laufen; Produktion bricht an drei Stellen:

1. Instabiles Parsen — Höflichkeit, umgeordnete Argumente, fehlende Anführungszeichen; JSON.parse stirbt.
2. Keine Typen — Enums werden Freitext; Pflichtfelder fehlen; parallele Calls lassen sich nicht zuordnen.
3. Seiteneffekte im Chat — das Modell behauptet eine Löschung, die nie lief, oder Sie liefen und das Modell sah kein Ergebnis.

Function Calling lässt die Wahl beim Modell und die Ausführung in der Runtime. HTTP, SQL und Shell passieren nie im Modellprozess. Wie CI: eine Job, ein Workspace — Grenze vor Klugheit.

Drei Schichten (What)

„OpenAI tools verdrahtet“ ist keine Architektur. Mindestens drei Schichten:

Asymmetrische These: Vendor-APIs standardisieren den L1-JSON-Umschlag. L2-Autorisierung und L3-Prozessisolation machen Sie selbst. MCP ist Discovery und Session — keine automatische Sicherheit.

Die Schleife: Das Modell hält keine API-Keys; Geheimnisse nur in der Runtime.

┌──────────────┐     JSON tool request      ┌──────────────────┐
│  LLM API     │  ────────────────────────► │  Your runtime    │
│  (OpenAI /   │     name + arguments       │  (Agent loop)    │
│   Gemini /   │                            │                  │
│   Claude)    │  ◄──────────────────────── │  execute tool    │
└──────────────┘     tool result JSON       │  • HTTP APIs     │
                                            │  • DB / search   │
                                            │  • shell / MCP   │
                                            └────────┬─────────┘
                                                     │
                                                     ▼
                                            ┌──────────────────┐
                                            │ Policy + secrets │
                                            │ allowlist, audit │
                                            │ Cloud Mac / VPC  │
                                            └──────────────────┘

Vergleich: OpenAI vs Gemini vs Claude

2026 trennt nicht „unterstützt Function Calling“ (alle drei tun es), sondern String- vs Objekt-Argumente, parallele Zuordnung und Fehler-Rückschreiben. Gateways normalisieren auf ToolCall{name, id, args} und eine L2-Runtime.

So sieht das JSON aus (How)

Dasselbe get_weather. In Produktion Grenzen in die Description („nur öffentliches Wetter, nie persönlicher Standort“).

OpenAI: tools + tool_calls

Tools an die Anfrage hängen. Bei einem Call enthält die Assistant-Nachricht tool_calls. arguments ist stringifiziertes JSON — parsen, dann validieren.

{
  "model": "gpt-4.1",
  "messages": [{"role": "user", "content": "What's the weather in Beijing?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {"type": "string", "description": "City name"},
          "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
      }
    }
  }]
}

{
  "role": "assistant",
  "tool_calls": [{
    "id": "call_abc123",
    "type": "function",
    "function": {
      "name": "get_weather",
      "arguments": "{\"city\":\"Beijing\",\"unit\":\"celsius\"}"
    }
  }]
}

Danach role: tool (oder Responses-Äquivalent) mit passender tool_call_id und String-content.

Gemini: functionDeclarations + toolConfig

Deklarationen unter tools[].functionDeclarations. mode: AUTO, ANY, NONE — Produktschalter, keine Sandbox.

{
  "contents": [{"role": "user", "parts": [{"text": "What's the weather in Beijing?"}]}],
  "tools": [{
    "functionDeclarations": [{
      "name": "get_weather",
      "description": "Current weather for a city",
      "parameters": {
        "type": "OBJECT",
        "properties": {
          "city": {"type": "STRING"},
          "unit": {"type": "STRING", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
      }
    }]
  }],
  "toolConfig": {"functionCallingConfig": {"mode": "AUTO"}}
}

Modell: functionCall-Part; Sie: functionResponse. Feldnamen nicht mit OpenAI gleichsetzen.

Claude: tools + tool_use / tool_result

input_schema. Antwort ist ein Array von Content-Blöcken. input ist Objekt, Validierung bleibt Pflicht.

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "tools": [{
    "name": "get_weather",
    "description": "Current weather for a city",
    "input_schema": {
      "type": "object",
      "properties": {
        "city": {"type": "string"},
        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
      },
      "required": ["city"]
    }
  }],
  "messages": [{"role": "user", "content": "What's the weather in Beijing?"}]
}

{
  "role": "assistant",
  "content": [{
    "type": "tool_use",
    "id": "toolu_01XYZ",
    "name": "get_weather",
    "input": {"city": "Beijing", "unit": "celsius"}
  }]
}

{
  "role": "user",
  "content": [{
    "type": "tool_result",
    "tool_use_id": "toolu_01XYZ",
    "content": "{\"temp_c\": 28, \"condition\": \"clear\"}"
  }]
}

Claude Code und Cursor legen MCP drauf. Das Modell sieht weiter JSON-Schema-Tools. Transport ändert sich, die Schleife nicht.

Auswahlmatrix

Empfohlene Stacks

A — Solo, halber Tag: ein Modell, 1–3 Lesetools, JSON Schema ohne additionalProperties, Secrets in Env, Logs nur Hashes. Schreiben Sie die Tool-Beschreibungen so eng, dass das Modell weiß, wann es nicht rufen darf — das spart Round-Trips und Fehlschläge in der Parse-Schicht.

B — kleines Team: internes ToolCall, Timeouts und Caps je Tool, Writes auf Cloud-Mac-Sessions, Memory getrennt. Dieselbe Destroy-Disziplin wie Remote-Mac-Automatisierung. Fügen Sie eine Idempotenz-ID in schreibende Tools ein, damit parallele Retries nicht doppelt buchen. Halten Sie Audit-JSONL außerhalb des Workspace-Volumes, damit ein Destroy die Spur nicht löscht.

C — Enterprise: Katalog-Review, Schema als PR, MCP in VPC, kein unbeschränktes bash. Pflicht: Secret-Rotation unabhängig vom Prompt, und ein Break-Glass-Pfad, der Function Calling für destruktive Tools global auf NONE schaltet, ohne das Modell neu zu deployen.

Fallstricke

1. Glauben, das Modell authentifiziert — Keys in der Runtime.
2. OpenAI-arguments als Objekt behandeln — erst parsen.
3. Beschreibungen „mach alles“ — Über-Calls.
4. Parallele tool_calls ignorieren — Writes serialisieren.
5. Fehler schlucken — strukturierte Errors zurück.
6. MCP = Sicherheit — Home-Root ist volle Platte.

Rollout in 7 Schritten

1. Tool-Inventar (Seiteneffekt, Timeout, Residenz).
2. JSON Schema (required, enum, keine additionalProperties).
3. Minimale Schleife, ein Tool.
4. Validierung, Secret-Isolation, Audit.
5. Zweiter Vendor-Adapter als Beweis für das interne Modell.
6. Write-Tools sandboxen.
7. 7 Tage beobachten, häufige Fehlschemas verengen.

FAQ

Unterschied zu JSON mode?

JSON mode formt die Endantwort. Function Calling formt Zwischen-Tool-Requests und läuft oft über mehrere Turns nach der Ausführung.

Kann das Modell die Datenbank direkt abfragen?

Nein, außer die Runtime exponiert beliebiges SQL ohne Autorisierung. Standard: nur schema-gültige Parameter vorschlagen.

Ein Schema für drei Vendoren?

Kern-JSON-Schema teilen, Umschläge wrappen. Enums und Pflichtfelder regressionstesten; Strict-Modi sind nicht identisch.

Sind Claude-Code-Tools Function Calling?

Dieselbe Schleife; der Katalog kommt dynamisch von IDE/MCP statt eines handgeschriebenen tools-Arrays.

Tool-Ergebnisse ins Langzeitgedächtnis?

Roh-Payloads sind groß und flüchtig. Zusammenfassen in Memory. Siehe Hilfe.

Fazit

Function Calling 2026 ist schema-typisiertes RPC. Drei JSON-Dialekte, eine Grammatik: Modell schlägt vor, Runtime führt aus, Ergebnis kommt zurück. Sicherheit sitzt in L2-Validierung und isolierten Hosts. Wenn Sie nicht sagen können, wohin ein write_file jetzt fällt, keine Write-Tools anschließen. Lesende APIs können heute live. Code und Tests auf entsorgbare Cloud-Mac-Knoten — zuerst Preise.

Weiterlesen

• Agent-Dateisystem & Sandboxes →
• Self-Hosted vs SaaS Agent Memory →
• OpenClaw Cloud-Automatisierung →