AI Development

OpenAI DevDay 2026 Predictions: What Changes for Structured Outputs, Function Calling, and AI Agents?

JSONSort Published 2026-09-02 Updated 2026-09-02 About 14 min read

OpenAI DevDay 2026 is on September 29 at Fort Mason in San Francisco. The keynote is livestreamed; sessions cover APIs, agents, and production patterns. The product list is still embargoed, but the platform path is clear: Structured Outputs make the model emit valid JSON, Function Calling lets it express call intent, and AI agents compose both into a runnable workflow. This article predicts those three layers from the public API trajectory since 2025, and the JSON Schema work you can do before the keynote.

Quick overview

Layer	Status as of 2026-09	Likely DevDay direction
Structured Outputs	`json_schema` + `strict` enforces schema fit	Richer Schema subset, incrementally valid streams, default on agent handoffs
Function Calling	`tools[]` / `tool_calls`; `arguments` still a string	Native JSON arguments, parallel + sequential plans, first-class MCP mapping
AI Agents	Responses API + Agents SDK; Assistants API retired on August 26	Typed handoffs, observable JSON traces, MCP / A2A interop

Predictions from the public API path—not the official agenda or a leak. The September 29 keynote is the source of truth.

When DevDay 2026 happens, and what we are predicting

The date is fixed: September 29, 2026, Fort Mason, San Francisco, one day. The keynote is free to stream; other sessions land on openai.com afterwards. In-person applications closed on July 10; invited tickets were $650. For the first time, the flagship is followed by DevDay Exchanges: Bengaluru October 16, Tokyo 20, Seoul 22, Berlin 26, Paris 28, London November 3, São Paulo 6, Mexico City 11.

The public page already lists APIs, agents, production patterns, and safety. Product names are still embargoed. So this piece only makes falsifiable predictions—each maps to a current pain, and you can score them after the keynote. No model-size or hardware rumors; only the JSON developers write every day.

The September 2026 baseline

Align on what already shipped, or last year's features get mistaken for this year's launch.

Structured Outputs (since August 2024): stricter than JSON mode—the model must match your JSON Schema. In the Responses API that is text.format; on tools it is strict: true.
Function Calling: inject tools[], receive tool_calls. arguments is still stringified JSON; the host must parse, then validate.
AI agents: production has converged on Responses API + Agents SDK. AgentKit from DevDay 2025 (Agent Builder, ChatKit, Connector Registry) remains the orchestration layer. The Assistants API retired on August 26, 2026.

Two ecosystem layers sit beside that: tool supply in MCP Tool Schema vs Function Calling, and agent interop in A2A Extensions. DevDay is unlikely to replace those open protocols; it is more likely to plug them into OpenAI's own call frame.

Prediction 1: Structured Outputs become the default pipe, not an opt-in

Structured Outputs already stop “looks like JSON, fails the schema” incidents. Friction left: a narrow Schema subset, streams that are invalid mid-token, and unstable refusal shapes. The likely DevDay move is to make Schema the default contract on agent pipelines.

A ticket-extraction schema looks like this:

{
  "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
  }
}

Expected changes, most to least likely:

A richer JSON Schema subset. oneOf, $ref, and limited recursion still break often. Exclusive branches such as refund | exchange | human need oneOf instead of a flattened enum.
Streaming Structured Outputs stay incrementally valid. UIs that render a table as tokens arrive die on half-closed JSON. A better contract: every closed field is immediately validatable.
Refusals and errors stay on-schema. Safety refusals often escape your object shape. Production needs refusal as legal JSON, not free text.
One schema across a model family. Teams already hop GPT-5 snapshots; “one schema, many snapshots” would shrink adapter code.

When you debug these schemas, confirm brackets in JSONSort formatting, then check required / additionalProperties against the JSON Schema tutorial. Do not upload model output that contains user data to a public JSON site.

Prediction 2: Function Calling becomes a plan, not a single call

Function Calling grew from one function to parallel tool_calls. The 2026 bottleneck is no longer “will it call a tool?”—it is wrong-tool selection at scale, double-encoded arguments, untyped tool results, and hand-written MCP mappings. DevDay is more likely to ship call plans + typed round-trips than another alias for tools.

A current tool definition still looks like this:

{
  "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
    }
  }
}

The predictions that matter:

