Claude 2026 Features: API, Tool Use, MCP, Structured Output und AI Agents

1. Warum eine längere Feature-Liste Produktion fragiler macht

Von Ende 2025 bis 2026 hat Anthropic „Tools aufrufen“, „MCP anbinden“ und „JSON Schema ausgeben“ auf den Messages-Hauptpfad gebracht: output_config.format ersetzt das Beta-output_format; Tools können strict: true setzen, damit grammar-constrained Sampling gültige Argumente liefert; Remote-MCP fährt im gleichen Request über mcp_servers plus type: "mcp_toolset". Die Docs sind klar. In der Praxis kollabieren drei Aufgaben zu einer:

• Lesbarer Text und maschinenlesbares JSON in einem unschemaierten Textblock;
• Lokale Skripte, SaaS und schreibfähige MCP-Tools in einem flachen tools-Array für das Modell;
• „Agent“ als „denselben User-Turn 20-mal wiederholen“ ohne Max-Schritte und ohne tool_use-Audit.

Demos laufen; Tickets sammeln JSONDecodeError, falsche Enums und MCP-Server als Universal-Shell. Die Claude API fehlt nicht an Features. Einstieg, Ausführung und Kontext wurden nie getrennt. Wenn der Agent xcodebuild ausführen muss, landet die Ausführung auf echter Mac-Hardware—das gleiche Ops-Problem wie ein selbst gehosteter GitHub Actions macOS-Runner, kein Prompting-Problem.

2. Was jede Schicht ist (What)

2.1 Claude API — Gesprächseinstieg, kein Agent-Produkt

Die Claude API (Messages) ist der Einstieg, der Modell, Messages, System-Prompt, Cache und Abrechnung an Ihr System hängt. Sie führt keine Tools für Sie aus und garantiert kein json.loads. Chat-Completion ist legitim. Sobald ein Downstream-Service eine DB schreibt, Tickets öffnet oder CI startet, stapeln Sie die späteren Schichten. Zuerst fragen: Wird dieser Call von einem Menschen oder einem Parser verarbeitet?

2.2 Tool Use — eine Ausführungsebene, die Sie besitzen

Tool Use lässt das Modell tool_use-Blöcke erzeugen; Ihr Server führt sie aus und liefert tool_result. Für Implementierungen, die Sie besitzen: Inventar, Tickets, Repo-Skripte. Für Produktion 2026: strict tool use in der Definition—strict: true plus input_schema nutzen dieselbe Grammar-Pipeline wie Structured Outputs und reduzieren Crashes wie „String 2 statt Zahl“. Kosten: Das Schema muss in Anthropic’s unterstützte JSON-Schema-Teilmenge passen.

2.3 MCP-Connector — Remote-Tool-Ebene, kein weiteres SDK

Der Messages-MCP-Connector declariert Remote-Server (URL, OAuth) und ein mcp_toolset für alle Tools, Allowlist oder Denylist. Er löst Discovery und Transport: Sie schreiben kein Anthropic-Tool-JSON pro SaaS. Das ist nicht automatisch sicher—Filesystem- oder Shell-MCP braucht Gateway oder Allowlist. Protokoll „warum USB“ und diese Seite „Server an der API hängen“ ergänzen sich, sind keine Duplikate.

2.4 Structured Output — Kontext für Parser, nicht Stil für Leser

Structured Output nutzt output_config.format mit json_schema, damit der Textblock des Modells gültiges JSON ist. Für Feldextraktion, Report-Objekte, Verträge für den nächsten Service. Orthogonal zu Tool Use: nur JSON, nur strict Tools oder beides. Ersetzt keine Tool-Calls—schönes JSON startet kein HTTP für Sie.

2.5 AI Agent — Loop-Policy, kein fünftes API-Produkt

Ein AI Agent hier bedeutet: Modell wählt Tool → Sie führen aus → Ergebnisse zurück → bis Stop. Stop-Bedingungen sind Ihre: Max-Runden, verbotene Tool-Namen, Budget, Human Confirm. Der Loop kann nur Tool Use oder gemischt mit MCP sein. Structured Output passt zur finalen Übergabe. „Vollautomatisch“ ohne Loop-Cap ist unbegrenztes Retry.

3. Kernvergleich (How Compare)

4. Wie Sie auswählen (Decision)

Consumer und Side Effects zuerst festlegen, dann Schichten wählen. Die Matrix trennt nach externer Zustandsänderung.

5. Empfohlene Stacks

Features stapeln. Nicht nach einem einzigen Produktnamen suchen.

