App Intents from React Native: Siri, Spotlight and Apple Intelligence with expo-app-intents

What SDK 58 shipped

Expo SDK 58 entered beta in mid-September 2026, built for iOS 27 and bundling the React Native 0.88 release candidate (RN 0.88 stable is scheduled for around 12 October 2026). Alongside faster Android builds, Android home-screen widgets and a new CLI aimed at coding agents, the headline for iOS teams is expo-app-intents: a first-class way to define Apple App Intents from JavaScript, plus an Expo Device Hub integration for testing with Xcode 27.

Why App Intents matter now

An App Intent is a declaration that says “my app can do this specific thing, with these parameters.” Once declared, the systemcan invoke it: Siri and Shortcuts can run it, Spotlight can surface it, and, the reason this is suddenly interesting, Apple Intelligence can discover and chain it. It turns your app from something a user has to open into a set of capabilities the OS can call on the user's behalf.

Until now, doing this in a React Native app meant dropping into Swift, defining AppIntent structs natively, and bridging back to your JS. expo-app-intents collapses that into the JS layer where your app logic already lives, which is what makes it worth a serious look rather than a “maybe next year.”

How the pieces fit

Three parts, in the order you set them up:

1. The config plugin in app.json enables the module and its iOS entitlements at prebuild.
2. Intent definitions in JS/TS: a title, a description the system (and Apple Intelligence) reads, typed parameters, and a handler.
3. Donation / registration: telling the system the intent exists so it shows up in Shortcuts and Spotlight.

{
  "expo": {
    "name": "My App",
    "ios": { "bundleIdentifier": "com.mycompany.myapp", "deploymentTarget": "27.0" },
    "plugins": [
      "expo-app-intents"
    ]
  }
}

import { defineAppIntent, StringParameter } from "expo-app-intents";

// "Log a run" — the kind of action Siri / Spotlight / Apple Intelligence
// can invoke without the user opening the app.
export const logRun = defineAppIntent({
  name: "LogRun",
  // Titles/descriptions are what the system and Apple Intelligence read to
  // decide when to surface and run this — treat them as product copy.
  title: "Log a run",
  description: "Record a completed run with an optional note.",
  parameters: {
    note: StringParameter({ title: "Note", optional: true }),
  },
  async handler({ note }) {
    const run = await api.runs.create({ note, at: Date.now() });
    return {
      value: run.id,
      // What Siri speaks / Apple Intelligence shows back to the user.
      dialog: note ? `Logged your run: ${note}` : "Logged your run.",
    };
  },
});

import { registerAppIntents } from "expo-app-intents";
import { logRun } from "@/intents/logRun";

// Make the intents discoverable to Shortcuts / Spotlight / Siri.
registerAppIntents([logRun]);

The important design point is not the syntax, it is the metadata. Apple Intelligence decides whether to surface and run an intent from its title, description and parameter names. Vague copy (“Do thing”) gets ignored; precise, action-shaped copy (“Log a run”, parameter “Note”) gets picked up. Writing intents is as much product writing as engineering.

Where it actually earns its place

Not every app needs this. The ones that benefit most share a shape:

• Frequent, atomic actions — log a habit, start a timer, add an item, mark done. Anything a user does often and quickly is a candidate to lift out of the app entirely.
• Lookups— “what's my balance”, “next delivery”, “today's summary” — read-only intents that Spotlight and Siri can answer without a launch.
• Multi-step flows Apple Intelligence can chain — where your action is one node in a larger task the OS assembles.

The apps that should not rush: anything where the action is destructive, irreversible or money-moving. An OS-invoked action needs the same care as any other privileged entry point — clear confirmation, scoped effect, and no surprises. We wrote the general version of that discipline for agents in giving an AI agent safe write access, and the instinct carries over: a system that can run your action unattended is a system you design defensively.

Gotchas before you commit

• iOS-only.This is Apple's framework. Budget Android's App Actions separately; do not promise “works with your assistant” cross-platform from one integration.
• Toolchain floor. SDK 58 targets iOS 27 and pairs with Xcode 27 / the Device Hub for testing. Older CI images will not build it, factor that into your pipeline.
• It is beta. RN 0.88 is a release candidate inside SDK 58. Pin your versions, keep intents behind a flag, and expect the API to move before stable.
• App Review. Intents that touch sensitive data or perform actions get scrutiny; document them the way you would any new capability. Our App Store rejection data covers the patterns that trip submissions.

The one-day version

If you want to try it this week: upgrade a branch to SDK 58, add the expo-app-intents plugin, define one read-only lookup intent (lowest risk, immediate “wow” in Spotlight), and test it through the Device Hub in Xcode 27. One good intent that answers a question without a launch tells you more about the fit than a spec doc. If it lands, expand to your two or three highest-frequency actions, that is where the retention and Apple Intelligence surface actually comes from.

This is the kind of platform capability we fold into builds as it stabilises through our React Native app development engagement, and validate against review through app store launch.

Three companions from the same mobile cluster:

The engagements that build and ship this: