AI Development

How Strong Is iPhone 18 AI? Apple Intelligence, Siri AI, Agents, and JSON

JSONSort Published 2026-09-09 Updated 2026-09-09 About 16 min read

The keynote poster says “smarter AI.” If you handle JSON, the question is not a parameter leaderboard. It is whether Siri will stuff an illegal object into an App Intent, whether the on-device model can emit an object that matches a Schema, and how much of a 32K window is left for tool results. This article splits Apple Intelligence, Siri AI, and AI agents, then lands on JSON.

Quick overview

Idea	One line	Where it lives
Apple Intelligence	An OS-level AI fabric — not a chat app	On-device model + Private Cloud Compute
Siri AI	A natural-language dispatcher for App Intents	Parameters must be a legal object, not prose
AI Agent	A multi-step tool loop: propose, run, read	LanguageModelSession + system tools
JSON / Schema	The runtime contract: fields, required, enums	@Generable → JSON Schema; Intent parameters

Remember the split: Apple Intelligence is the base, Siri is the dispatcher, the agent is the loop, JSON Schema is the diameter. Flatten them into “the phone got smarter” and the next hop will parse prose.

On event day, ask “how strong” the right way

Today is 9 September 2026, Apple's Surprise and Shine keynote (10 a.m. Pacific). This piece is written on event day: software claims follow WWDC 2026 / iOS 27 docs; hardware numbers that the keynote has not read out are tagged as media expectation or rumor.

If “how strong” only means parameters and a chat demo, Apple rarely wins. The real question is whether the system can turn a spoken sentence into a validatable object and hand it to your app.

Confirmed: WWDC docs and the public Foundation Models, App Intents, and Siri AI APIs.
Media: the devices expected on stage today (18 Pro / Pro Max, and a foldable iPhone).
Rumor: A20, 12 GB of RAM, and other figures Apple has not read out. Not shipping specs.

Do not wait for the keynote to finish before you write a Schema. Intent parameters and Guided Generation diameters have been in the developer docs since June.

From Apple Intelligence to iPhone 18: a timeline

2024-06 Confirmed
WWDC launches Apple Intelligence: a small on-device model plus Private Cloud Compute for writing, images, and notification summaries.
2025-06 Confirmed
The Foundation Models framework ships: @Generable / Guided Generation compile a Swift type into JSON Schema and constrain decoding.
2026-06 Confirmed
Siri is rebuilt on a new LLM; SiriKit is deprecated. App Intents schemas, View Annotations, and the Spotlight semantic index. A PCC server model at about 32K; a LanguageModel protocol; built-in barcode / OCR / Spotlight tools.
2026-09-09 Media
Surprise and Shine. Media expect iPhone 18 Pro / Pro Max and the first foldable iPhone (often called Ultra). The standard iPhone 18 may slip to spring 2027.
2026-09 Rumor
A20 / 2 nm and 12 GB on Pro models to host a larger on-device model. Until Apple reads the number, treat it as a hypothesis.

What Apple Intelligence is (it is not a chatbot)

Apple Intelligence is an OS fabric: which compute stays on device, which goes to Private Cloud Compute, and which capabilities Siri, Spotlight, and third-party apps can see. It is not “ChatGPT in the phone.”

By 2026, developers actually touch four pieces:

The on-device Foundation Model. WWDC 2026 rebuilt reasoning and tool calling, and added APIs for context use and token counts.
PrivateCloudComputeLanguageModel. About a 32K window, with reasoning levels, and no account or API key.
The LanguageModel protocol. One LanguageModelSession can sit on local, PCC, or a third-party / open-source backend.
System tools. BarcodeReaderTool, OCRTool, and Spotlight search — local RAG without standing up a server first.

“Strong” here means the default path never hits your own cloud, and the object is born on device or in PCC. The weak side is equally clear: the window is shorter than cloud flagships, and open-domain chat is not the design goal.

Comparing chat quality with the GPT-6 Astra guide, or parameter counts with why models keep getting bigger, asks the wrong question. Apple sells “a legal object into the app,” not “a longer paragraph.”

Where Siri AI is actually strong

Siri AI is not a cloud chat stuffed into the earpiece. WWDC 2026 built it to hear a sentence, fill App Intent parameters, optionally bind an on-screen entity, and let the host execute.

SiriKit is formally deprecated, with a two-to-three-year migration window. The new Siri cannot see an app that does not speak App Intents.