• Persönliche Skripte / interne Bots: Claude API + 2–5 eigene Tools + strict. MCP überspringen, bis die Secret-Fläche es rechtfertigt.
• Wachsender SaaS-Support-Agent: eigene Schreib-Tools (Tickets) + read-only MCP-Wissen + Structured Output am Ende für QA.
• Plattform / Multi-Team: MCP-Gateway für Auth und Rate Limits; Orchestrator für Steps und Budget; Billing-Schreiben bleibt eigenes Tool Use.
• macOS / iOS Build-Agent: nur „Job auf named Runner enqueue“ exponieren; echtes xcodebuild auf stabilem Cloud Mac, nicht modellgetriebenes Ad-hoc-SSH.

Vs. IDE Skills: Der API-Agent besitzt Loops mit System-Side Effects; Claude Code Skills besitzen Developer-SOPs im Repo. Beide können MCP erwähnen; eine Credential-Tabelle für Schreibzugriff teilen Sie nicht.

6. Fallstricke

• „MCP heißt, wir können Tool Use streichen“ → Schreibpfade, Compliance und Idempotenz bleiben eigen und auditiert.
• „Structured Output ist ein Agent“ → constrainiert nur Text-JSON; keine Side Effects.
• „strict funktioniert mit jedem nested JSON Schema“ → in der dokumentierten Teilmenge bleiben; tiefe oneOf / dynamische Keys scheitern.
• Legacy-Beta output_format und output_config als zwei Produkte → nur Übergangs-Kompatibilität; neuer Code nutzt output_config.format.
• „Stärkere Modelle brauchen keine Max Steps“ → Steps sind Geld und Blast Radius, nicht IQ.
• strict in jedes MCP-Client-Schema kopieren → API-only Felder auf generischen MCP-Kanälen entfernen.

7. Sieben Einführungsschritte

1. Side Effects inventarisieren: Read-Queries, interne Writes, CI-Trigger, Produktion. Eine Tool-Tabelle pro Klasse.
2. Ein eigenes Tool shippen: minimales input_schema + strict: true; tool_use → execute → tool_result beweisen.
3. Human vs. Machine Delivery trennen: Maschinenverträge via Structured Output oder dedizierter Parse-Call.
4. Read-only MCP anbinden: mcp_servers + Allowlist; Writes bleiben eigen.
5. Loop wrappen: Max N Steps, Timeouts, Token-Budget, undeclared Tool-Namen ablehnen.
6. Beobachten: Tool-Name, Arg-Hash, Latenz, Schema-Failures loggen—nicht nur finalen Assistant-Text.
7. Heavy Execution pinnen: macOS-Jobs auf Cloud Mac / Self-Hosted Runner; Agent liefert Job-ID, kein Laptop-Shell.

# Pseudocode — use the official SDK in production
POST /v1/messages
{
  "model": "claude-opus-4-6",
  "max_tokens": 2048,
  "tools": [{
    "name": "create_ticket",
    "strict": true,
    "input_schema": {
      "type": "object",
      "properties": {
        "title": {"type": "string"},
        "severity": {"type": "string", "enum": ["low","high"]}
      },
      "required": ["title","severity"],
      "additionalProperties": false
    }
  }],
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {
          "ticket_id": {"type": "string"},
          "next_action": {"type": "string"}
        },
        "required": ["ticket_id","next_action"],
        "additionalProperties": false
      }
    }
  },
  "messages": [{"role": "user", "content": "High-Severity-Ticket öffnen: Build-Timeout"}]
}

Model-IDs an Ihre Console und die Tool-Use-Übersicht pinnen. Vor Prod prüfen, dass output_config und strict in Ihrer SDK-Version nicht von übrigen Beta-Headern hängen.

8. Fazit

Claude API antwortet, wie das Modell ins System kommt. Tool Use antwortet auf eigene Ausführung und garantierte Args. MCP antwortet auf Remote-Discovery und Trimmen. Structured Output antwortet auf den Parser-Vertrag. Der AI Agent antwortet, wann der Loop stoppt und wie groß der Blast Radius ist. Das sind keine fünf parallelen „Neues Feature“-Headlines. Es sind ein Einstieg, zwei Ausführungsebenen, ein Delivery-Format und Orchestrierung, die Sie schreiben müssen. Side-Effect-Grenzen zuerst zeichnen; dann MCP und Loop aktivieren, damit Demos Produktion überstehen.

Weiterlesen: Structured outputs · Strict tool use · MCP connector · MCP-Protokoll-Einführung