AI Development

How Does iOS 27 Siri AI Call Apps? App Intents, Agents, JSON, and Automation

About 15 min read

The user says “look up A-1042.” For anyone who writes JSON, the question is not whether Siri can chat. It is whether that sentence becomes a legal Intent parameter and whether your app will run a side effect inside perform(). This guide splits App Intents, the AI agent, JSON data, and automated execution.

Before you read

Idea One line Where it lives
App Intents An action the app registers with the system perform() + a parameter object
Siri AI A dispatcher that fills an Intent from a sentence Dispatch only — no side effects
AI Agent A multi-step tool loop: propose, run, read LanguageModelSession + Intents
JSON Schema The runtime diameter for parameters and state A source file in the repo, not a Swift footnote

Remember the split: Siri delivers an object, App Intents are the door, the agent is the loop, Schema is the gate before execute. Flatten them into “Siri opened the app” and the next hop will parse prose.

Ask “call an app” the right way

It is September 2026. iOS 27 is shipping with the iPhone 18 line. The software diameter was set at WWDC 2026: Siri rebuilt on an LLM, SiriKit deprecated, third-party entry only through App Intents. how strong iPhone 18 AI is asked how strong the stack is. This piece asks one thing — how Siri calls your app.

If “call an app” means “open a UI and read a paragraph,” you will design the wrong thing. The system hears a sentence, picks an Intent name, fills a parameter object, and hands it to the host perform(). The UI may stay closed.

  • The user speaks natural language. The system must hand over an object.
  • Siri is the dispatcher. Lookups, refunds, and mail still run in your app.
  • Multi-step automation is not another chat window. It is several legal Intent calls.

So this guide follows the execute path: door → parameters → agent loop → Schema gate → Shortcuts / Spotlight. Every hop asks the same question: is the object legal?

The call path: how a sentence becomes perform()

Old Siri matched phrases and SiriKit. New Siri fills slots: “A-1042,” “refund this,” “refund if paid” become fields, then land on an Intent you already registered.

A successful call takes at least four hops:

  1. Hear. On-device or Private Cloud Compute turns speech / text into an intent — not a chat log.
  2. Pick who. The system chooses a name from the App Intents it can see. No registration, no turn.
  3. Fill. Entities, on-screen views, and the Spotlight index collapse into a parameter object.
  4. Host runs. Your perform() does the side effect and returns a structured result.

As JSON, a LookupOrder hop looks about like this:

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

source can be siri, shortcut, spotlight, or agent. Different doors, same object shape. Opening a UI is a presentation, not the call.

App Intents: the only door the new Siri can see

After WWDC 2026, the new Siri cannot see an app that does not speak App Intents. SiriKit has a two-to-three-year migration window, but new capability lands only on Intents. Wake phrases, custom vocabulary, and old intent-definition files are no longer the main path.

To the system, an Intent is a dispatchable tool: a name, parameter types, whether it needs confirmation, whether it opens UI, which domain it belongs to. Siri, Shortcuts, Spotlight, and the on-device agent share that catalog.

  • Intent schemas: system domains (tasks, photos, communication, commerce). Align with a domain and Siri does not need your frozen trigger phrase.
  • Entity schemas: orders, contacts, and files enter the Spotlight semantic index; personal context comes back with attribution.
  • View Annotations: mark the visible view as an entity so “refund this one” has something to bind — no second ID prompt.
  • App Intents Testing: exercise Siri / Shortcuts / Spotlight on real system paths. You test objects, not taglines.

You write AppIntent in Swift; the system sees a callable description. the AI Agent guide draws “the model proposes, the host runs.” On iOS the proposal often comes from Siri; execution always sits in your perform().

Opening the app is only one presentation. Lookups, state changes, and cross-app handoffs can finish in the background — if the parameters are legal and you declared confirmation for destructive work.

Parameters are a JSON object, not a wake phrase

The old path treated natural language as a search string. The new path treats it as form-fill. If a field is stored as prose, perform() has to parse again — you threw away the dispatch.

Every Intent should have a JSON Schema. The Swift type is a projection. @Generable, cloud Structured Outputs, the eval suite, and non-Swift clients should point at one source.

A minimal LookupOrder contract can look like this:

{
  "$id": "https://example.com/schemas/intents/lookup-order.json",
  "type": "object",
  "properties": {
    "intent": { "const": "LookupOrder" },
    "parameters": {
      "type": "object",
      "properties": {
        "order_id": { "type": "string", "pattern": "^A-[0-9]{4,}$" }
      },
      "required": ["order_id"],
      "additionalProperties": false
    }
  },
  "required": ["intent", "parameters"]
}

Keywords are in the JSON Schema tutorial. Keep property names short, freeze the enum, cap arrays with maximumCount. why AI needs JSON Schema already said it: Schema is the diameter, not the sentence “please return JSON.”

A bad Siri fill, a stale entity, or an extra key still reaches your function. Tighten the Intent, then validate again with the same Schema before you execute. Debug by formatting, pull order_id with JSONPath extract, and JSON Diff against last week's passing object. Do not paste user orders onto a public site.

AI agents: automation is a loop, not one Intent

