Why do ChatGPT, Gemini, and Siri AI all need structured data?

In 2026 you can still read a fluent paragraph in a chat window. Hand that paragraph to a calendar, a ticket, billing, or the next agent step, and sentences are not enough. "Sometime Thursday morning," "the customer seems urgent," "book it for me" — a person can fill that in; a parser cannot. ChatGPT, Gemini, and Siri AI need structured data not because curly braces look good, but because they all have to go from "explain" to "execute." How flagships get picked: see 2026 AI model war. This piece only writes the contract layer that already ships in production.

Three products, the same gap

On the surface they are far apart. ChatGPT sells conversation and the Responses API. Gemini sells multimodality and GenerateContent. Siri AI sells "say this at the screen, the system does the work." The gap is the same: natural language has no types.

Miss a required key, write a boolean as "yes," write a date as "next Tuesday," and downstream writes regex, retries, and a human fallback. The three folded that problem into the same class of interface: hand over an object first, then allow a sentence beside it for people. Why the object picks JSON: the previous piece Why AI likes JSON already wrote that. This piece fills in: what needs structured data is not only the cloud model. It includes the system assistant and the agent runtime.

What structured data actually means

In speech, "structured" often gets said as "please return JSON." In production it has three layers. Mix them, and it feels like "the model sometimes obeys, sometimes does not."

1. Instance. One concrete object: this ticket, this event, this tool call. It has to parse.
2. Contract. What that object is allowed to look like: which keys are required, which enum values exist, whether numbers have bounds. The common writing of the contract is JSON Schema.
3. Loop. The agent reads the last object, picks the next tool, and hands over the next object. Without the first two layers, the third can only be watched by a person.

The three words in the title line up with those layers: JSON is the common writing of an instance, JSON Schema is the contract, an AI agent is the loop that cannot turn without the first two. Drop any layer, and the rest degrades into "please only return JSON" in the prompt — a 2024 demo, a 2026 debt.

JSON: the bus, not a taste

Structured data does not have to be JSON. Databases have rows, Protobuf has field numbers, Swift has types. The AI line still converges on JSON because four things hold at once:

1. Every runtime can parse it. Browser, Python, Swift, Go, cloud functions — failure is a syntax error, not "it feels off."
2. It can nest. Objects, arrays, booleans, numbers, null cover tool parameters and business documents.
3. Training is full of it. API responses, logs, application/json on the web — models have seen far more valid JSON than valid YAML or XML.
4. A Schema can watch it. The same instance can be model output and input to a validator, Zod, or OpenAPI.

YAML is brittle on indentation, XML tags are heavy, Markdown is for people. So ChatGPT tool parameters, Gemini's response_mime_type: application/json, MCP JSON-RPC, and Apple's docs saying "@Generable compiles to JSON Schema" — the bus is an object, and the most common on-the-wire writing is JSON. A common format is not "any curly braces." The rules stay: types locked, enums closed, required listed in full, additionalProperties: false.

JSON Schema: the contract, not an appendix

JSON alone, and the next hop is still gambling. The model can drop a key, write an amount as a string, invent a field your parser does not know. JSON Schema takes the gamble away:

• Shape. type, properties, items on arrays.
• Required. List required in full. Strict mode on all three wants it explicit; omit a name and you allowed a missing field.
• Close it. Status, priority, channel as enum. Free text only for sentences that actually display.
• Reject extra keys. additionalProperties: false. Otherwise the model will "helpfully" add an explanation field you never declared.

Schema has a second job: constrained decoding. Illegal tokens get blocked at sampling, not regretted after generation. ChatGPT Structured Outputs, Gemini's responseSchema, Apple's Guided Generation — all that. Definition and acceptance steps: Generate Structured Output from a sample.

AI agents: the loop cannot eat prose

A one-shot Q&A can skip the contract. An agent cannot. A production loop is usually: understand the goal → pick a tool or Intent → fill parameters → clarify if needed → execute → hand the result back as an object. The cloud path at DevDay: DevDay 2026 Agent. Siri / Shortcuts walk the same class of loop on the system bus; the tool name is just a domain Intent.

Every hop in the loop has to be catchable by a machine:

• Picking a tool is an enum, not a paragraph of "I plan to use the calendar." The name must line up with the registry.
• Filling parameters is JSON (or an object that maps to JSON). Missing starts_on, the calendar API will not guess.
• Reading the return is still an object. The next step wants event_id, status, not "I booked it for you."

MCP locked this layer as JSON-RPC: tool name, parameters, return value are all objects. This site's MCP Tool page is writing that contract. Evals want objects too — prose cannot auto-compare; JSON can show field drift vs type drift in JSON Diff. So an agent is not "a model that chats better." It is a state machine that only closes if structured data is there.

How each of the three "needs" it

What they need is the same object, not the same request body. Write the wrapper into the docs; leave the fields in a shared file.

1. ChatGPT: the Schema enters the decoder

The chat window is for people. The production path is the API. In Chat Completions, Structured Outputs hang on response_format, type json_schema, and production wants strict: true. The Responses API puts the same object on text.format. Paste old-guide fields onto the new interface and you often do not get a nice error — it just stops constraining the way you expected.

The agent side is another contract: a function's parameters are also JSON Schema. The model is not "talking about whether to book a callback"; it submits parameters that must validate. JSON Mode only guarantees the braces parse. Fine for a demo; do not leave it on write and billing paths. The SDK's .parse() takes another pass with Pydantic / Zod.

