Claude 2026 : API, Tool Use, MCP, Structured Output et agents IA

1. Pourquoi une liste de features plus longue fragilise la prod

De fin 2025 à 2026, Anthropic a intégré « appeler des outils », « brancher MCP » et « émettre du JSON Schema » sur le chemin principal Messages : output_config.format a remplacé le beta output_format ; les outils peuvent définir strict: true pour que l’échantillonnage contraint par grammaire garde des arguments valides ; le MCP distant peut monter dans la même requête via mcp_servers plus type: "mcp_toolset". La doc est claire. L’ingénierie fusionne encore trois rôles en un :

• Prose lisible par un humain et JSON ingestible par une machine dans un même blob de texte sans schéma ;
• Scripts locaux, SaaS et outils MCP en écriture aplatis dans un seul tableau tools que le modèle choisit ;
• Un « agent » défini comme « répéter le même tour utilisateur 20 fois » sans max d’étapes ni audit des tool_use.

Les démos passent ; les tickets s’emplissent de JSONDecodeError, d’enums incorrects et de serveurs MCP traités comme un shell universel. L’API Claude ne « manque pas de features ». Entrée, exécution et contexte n’ont jamais été séparés. Si l’agent doit lancer xcodebuild, l’exécution atterrit aussi sur du vrai matériel Mac — le même problème d’ops qu’un runner macOS auto-hébergé pour GitHub Actions, pas un problème de prompt.

2. Ce qu’est chaque couche (What)

2.1 Claude API — entrée de conversation, pas un produit agent

L’API Claude (Messages) est l’entrée qui rattache modèle, messages, prompt système, cache et facturation à votre système. Elle n’exécute pas les outils à votre place et ne garantit pas json.loads. Le chat completion est un usage valide. Dès qu’un service aval écrit en base, ouvre un ticket ou déclenche la CI, vous empilez les couches suivantes. Demandez-vous d’abord : cet appel est-il consommé par un humain ou par un parseur ?

2.2 Tool Use — un plan d’exécution que vous possédez

Tool Use permet au modèle d’émettre des blocs tool_use ; votre serveur les exécute et renvoie tool_result. À utiliser pour les implémentations que vous maîtrisez : inventaire, tickets, scripts de dépôt. En prod 2026, activez le strict tool use sur la définition : strict: true plus input_schema passent par le même pipeline de grammaire que les structured outputs, ce qui réduit les crashs du type « chaîne 2 au lieu d’un nombre ». Le coût : le schéma doit tenir dans le sous-ensemble JSON Schema supporté par Anthropic.

2.3 Connecteur MCP — plan d’outils distant, pas un autre SDK

Le connecteur MCP Messages déclare des serveurs distants (URL, OAuth) et un mcp_toolset pour activer tous les outils, une allowlist ou une denylist. Il résout la découverte et le transport : pas besoin d’écrire à la main du JSON d’outil Anthropic pour chaque SaaS. Ce n’est pas une sécurité automatique — un MCP fichiers ou shell exige encore une passerelle ou une allowlist. Le « pourquoi USB » du protocole et le « comment accrocher un serveur à l’API » de cette page se complètent, ce ne sont pas des doublons.

2.4 Structured Output — contexte pour les parseurs, pas la voix pour les lecteurs

Structured Output utilise output_config.format avec json_schema pour que le bloc texte du modèle soit du JSON valide. À utiliser pour l’extraction de champs, les objets de rapport, les contrats du service suivant. C’est orthogonal à Tool Use : JSON seul, outils stricts seuls, ou les deux. Ça ne remplace pas les appels d’outil — du joli JSON ne déclenche jamais de HTTP à votre place.

2.5 Agent IA — politique de boucle, pas un cinquième produit API

Un agent IA ici, c’est : le modèle choisit un outil → vous exécutez → les résultats reviennent → jusqu’à l’arrêt. Les conditions d’arrêt sont les vôtres : tours max, noms d’outils interdits, budget, confirmation humaine. La boucle peut être Tool Use seul ou mixée avec MCP. Structured Output convient pour la remise finale. Du « full auto » sans plafond de boucle, c’est du retry sans borne.

