Développement IA

Prévisions OpenAI DevDay 2026 : Structured Outputs, Function Calling et agents IA

JSONSort Publié 2026-09-02 Mis à jour 2026-09-02 Environ 14 min

OpenAI DevDay 2026 a lieu le 29 septembre à Fort Mason, San Francisco. La keynote est diffusée en direct ; les sessions portent sur les API, les agents et les schémas de production. La liste produit reste sous embargo, mais les couches sont claires : Structured Outputs font émettre du JSON valide, Function Calling exprime l'intention d'appel, les agents IA composent les deux en flux exécutable. Cet article prévoit ces trois couches à partir de la trajectoire API publique depuis 2025, et le travail JSON Schema à faire avant la keynote.

Aperçu

Couche	État au 2026-09	Direction probable à DevDay
Structured Outputs	`json_schema` + `strict` imposent l'adéquation au schéma	sous-ensemble Schema plus riche, flux incrémentalement valides, défaut sur les handoffs
Function Calling	`tools[]` / `tool_calls` ; `arguments` reste une chaîne	arguments JSON natifs, plans parallèles + séquentiels, mapping MCP de premier plan
AI Agent	Responses API + Agents SDK ; Assistants API retiré le 26 août	handoffs typés, traces JSON observables, interop MCP / A2A

Prévisions issues de la trajectoire API publique — pas l'agenda officiel ni une fuite. La keynote du 29 septembre fait foi.

Quand a lieu DevDay 2026, et que prévoyons-nous

La date est fixe : 29 septembre 2026, Fort Mason, San Francisco, une journée. La keynote est gratuite en streaming ; les autres sessions arrivent ensuite sur openai.com. Les candidatures sur place ont clos le 10 juillet ; les invitations coûtaient 650 dollars. Pour la première fois, le navire amiral est suivi de DevDay Exchanges : Bengaluru 16 octobre, Tokyo 20, Séoul 22, Berlin 26, Paris 28, Londres 3 novembre, São Paulo 6, Mexico 11.

La page publique liste déjà API, agents, schémas de production et sécurité. Les noms de produits restent sous embargo. Ce texte ne pose que des prévisions falsifiables — chacune correspond à une douleur actuelle et se notera après la keynote. Pas de rumeurs de taille de modèle ni de matériel ; seulement le JSON que les développeurs écrivent chaque jour.

La base des trois couches en septembre 2026

Alignons d'abord ce qui est déjà livré, pour ne pas prendre une fonction de l'an dernier pour le lancement de cette année.

Structured Outputs (depuis août 2024) : plus strict que le JSON mode — la sortie doit coller à votre JSON Schema. Dans l'API Responses : text.format ; sur les outils : strict: true.
Function Calling : injecter tools[], recevoir tool_calls. arguments reste du JSON stringifié ; l'hôte parse puis valide.
Agents IA : la production a convergé vers Responses API + Agents SDK. AgentKit de DevDay 2025 (Agent Builder, ChatKit, Connector Registry) reste la couche d'orchestration. L'API Assistants a été retirée le 26 août 2026.

Deux couches d'écosystème s'y ajoutent : l'offre d'outils dans MCP Tool Schema vs Function Calling, l'interop agents dans A2A Extensions. DevDay a peu de chances de remplacer ces protocoles ouverts ; plus probable : les brancher sur le cadre d'appel OpenAI.

Prévision 1 : Structured Outputs devient le tuyau par défaut, pas une option

Structured Outputs arrête déjà les incidents « on dirait du JSON, ça rate le schéma ». Frictions restantes : sous-ensemble Schema étroit, flux invalides en cours de token, formes de refus instables. Le geste DevDay le plus probable : faire du Schema le contrat par défaut des pipelines d'agents.

Un schéma d'extraction de ticket ressemble à ceci :