Intent schemas: system-defined domains (tasks, photos, communication). Siri does not need your frozen trigger phrases.
Entity schemas: content enters the Spotlight semantic index; personal context comes back with attribution.
View Annotations: mark the visible view as an entity so “send this one” has something to bind.
App Intents Testing: exercise Siri / Shortcuts / Spotlight on real system paths — no UI automation.

What the system hands you is not a paragraph. It is a parameter object. A LookupOrder hop looks about like this:

{
  "intent": "LookupOrder",
  "app": "com.example.shop",
  "source": "siri",
  "parameters": {
    "order_id": "A-1042"
  }
}

the AI Agent guide draws “the model proposes, the host runs” inside the full loop. Siri is a system dispatcher: it picks the Intent; your app is still the host. Missing fields, bad enums, extra keys — if the Intent is loose, the incident happens in your perform function, not in the demo reel.

A stronger Siri means better dispatch, on-screen awareness, and multi-step chains. It does not replace Schema-level checks on the parameters.

iPhone 18 hardware: what counts as stronger, what is still a rumor

Keynotes sell silicon and RAM because on-device models and tool calling eat both. iOS 27 software lands on a set of devices; not every phone that can run Apple Intelligence can run the heaviest local agent.

Confirmed: the iOS 27, Foundation Models, and Siri AI APIs were published at WWDC. Today's keynote confirms which devices ship with them.
Media: 18 Pro / Pro Max and a foldable this fall; the standard iPhone 18 may wait until spring 2027.
Rumor: a 2 nm A20 and 12 GB on Pro to host a larger local model. Until the keynote, treat the digits as a hypothesis.

For JSON work, hardware changes two things: whether the local window can hold your tool result, and whether an agent loop gets killed for memory.

When the window grows, the first move should not be dumping a whole API response into it. why models keep getting bigger already said it: parameters are capacity, tokens are the bill, the window is the bucket.

How an Apple-stack agent differs from a cloud agent

An agent on Apple's stack is not another cloud loop. It is a LanguageModelSession calling tools for several steps on device or in PCC. Those tools are often App Intents, or system Vision / Spotlight.

The skeleton matches cloud Function Calling: the model emits a name and arguments; the host parses, validates, executes, and puts the result back into the session.

The default catalog is Intents the system can see, not a long tools[] list you maintain alone.
Built-in vision / retrieval tools should still return objects, not screenshot prose.
PCC is about 32K — tighter than a typical 128K cloud window. Tool results eat it first.
Multi-step Intents can chain across apps. Each hop still needs legal parameters.

{
  "agent": "on_device",
  "step": 2,
  "tool": "LookupOrder",
  "arguments": {"order_id": "A-1042"},
  "result": {
    "order_id": "A-1042",
    "amount": 99.00,
    "status": "paid"
  },
  "next": "CreateRefund"
}

The blob above is a minimal local-loop state. the AI Agent guide explains the loop; MCP Tool Schema vs Function Calling shows another spelling of tool JSON. Apple writes the same dictionary as Swift types and App Intents.

Do not write Siri and agent as one word. Siri decides who to call. The agent, inside your session, decides which tool is next. Both pass an object as the baton.

JSON handling: Apple has been using Schema the whole time

Apple's Guided Generation docs already say it: every @Generable type is compiled into a JSON Schema and given to the model; that Schema counts against the context window. DynamicGenerationSchema / GenerationSchema are the same job at runtime.

So on-device “structured output” is not a new data format. It is a Swift projection of JSON Schema. Cloud Structured Outputs json_schema, MCP inputSchema, and App Intent parameters should all point at one source file.

One order-summary contract can feed @Generable, an Intent parameter, and the host validator:

{
  "$id": "https://example.com/schemas/order-summary.json",
  "type": "object",
  "properties": {
    "order_id": { "type": "string", "pattern": "^A-[0-9]{4,}$" },
    "amount": { "type": "number", "exclusiveMinimum": 0 },
    "status": { "type": "string", "enum": ["paid", "refunded", "pending"] }
  },
  "required": ["order_id", "amount", "status"],
  "additionalProperties": false
}

Keyword details are in the JSON Schema tutorial. On device the expensive part is the Schema itself: long descriptions and deep nesting consume the window. Keep property names short, add Guide(description:) only when it helps quality, and cap arrays with maximumCount.

{
  "session": "LanguageModelSession",
  "context_window": 32000,
  "spent": {
    "instructions": 800,
    "generable_schema": 1200,
    "tools": 2400,
    "app_intent_result": 18000
  },
  "reserved_output": 2000,
  "remaining": 9600
}