3. Comparaison centrale (How Compare)

4. Comment choisir (Decision)

Fixez d’abord le consommateur et les effets de bord, puis choisissez les couches. La matrice se découpe selon que vous mutez l’état externe ou non.

5. Stacks recommandés

Empilez les capacités. Ne cherchez pas un seul nom de produit.

• Scripts perso / bots internes : Claude API + 2–5 outils maison + strict. Passez MCP quand la surface de secrets le vaut.
• Agent support SaaS en croissance : outils d’écriture maison (tickets) + MCP connaissance en lecture seule + Structured Output en fin pour la QA.
• Plateforme / multi-équipes : passerelle MCP pour auth et rate limits ; orchestrateur pour étapes et budget ; les écritures de facturation restent en Tool Use maison.
• Agent build macOS / iOS : n’exposez que « mettre en file un job sur un runner nommé » ; le vrai xcodebuild tourne sur un Mac cloud stable, pas un SSH ad hoc piloté par le modèle.

Face aux Skills IDE : l’agent API possède les boucles avec effets de bord système ; Claude Code Skills possèdent les SOP dev dans le dépôt. Les deux peuvent mentionner MCP ; ne partagez pas une même table de credentials pour l’écriture.

6. Pièges

• « MCP = on peut abandonner Tool Use » → chemins d’écriture, conformité et idempotence restent maison et audités.
• « Structured Output = un agent » → ça ne contraint que le JSON texte ; pas d’effets de bord.
• « strict marche sur n’importe quel JSON Schema imbriqué » → restez dans le sous-ensemble documenté ; oneOf profond / clés dynamiques échouent.
• Traiter le beta legacy output_format et output_config comme deux produits → compatibilité de transition seulement ; le nouveau code utilise output_config.format.
• « Des modèles plus forts n’ont pas besoin de max d’étapes » → les étapes, c’est de l’argent et un rayon d’explosion, pas du QI.
• Copier-coller strict dans chaque schéma client MCP → retirez les champs réservés à l’API sur les canaux MCP génériques.

7. Sept étapes de déploiement

1. Inventorier les effets de bord : lectures, écritures internes, déclencheurs CI, prod. Un tableau d’outils par classe.
2. Livrer un outil maison : input_schema minimal + strict: true ; prouver tool_use → exécution → tool_result.
3. Séparer livraison humaine vs machine : contrats machine via Structured Output ou appel parse dédié.
4. Brancher MCP lecture seule : mcp_servers + allowlist ; gardez l’écriture en maison.
5. Encapsuler la boucle : max N étapes, timeouts, budget tokens, rejeter les noms d’outils non déclarés.
6. Observer : journaliser nom d’outil, hash des args, latence, échecs de schéma — pas seulement le texte assistant final.
7. Épingler l’exécution lourde : jobs macOS sur Mac cloud / runners auto-hébergés ; l’agent émet un id de job, pas un shell de laptop.

# 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": "Open a high-severity ticket: build timed out"}]
}

Épinglez les IDs de modèle à votre console et à la vue d’ensemble Tool Use. Avant la prod, vérifiez que output_config et strict ne dépendent plus d’en-têtes beta résiduels dans votre version du SDK.

8. Conclusion

Claude API répond à la façon dont le modèle rejoint le système. Tool Use répond à l’exécution maison et aux arguments garantis. MCP répond à la découverte distante et à l’élagage. Structured Output répond au contrat parseur. L’agent IA répond à quand la boucle s’arrête et à quelle taille fait le rayon d’explosion. Ce ne sont pas cinq gros titres « nouvelle feature » en parallèle. C’est une entrée, deux plans d’exécution, un format de livraison et une orchestration que vous devez écrire. Tracez d’abord les frontières d’effets de bord ; activez ensuite MCP et la boucle pour que les démos survivent à la prod.

Pour aller plus loin : Structured outputs · Strict tool use · Connecteur MCP · Intro protocole MCP