{
  "name": "ticket_extract",
  "strict": true,
  "schema": {
    "type": "object",
    "properties": {
      "priority": { "type": "string", "enum": ["low", "medium", "high"] },
      "assignee": { "type": "string" },
      "summary": { "type": "string" },
      "labels": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["priority", "summary"],
    "additionalProperties": false
  }
}

Changements attendus, du plus au moins probable :

Un sous-ensemble JSON Schema plus riche. oneOf, $ref et la récursion limitée cassent encore. Les branches exclusives remboursement | échange | humain ont besoin de oneOf, pas d'un enum aplati.
Les flux Structured Outputs restent incrémentalement valides. Les interfaces qui dessinent un tableau au fil des tokens meurent sur un JSON à moitié fermé. Meilleur contrat : chaque champ fermé est tout de suite validable.
Refus et erreurs restent sur schéma. Les refus de sécurité sortent souvent de votre forme d'objet. La production a besoin d'un refusal JSON légal, pas d'un texte libre.
Un même schéma sur une famille de modèles. Les équipes sautent déjà entre instantanés GPT-5 ; « un schéma, plusieurs instantanés » réduirait le code d'adaptation.

Vérifiez les parenthèses dans le formatage JSONSort, puis required / additionalProperties dans le tutoriel JSON Schema. N'envoyez pas une sortie modèle contenant des données utilisateur sur un site JSON public.

Prévision 2 : Function Calling devient un plan, pas un appel unique

Function Calling est passé d'une fonction à des tool_calls parallèles. Le goulot 2026 n'est plus « va-t-il appeler un outil ? » mais le mauvais choix à grande échelle, les arguments doublement encodés, les résultats non typés et les mappings MCP écrits à la main. DevDay livrera plutôt des plans d'appel et des allers-retours typés qu'un nouvel alias de tools.

Une définition d'outil actuelle ressemble encore à ceci :

{
  "type": "function",
  "function": {
    "name": "create_ticket",
    "strict": true,
    "parameters": {
      "type": "object",
      "properties": {
        "title": { "type": "string" },
        "priority": { "type": "string", "enum": ["low", "medium", "high"] }
      },
      "required": ["title", "priority"],
      "additionalProperties": false
    }
  }
}

Les prévisions qui comptent :

arguments en objet JSON natif (ou objet plus chaîne). Un second JSON.parse est un bug de production fréquent ; l'API Responses peut déjà resserrer cela.
Plans parallèles + séquentiels de premier plan. Les appels parallèles existent ; « consulter la commande puis rembourser » vit encore dans les prompts ou une machine à états maison. Un champ du type depends_on enlèverait une couche d'orchestration.
Les outils MCP apparaissent directement dans tools[]. Les hôtes cessent de réécrire inputSchema → parameters. Cela rejoint l'article précédent : MCP fournit, la couche API exprime l'intention.
Les résultats d'outils passent aussi par Structured Outputs. role: tool est souvent une chaîne libre ; un agent en aval ne consomme que des résultats conformes au schéma.
Recherche d'outils plutôt que d'en fourrer 50. Les gros schémas coûtent cher et multiplient les mauvais appels. API plus probable : récupérer une short-list, puis la donner au modèle.
strict: true devient le défaut. Les nouvelles intégrations n'ont plus à retenir un drapeau.

Prévision 3 : les agents traitent les contrats JSON comme runtime, pas comme config

La voie agent 2025–2026 : quitter Assistants, écrire agents, outils, handoffs et garde-fous en code sur le Agents SDK. AgentKit fournit encore toile, UI de chat et connecteurs. Des reports indiquent que le Agent Builder visuel pourrait cesser les exports après le 30 novembre — à confirmer officiellement. La direction est claire : une orchestration versionnée en code bat une toile qu'on ne peut pas exporter.

Ce que DevDay insistera probablement n'est pas « un autre chatbot », mais des handoffs typés :

{
  "handoff": {
    "from": "triage",
    "to": "billing_agent",
    "output": {
      "intent": "refund",
      "order_id": "A-1042",
      "confidence": 0.91
    }
  }
}

Une fois ce JSON objet de premier plan du SDK, le routage ne dépend plus du mot « billing » dans la prose. Prévisions associées :

Les handoffs exigent output_type. Un agent de triage émet un objet de classification, puis cède. C'est Structured Outputs.
Traces et evals sont du JSON. Scores, traces inter-étapes et jeux de régression deviennent des fichiers diffables, pas des captures de console.
MCP et A2A apparaissent sur le même pipeline. Les serveurs MCP fournissent les outils ; A2A dispatch entre agents avec en-têtes d'extension. OpenAI approfondira plutôt un registre de connecteurs qu'un troisième protocole d'interop.
Les longs travaux reprennent sur des points de contrôle structurés. Computer use et lots de nuit ont besoin d'un état JSON recouvrable, pas seulement de l'historique de chat.

Comment les trois couches deviennent un tuyau JSON

Empilées, l'architecture prudente fin 2026 est des couches, pas un vainqueur unique :

JSON Schema est la source unique de vérité. Garder schemas/tools/*.json et schemas/handoffs/*.json dans git.
Structured Outputs contraignent l'objet renvoyé à un utilisateur ou à un agent aval.
Function Calling contraint l'intention d'appel vers les systèmes externes ; les schémas de paramètres s'exportent des mêmes fichiers.
Le runtime agent route sur le JSON de handoff, exécute sur le JSON d'outil, relit sur le JSON de trace.
MCP / A2A gèrent l'offre inter-hôtes et la négociation inter-agents. Ils ne remplacent pas les trois couches ci-dessus.

En cas de dérive, JSON Diff le schéma qui tournait la semaine dernière et celui que le modèle refuse aujourd'hui. Beaucoup de « le modèle a empiré » sont un champ required en trop.

Quoi préparer maintenant (ne pas attendre le 29 septembre)

Écrire paramètres d'outils, objets de handoff et fixtures d'eval en JSON Schema — pas en prose dans les prompts.
Le code neuf passe uniquement par Responses API / Agents SDK. Ne plus ouvrir de fils Assistants.
Activer strict: true par outil et valider des payloads d'exemple en CI (ajv ou équivalent).
Au-delà de dix outils, ajouter routage ou recherche. Ne pas verser tout le catalogue dans une requête.
Parser arguments comme chaîne ou objet pour qu'un changement de type après DevDay ne fasse pas tomber tout le site.
Inspecter les payloads d'outils secrets ou nominatifs uniquement en local : formater, diff, zéro envoi.

Pièges fréquents

Traiter une prévision comme une note de version. Jusqu'au 29 septembre, dépréciez les posts de seconde main « OpenAI va livrer X ». Chaque affirmation ici peut échouer sur scène.
Fusionner Structured Outputs et Function Calling en un interrupteur. L'un façonne ce qu'on dit à un utilisateur ou un agent aval ; l'autre ce qu'on appelle. Les agents activent souvent les deux.
Croire que MCP meurt à DevDay. Des connecteurs plus profonds sont plus plausibles qu'un nouvel inputSchema.
Flux toile sans export. Si vous utilisez encore un Builder visuel, exportez nœuds, prompts et schémas vers git d'abord.
Ignorer les arguments doublement encodés. Tant que les objets natifs n'arrivent pas, c'est le premier défaut de production.

FAQ

Est-ce l'agenda officiel ?

Non. Date, lieu et thèmes viennent de la page événement publique. Le détail produit est une prévision à partir des douleurs API actuelles. La source primaire est la keynote en direct.

Structured Outputs va-t-il remplacer Function Calling ?

Non. Structured Outputs façonne l'objet final ; Function Calling façonne les appels d'outils. Le motif 2026 est d'empiler : le même Schema couvre paramètres et handoffs.

Assistants a disparu — et les anciens fils ?

Passez la production sur Responses API + Agents SDK. Exportez d'abord l'état des fils, les définitions d'outils et les schémas de sortie, puis réécrivez l'orchestration dans le SDK. N'attendez pas qu'une toile traduise toute seule.

Pas de billet — comment suivre ?

La keynote est gratuite ; les sessions sont publiées ensuite. Les candidatures Exchange courent jusqu'au 17 septembre. Pour la plupart des équipes, la doc d'après-coup bat une question de couloir.

Comment déboguer le JSON d'outils et de handoffs ?

Formatez, validez et différez dans le navigateur avec JSONSort. Ne collez pas de réponses d'outils à secrets sur un site JSON public.

Conclusion

DevDay 2026 a peu de chances d'inventer un autre format « en forme de JSON ». L'issue plus probable : Structured Outputs devient le contrat par défaut, Function Calling devient un plan à dépendances, le runtime agent devient une machine à états JSON que l'on peut differ — branchée plus profondément à MCP et A2A. Le levier avant le show n'est pas de deviner des noms de produits ; c'est de ramener les schémas à une source unique de vérité dans git. Notez la keynote le 29 septembre. Gardez ce qui colle, jetez le reste. La préparation JSON reste utile.

Pour aller plus loin

OpenAI Structured Outputs Usage actuel de json_schema et strict
OpenAI Function Calling Forme des messages tools / tool_calls
MCP Tool Schema vs Function Calling Frontière de protocole du JSON d'outils
A2A Extensions et le protocole JSON Troisième couche d'interop multi-agents
Boîte à outils locale JSONSort Formater, valider, Diff
Tous les articles Plus de notes JSON et développement IA

Journal : 2026-09-02 première version (prévision avant DevDay)