Users rarely want one hop. “Look up A-1042 and refund it if paid” needs LookupOrder first, then a decision to run CreateRefund. That is an agent: propose, run, read, propose again.

On Apple's stack the loop lives in a LanguageModelSession. Tools are often App Intents, or system OCR / Spotlight. The skeleton matches cloud Function Calling: the model emits a name and arguments; the host validates and runs.

  • The default catalog is Intents the system can see, not a long tools[] list you maintain alone.
  • Every hop's input and output is an object. Screenshot prose cannot be the next parameter.
  • PCC is about 32K. Tool results eat the window first. Trim before the session.
  • Cross-app chains are allowed. Each hop still needs legal parameters and its own confirmation policy.
{
  "agent": "on_device",
  "goal": "refund_if_paid",
  "plan": [
    {
      "step": 1,
      "tool": "LookupOrder",
      "arguments": { "order_id": "A-1042" }
    },
    {
      "step": 2,
      "tool": "CreateRefund",
      "arguments": { "order_id": "A-1042", "reason": "duplicate" }
    }
  ]
}

A minimal “refund if paid” plan looks like the blob above. The model may propose step 2; it may not skip the host. If status is not paid, amount is out of range, or confirmation is missing, CreateRefund must not run. AI agents and the JSON Schema workflow is how the gates line up; MCP Tool Schema vs Function Calling is another spelling of tool JSON. Apple writes the same dictionary as App Intents.

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

Schema is the gate before execute, not an appendix

Guided Generation stops illegal tokens. It does not do auth, caps, or a second confirm. Parameters Siri filled can still miss a field, use a bad enum, or point at a stale entity.

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

Layer What the system is doing Without a Schema
Siri AI Turns a sentence into an Intent call Prose hits perform(); the side effect starts
App Intents Registers callable actions with the system The new Siri cannot see you; old phrases will not save you
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

After a successful lookup, automation state should also be an object, not the sentence “found it”:

{
  "automation": "refund_if_paid",
  "trigger": "siri",
  "state": {
    "order_id": "A-1042",
    "status": "paid",
    "amount": 99.00
  },
  "next": {
    "intent": "CreateRefund",
    "allowed": true
  }
}

allowed must be computed by the host from the Schema and business rules. The model may say “suggest a refund.” It may not write allowed: true itself.

Automated execution: Shortcuts, Spotlight, and cross-app

Automation on iOS 27 is not another API. It is different doors on the same Intent catalog.

  • Shortcuts is a visual planner. Each tile is still an Intent; each handoff is still a parameter object.
  • Spotlight semantic index returns entities, not web snippets. “That order from last week” must resolve to an order_id.
  • Cross-app chains are fine, but each side validates its own perform(). Do not feed the other app's prose into the next hop.
  • Confirm destructive work. Refunds, deletes, outbound send: declare a confirmation policy. Return a structured result, not just “OK.”

The same LookupOrder can be spoken, tapped on a Shortcuts canvas, or used as an agent tool. You maintain one Schema.

When automation fails, inspect the object first: a missing required, an enum off the list, a stale entity. Do not start by rewriting wake phrases.

How to ship in 2026

  • Keep schemas/intents/ and schemas/state/ in the repo, each with a stable $id and a version.
  • Write the JSON Schema before AppIntent / @Generable. The type is a projection, not the source.
  • Side effects (lookup, refund, mail) go through an Intent. Extraction, triage, and handoff go through Guided Generation.
  • Default new objects to additionalProperties: false and an explicit enum. For extension, add a separate metadata.
  • Declare confirmation for refunds, deletes, and outbound send. Put illegal parameters into App Intents Testing — do not only test the happy path.
  • 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. Siri's phrasing will change. The diameter should stabilize first.

Common pitfalls

  • Treating Siri AI as ChatGPT. It delivers an Intent. It does not run your side effects, and it does not guarantee legal parameters.
  • Relying on wake phrases without App Intents. The new Siri cannot see you.
  • Skipping validation because Siri filled the fields. Missing keys, bad enums, and stale entities still reach perform().
  • Writing only Swift types, with no JSON source. The cloud API, evals, and non-Swift clients will drift.
  • Using a wide type: object to dodge design. An open object is no gate. Version it, or add explicit metadata.

FAQ

Can iOS 27 Siri call my app if I have no App Intents?

The new Siri cannot. SiriKit is still in a migration window, but natural-language dispatch, on-screen entities, and multi-step agents only see App Intents. To be called, register the action and its parameters.

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, then check the same Schema again before you execute.

Are Shortcuts and Siri two APIs?

No. They read the same Intent catalog. The difference is the door: voice, a Shortcuts canvas, or an agent loop. The object shape should match.

Can an on-device agent write the database itself?

No. The model may only propose a name and arguments. State changes, refunds, and mail must go through the host perform() and your confirmation policy.

How do I inspect this 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 orders or contacts onto a public site.

Conclusion

On iOS 27, Siri AI “calling an app” is not opening a chat UI. It is turning a sentence into a legal Intent parameter, letting the host execute, and entering a multi-step agent loop when needed.

App Intents are the door, the agent is the loop, JSON Schema is the gate before execute. Put schemas/intents/lookup-order.json in the repo first. Then decide which phrases deserve a demo.

Further reading

Changelog: initial release