arguments as a native JSON object (or object plus string). A second JSON.parse is a top production bug; the Responses API already has room to tighten this.
Parallel + sequential plans as first-class. Parallel calls exist; “lookup order, then refund” still lives in prompts or a home-grown state machine. A depends_on-style field would drop a layer of orchestration.
MCP tools appear directly in tools[]. Hosts stop rewriting inputSchema → parameters. That matches the earlier article: MCP supplies tools; the API layer expresses model intent.
Tool results also use Structured Outputs. role: tool is usually a free string; schema-fit results are what a downstream agent can consume.
Tool retrieval instead of stuffing 50 tools. Huge schemas are expensive and raise mis-calls. A likelier API: retrieve a shortlist, then give that list to the model.
strict: true becomes the default. New integrations should not have to remember a flag.

Prediction 3: Agents treat JSON contracts as runtime, not config

The 2025–2026 agent path is: leave Assistants, write agents, tools, handoffs, and guardrails as code on the Agents SDK. AgentKit still supplies a canvas, chat UI, and connectors. Industry reports say the visual Agent Builder may stop exports after November 30—confirm that against official notes, but the direction is clear: versioned code orchestration beats a canvas you cannot export.

What DevDay is likely to stress is not “another chatbot,” but typed handoffs:

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

Once that JSON is a first-class SDK object, routing no longer depends on the model mentioning “billing” in prose. Companion predictions:

Handoffs require output_type. A triage agent emits a classification object, then yields. That is Structured Outputs at work.
Traces and evals are JSON. Scores, cross-step traces, and regression sets become files you can diff—not console screenshots.
MCP and A2A show up on the same pipeline. MCP Servers supply tools; A2A dispatches across agents with extension headers. OpenAI is more likely to deepen a connector registry than invent a third interop protocol.
Long jobs resume from structured checkpoints. Computer-use and overnight batches need recoverable JSON state, not chat history alone.

How the three layers become one JSON pipe

Stacked, the conservative architecture for late 2026 is layers, not a winner-take-all:

JSON Schema is the single source of truth. Keep schemas/tools/*.json and schemas/handoffs/*.json in git.
Structured Outputs constrain the object the model returns to a user or a downstream agent.
Function Calling constrains call intent toward external systems; parameter schemas export from the same files.
The agent runtime routes on handoff JSON, executes on tool JSON, and reviews on trace JSON.
MCP / A2A handle cross-host supply and cross-agent negotiation. They do not replace the three layers above.

When versions drift, JSON Diff the schema that ran last week against the one the model refuses today. Many “the model got worse” incidents are one extra required field.

What to prepare now (do not wait for September 29)

Write tool parameters, handoff objects, and eval fixtures as JSON Schema—not as prose inside prompts.
New code goes through Responses API / Agents SDK only. Do not open Assistants threads.
Turn on strict: true per tool and validate example payloads in CI (ajv or similar).
Past ten tools, add routing or retrieval. Do not dump the whole catalog into one request.
Parse arguments as either a string or an object so a post-DevDay type change does not page the whole site.
Inspect secret or user-bearing tool payloads only locally: format, diff, zero upload.

Common pitfalls

Treating a prediction as a release note. Until September 29, discount second-hand “OpenAI will ship X” posts. Every claim here can fail on stage.
Collapsing Structured Outputs and Function Calling into one switch. One shapes what you say to a user or downstream agent; the other shapes what you call. Agents often enable both.
Assuming MCP dies at DevDay. Deeper connectors are likelier than a new inputSchema.
Canvas workflows with no export. If you still use a visual Builder, export nodes, prompts, and schemas to git first.
Ignoring double-encoded arguments. Until native objects land, this remains the top production fault.

FAQ

Is this the official agenda?

No. Date, venue, and topic areas come from the public event page. Product detail is a prediction from current API pain. The livestreamed keynote is primary source.

Will Structured Outputs replace Function Calling?

No. Structured Outputs shape the final object; Function Calling shapes tool calls. The 2026 pattern is stacking: the same Schema covers tool parameters and handoff objects.

Assistants is gone—what about old threads?

Move production to Responses API + Agents SDK. Export thread state, tool definitions, and output schemas, then rewrite orchestration in the SDK. Do not wait for a canvas to auto-translate.

No ticket—how do I follow along?

The keynote is free; sessions publish afterwards. Exchange-city applications run through September 17. For most teams, post-event docs beat a hallway question.

How should I debug tool and handoff JSON?

Format, validate, and diff in the browser with JSONSort. Do not paste secret-bearing tool responses onto a public JSON site.

Conclusion

DevDay 2026 is unlikely to invent another “JSON-shaped” format. The likelier outcome: Structured Outputs become the default contract, Function Calling becomes a plan with dependencies, and the agent runtime becomes a JSON state machine you can diff—wired more deeply into MCP and A2A. The highest-leverage move before the show is not guessing product names; it is collapsing schemas into a single source of truth in git. Score the keynote on September 29. Keep what matches, drop what does not. The JSON prep still pays off.