A 32K session is easy to fill with a tool result. Format locally with formatting, pull order_id / amount / status with JSONPath extract, minify, then give it to the model. why AI needs JSON Schema already said it: Schema is the diameter, not the sentence “please return JSON.”

The host still validates. Guided Generation stops illegal tokens; caps, auth, and a second parse still live in your app. Debug by JSON Diff against last week's passing object. Do not paste user-bearing responses onto a public site.

How the four layers stack

Flatten the four into “the phone got smarter” and you lose the jobs. Split them:

Apple Intelligence is the base: where the model runs, how large the window is, which system tools exist.
Siri AI is outbound dispatch: a sentence becomes an Intent name plus a parameter object.
The agent is the loop: multi-step tools inside a session; state must be legal JSON. JSON Schema is the shared diameter.

A comparison table, so they are not synonyms next time:

Layer	What the system is doing	Without a Schema
Apple Intelligence	Picks model, window, system tools	Tool results are prose; 32K fills first
Siri AI	Turns a sentence into an Intent call	Missing fields and bad enums hit perform() raw
AI Agent	Calls tools for several steps in a session	State is guessed from a chat log; the next hop binds the wrong object
JSON Schema	Does nothing — it is the ruler	If the ruler lives only in a Swift macro, the cloud and CI cannot measure

A refund often uses all four: Siri triages into your app, the agent calls LookupOrder, Guided Generation returns a summary, the host runs CreateRefund. AI agents and the JSON Schema workflow is about how the gates line up.

How to ship in 2026 (write the file, then watch the keynote)

Keep schemas/intents/, schemas/generable/, and schemas/state/ in the repo, each with a stable $id and a version.
Write the JSON Schema before @Generable or the Intent. The type is a projection, not the source.
Side effects (lookup, refund, mail) go through an Intent / tool. Extraction, triage, and handoff go through Guided Generation.
Default new objects to additionalProperties: false and an explicit enum. For extension, add a separate metadata.
Trim tool results before they enter the session. 32K is not an invitation to paste the whole order.
Inspect secrets and user fields only in the browser: formatting, JSON Diff, zero upload.

The directory can be thin. What matters is files before the demo. Keynotes will change the chip slogan. The diameter should stabilize first.

Common pitfalls

Treating Siri AI as ChatGPT. It dispatches Intents. It does not run your side effects, and it does not guarantee legal parameters.
Writing only @Generable in Swift, with no JSON source. The cloud API and the eval suite will drift.
Dumping a whole network response into LanguageModelSession. Debug fields eat the window first.
Testing wake phrases, not illegal parameters. The testing framework runs objects, not taglines.
Using a wide type: object to dodge design. An open object is no gate. Version it, or add explicit metadata.

FAQ

Has iPhone 18 AI already beaten GPT?

That is the wrong comparison. Cloud flagships still win long open-domain chat. Apple's strengths are on-device / PCC, no account, App Intents dispatch, and Guided Generation's object guarantee. Compare “does an illegal object enter the app,” not a parameter board.

Can I use iOS 27 Siri AI without an iPhone 18?

Which tier you get depends on the device and its RAM. The software was published at WWDC; the heaviest local models usually bind to that year's Pro hardware. The developer contract (Intent schemas, @Generable) is not tied to one SKU.

I already have @Generable. Do I still need a JSON Schema file?

Yes. @Generable is a projection. One source can feed cloud Structured Outputs, evals, and non-Swift clients. Edit only the Swift type and it will fork from the API contract by week three.

Siri already filled the parameters. Do I still validate?

Yes. Siri is the dispatcher. Missing fields, bad enums, and stale entities can still reach your perform(). Tighten the Intent declaration, then validate again before you execute.

How do I inspect on-device JSON locally?

Format it, check the Schema for a missing required or a bad enum, then Diff against the last version that passed. JSONSort does this in the browser and does not upload. Do not paste contacts or orders onto a public site.

Conclusion

How strong iPhone 18 AI is does not depend on how many nanometers today's keynote assigns the chip. For JSON work, strength is whether a sentence becomes a legal Intent parameter, the on-device model hands back an object that matches a Schema, and tool results do not blow the window first.

Apple Intelligence is the base, Siri is dispatch, the agent is the loop, Schema is the diameter. After the keynote, put schemas/order-summary.json in the repo first. Then decide which fields deserve 32K.