TL;DR
- To make your app usable by AI assistants, give the assistant three things: an action it can find, a way to call it with the right values, and a link that opens the right screen when the user has to finish the job. On iOS the actions are App Intents, on Android they are AppFunctions, and on both the first step is links.
- Links, App Intents in Shortcuts and Spotlight, and AppFunctions tests all work today. Siri AI and Gemini's access to AppFunctions are still in preview, so build the first parts now and keep the rest small.
- Build an MCP server only when your users already work in an assistant. In Expo, App Intents work on iOS in alpha with a native build; Android needs a Kotlin module of your own.
I write Code Meet AI, the newsletter where I document how I actually use AI to ship real products, receipts included. New guides land there first.
In Part 1 I argued that the assistant may soon open your app for your user. The next question is the one I would type into a search box: what do I build so the assistant can use my app?
What it takes to make your app usable by AI assistants
An assistant can use your app when it can find an action you offer, call it with the right values, and send the user to the right screen when a person has to finish the job. If one of the three is missing, the assistant tells the user to open the app and do it by hand, or it uses another app.
The work is to describe what your app already does in a form the system can read. I have shipped mobile apps for 9 years, and I see this as the same job as building an API, only the caller is the phone's assistant.
Start with links: they open the right screen
Links are the cheapest step and they help every route below. When an assistant cannot call an action, the next best thing it can do is open the exact screen.
Universal links do this on iOS. Apple says that when a user taps one, "the system redirects the link directly to your app without routing through the person's default web browser or your website" (Apple docs). Android's version is App Links: deep links verified against your own website, so they "immediately open corresponding content in your app" (Android docs). On both, your website hosts a small file that proves the link belongs to your app; the two pages show how.
Say your app books a table. A link like yourapp.com/booking/42 that opens booking 42 is something an assistant, a search result and an email can all use. Many apps only link to the home screen. That is the first thing I would fix.
How Siri reaches your app: App Intents
App Intents is the iOS route. You write a small Swift type for each action, and you can test it in Shortcuts and Spotlight today. Apple is direct about the limit: "Siri can only perform actions you make explicitly available."
To make an intent a tool Siri can call, the same Apple page says to "add the @AppIntent(.tool) Swift macro to a new or existing app intent." It lists two exceptions: an intent that already follows one of Apple's schemas for Siri does not need the macro, and an intent with no custom action in its perform() should not get it. The page also says to "make your app entities available to Spotlight" so Siri can find your content.
Siri AI is the new Siri that calls these tools. Apple's developer news of 3 November 2026 opened its developer preview to all developers with the iOS 27.3 beta. Apple says it ships to customers "in a few months", "with submission to the App Store opening up in the spring", and that Siri AI is "currently unavailable in the EU" on iPhone. In June I wrote that WWDC 2026 meant your app now has to be usable by AI. The preview is that sentence turning into a date.
How Gemini reaches your app: AppFunctions
AppFunctions is the Android route. Google calls them "the mobile equivalent of tools within the Model Context Protocol (MCP)" (Android docs). You mark a Kotlin function with @AppFunctionDeclaration, write a clear comment on what it does, and the Jetpack library builds the list the system reads. Each function returns a typed result, like the task it just created, which the agent reads back.
Three limits, all from the same page:
- It is experimental, and it runs on Android 16 or higher.
- "As of May 2026, AppFunctions integration with Gemini is in a private preview with trusted testers."
- Only "a limited number of apps and system agents can access the entire pipeline" during this phase. The page links an early access form.
You can still build and test it today. On an Android 16 device with your app installed, the page gives this adb (Android Debug Bridge) command: adb shell cmd app_function list-app-functions --package <your.package>. It shows whether the device registered your functions.
Build an MCP server only if your users already work in an assistant
MCP is "an open-source standard for connecting AI applications to external systems" (MCP docs). An MCP server lives next to your backend. It lets assistants like Claude or ChatGPT call your product from a computer or the web. The AppFunctions FAQ draws the line with the phone: AppFunctions "execute locally", while a standard MCP server "relies on cloud execution and network round-trips."
So build one when your users already work in an assistant on a computer and your product has a backend API worth calling. Skip it when the value lives on the phone, in local data or in a camera flow. If MCP is new to you, start with What is MCP servers and the hands-on Using AI, properly 05.
What works in React Native and Expo today
On iOS, Expo ships expo-app-intents. You write the intents in Swift in an app-intents folder, and a useAppIntents() hook passes each call to your JavaScript. Two warnings from its docs: it "is currently in alpha and will frequently experience breaking changes", and it "is not available in Expo Go", so you need a native build:
npx expo prebuild -p ios
npx expo run:ios
On Android, as of 15 November I could not find an Expo or React Native wrapper for AppFunctions in a web search. For now that means a small Kotlin module of your own, written with the Expo Modules API, that declares the functions and calls into your app.
Start with links, then pick one route per platform
| Route | Platform | Effort | What the assistant can do | My recommendation |
|---|---|---|---|---|
| Universal links and App Links | iOS and Android | Low | Open the exact screen | Do it first, this week |
App Intents with @AppIntent(.tool)
|
iOS (Siri AI in preview) | Medium | Call an action and get a result | Start with your top three actions |
| AppFunctions | Android 16+ (Gemini access in private preview) | Medium | Call an action and get a result | Build one function, test with adb, apply for early access |
| MCP server | Any assistant on a computer or the web | Medium to high | Call your backend API | Only if your users already work in an assistant |
| expo-app-intents | Expo on iOS | Medium, alpha | Same as App Intents | Fine for a branch, pin the version |
| Custom Kotlin module | Expo on Android | High | Same as AppFunctions | Wait, unless Android is your main platform |
A one-week checklist for a small team
- Day 1: list the three actions users repeat most. Write each as one sentence a person would say to an assistant.
- Day 2: give each of those actions a universal link and an App Link that opens the right screen, including the website file each platform checks.
-
Day 3: write the three App Intents, mark each one that runs a custom action in
perform()with@AppIntent(.tool), and test them in Shortcuts and Spotlight. - Day 4: on an Android 16 device, add the AppFunctions Jetpack library from the Android page, write one function for the most common action, and check it with the adb command above.
- Day 5: write down what you would expose through an MCP server, and decide if your users need it yet.
Each day ends with something you can show. None of it waits for the previews to ship.
Next: Siri AI, step by step
The next piece builds one action for Siri AI end to end. Subscribe to get it, and reply with the one action in your app you would expose first.
This one came from Code Meet AI, the newsletter where I write up the setups I actually run on my own projects.
Top comments (0)