2. Gemini: mime type plus Schema

Gemini folds JSON Mode and Structured Output into one line: response_mime_type: application/json, then hang responseSchema / response_json_schema. It looks the most "Schema-native," and the subset is the narrowest: basic types, enum, format, bounds, required work; deep polymorphism, recursive $ref, trees that are too big or too deep — the docs say it may reject outright.

Tool declarations are Schema too. Multimodal in, object out is Gemini's most common production writing: an image or long audio into the model, out come ticket fields, not a description. High-volume Structured Output still often picks Gemini 3.8 Flash — see pick a model by task. Output cap is 64K; chunk long documents first.

3. Siri AI: the system bus wants objects too

Old Siri was a phrase table. New Siri (developer docs write Siri AI) eats a Schema. The app registers entities and actions as App Intents: calendar_createEvent receives title, start time, duration — not "book me tomorrow afternoon." "This" on screen has to bind to an entity too, or the referent cannot become a parameter. The user-confirm bit is a gate, not politeness.

On-device Foundation Models use another wrapper: add @Generable to a struct, the framework compiles the type to JSON Schema, then constrained sampling generates a Swift object. Day to day, developers touch types, not curly braces. When it hits logs, cross-device sync, or your own backend, the object still has to be catchable by a JSON parser and JSON Schema. Breakdown: What is Apple Intelligence.

What you can share is the fields: enums, required, booleans, date formats, additionalProperties: false. What you cannot share is the wrapper. Grow a first Schema from the same sample, then hook it to the three APIs and the system Intent.

One agent sample that can cross all three

This is not any vendor's private request body. It is the business object ChatGPT tool parameters, Gemini Structured Output, and a Siri calendar Intent should all line up on when an agent needs to book a customer callback. Enums as strings, duration as number, confirmed as boolean.

{
  "run_id": "agt-20260910-07",
  "surface": "siri",
  "step": "act",
  "intent": {
    "name": "schedule_callback",
    "domain": "calendar",
    "confirmed": false
  },
  "ticket": {
    "id": "TCK-8841",
    "priority": "high",
    "channel": "phone"
  },
  "slot": {
    "starts_on": "2026-09-11",
    "starts_at": "10:30",
    "duration_min": 20,
    "timezone": "Asia/Shanghai"
  },
  "customer": {
    "name": "Example Labs",
    "phone_last4": "4821"
  },
  "confidence": 0.84,
  "needs_confirmation": true
}

With this site's inference rules, that sample yields:

Once the sample is ready, open Structured Output to generate the OpenAI / Claude / Gemini wrappers, then review required and additionalProperties by hand. The same object can also become a tool via Function Calling or MCP Tool: the model is not "talking about a callback"; it is submitting one agent action that must validate. Mapped to Siri, intent.name lines up with the domain Schema, slot with calendar parameters, needs_confirmation with system confirmation.

How to accept it in JSON Toolbox

1. Paste the sample above into JSON Format and confirm it parses.
2. Generate a first draft with Structured Output or JSON → Schema. On-device @Generable does the same job at compile time, just in another language.
3. Take a second set of real output — the model wrote "Thursday" as a relative date, wrote priority as "a bit urgent" — to Schema validation. The first sample is always a bit too clean.
4. When you cut from ChatGPT to a Gemini or Siri trace, use JSON Diff to see whether a field dropped or a type drifted.
5. Convert to Zod when the frontend needs checks, and to OpenAPI 3.1 when you need API docs.

Everything stays in the browser and is never uploaded.

FAQ

Why do ChatGPT, Gemini, and Siri AI all need structured data?

Sentences work for people. Writing a calendar, calling a tool, or handing the result to the next agent hop requires a typed object. The three surfaces differ; a missing field, a drifted type, or an enum that flies off still stops the loop.

What is the difference between JSON and JSON Schema?

JSON is an instance: keys and values. JSON Schema is the contract: types, enum, required, additionalProperties. With only an instance, the next hop is gambling. With a Schema, you can constrain decoding and validate again.

Can an AI agent run without a Schema?

Demos can. Production loops cannot. An agent has to pick a tool, fill parameters, read the return value, and decide the next step. All three are objects. Prose cannot auto-diff, and it cannot write safely.

Can the three share one Schema?

The field contract can be shared. The wrapper cannot: OpenAI uses response_format or text.format, Gemini uses responseSchema, Siri uses App Intents or @Generable. Grow it from the same sample; do not hand-copy the fields three times.

Is Siri's structured data the same thing as ChatGPT's?

Same class of problem, not the same request body. ChatGPT / Gemini put JSON Schema in HTTP; Siri compiles a domain Schema and Swift types into objects. When it hits logs, evals, and your own backend, it still has to be catchable by JSON and JSON Schema.

Summary

ChatGPT, Gemini, and Siri AI need structured data because programs and agents have to catch the model — a good paragraph will not do. JSON is the bus, JSON Schema is the contract, the agent loop eats objects. The three wrappers differ: response_format / text.format, responseSchema, App Intents / @Generable. What they share is fields, types, required, and "no extra keys." What survives next week's model swap is the sample and the Schema, not "please return JSON" in a prompt. Grow the contract from one sample; validation, Zod, OpenAPI, and the Swift type you plan to map all follow it.

Related tools