Two things happened in the last two months, and together they change where your users actually are.
In May, at Google I/O, Google launched Gemini Spark. It is an AI agent that keeps working after you lock your phone, because it runs on Google’s own cloud machines rather than in your hand. It watches your Gmail, manages your Calendar, drafts your Docs. You hand it a job like “find and track interior design internships in New Orleans this summer” and it goes away and does it on a schedule while your laptop is shut.
Then, last week, a Chinese company called StepFun launched the StepX Neo, which it bills as the world’s first agentic smartphone. There is no ordinary launcher at the centre of it. There is an agent called Step Amoo living inside a custom operating system called Step AOS, and you simply tell it what you want. StepFun has lined up integrations with Ctrip, Alipay, Didi, Meituan, WPS and CapCut, so the agent can book the trip, pay for it, and hail the car.
Notice what those have in common. Nobody is tapping your launcher icon.
That is the backdrop for AppFunctions, Android’s answer to the question every one of these agents runs into: how does an assistant actually reach inside an app and get something done? This post explains what it is and why it matters. We will publish a proper step-by-step walkthrough separately.
The short version
- Agents are becoming the front door. Gemini Spark works in the cloud while your phone is off. The StepX Neo puts an agent where the launcher used to be.
- An agent is useless unless it can reach into apps. AppFunctions is how it reaches into yours.
- Your app publishes a list of things it can do, in plain language. The agent reads that list, picks one, and runs it. No screen opens.
- Google calls AppFunctions “the mobile equivalent of tools within the Model Context Protocol (MCP)”. That is the same standard Gemini Spark plans to use for third-party services.
- Everything runs on the phone, inside your app, so there is no server to host and no network round trip.
- It needs Android 16 or higher, it is an experimental preview, and the library is still in alpha.
- Gemini cannot call your app’s functions in production yet. As of May 2026 that was a private preview with trusted testers, with an Early Access Program to apply to.
What is an AppFunction?
An AppFunction is one thing your app knows how to do, published so that something other than your user interface can ask for it.
That is genuinely the whole idea. “Add an item to a shopping list” is a function. “Show this month’s spending” is a function. “Mark today’s habit as done” is a function. Each one already exists in your app. The difference is that today the only way to reach it is by opening your app and tapping through your screens, and an AppFunction makes it reachable directly.
Think of it as a menu your app hands to the phone. Every app on the device hands over its own menu, the system keeps them all in one place, and any agent can look through the whole thing and find the right item.
How does it work?
Four beats, and none of them involve your user.
You describe what your app can do. You mark a capability as available and write a short description of it in ordinary English, along with a description of each piece of information it needs.
The phone collects it. When your app is built, that list gets packed inside it. When the app is installed, Android reads the list and adds it to a device-wide registry of everything every app can do.
An agent goes looking. Here is the part that surprises people. The agent does not need to know your app exists, and it does not need you to integrate anything with it. It asks the system what is available, and your capabilities are simply there, descriptions and all.
It runs, quietly. The agent picks the right capability and calls it. Your code executes inside your app, against the data your app already has. No activity starts. No screen is drawn. The user just gets the result.
Put it together with a real request. A user says “add oat milk to my shopping list.” Today that is unlock, find your icon, wait for load, tap the right list, tap plus, type, save. Seven steps. With AppFunctions it is one sentence, and your app never opens. Your code still ran, and the item is on the list.
Why should developers care?
Four reasons, and only one of them is about the technology.
Reachability. This is the big one. If an agent is standing between your user and their phone, then being callable is the same thing as being used. An app the agent cannot reach becomes the thing the user has to go and do by hand, which is a fancy way of saying it becomes the thing they stop doing.
Privacy. Your function runs locally, on the device, against your existing data. Notes, tasks and messages do not have to leave the phone to be acted on. That is a genuinely different story from a cloud service that needs a copy of everything.
Speed. There is no network round trip. A cloud tool pays for DNS, TLS, transit and server time on every single call. This is an in-process call on the phone, so it is fast, and it works with no signal.
Almost no new code. You are exposing the logic you already wrote. There is no separate server to build, host, secure and pay for. You are putting a new door on an existing room, not building an extension.
The part everyone underestimates: your descriptions
This deserves its own section, because it is the thing most likely to catch you out.
When your app publishes a capability, it does not just publish the name and the shape of the data. It publishes your description of it, written by you, in English. And that description is what the model reads when it decides whether your app is the right tool for the job and what information to put where.
So the model is not reading your logic. It is reading your writing.
If your description says “adds an item”, the model has to guess. An item to what? If your app expects a quantity, is that a count, a weight, a number of packs? When somebody says “grab a couple of oat milks”, does your app get 2? A vague description means the agent either skips your app or calls it with the wrong information, and here is the uncomfortable part: nothing crashes. There is no error report. Your app is just quietly not chosen, or quietly wrong.
Write for a new colleague who cannot see your code. Say exactly what the capability does, give an example of what a piece of information should look like, and say what happens by default. That prose is now part of your product.
Things to keep in mind
Your function is not automatically on a background thread. Google is blunt about it: by default, an AppFunction runs on the app’s main thread. If it reads your database or hits the network, that work lands on the main thread the moment an agent calls it. This one is nastier than a normal freeze, because nobody is looking at your app. No screen, no spinner, no user to say “it hung”. It just quietly blocks.
Not anything can call you. A caller needs a special system-level permission to discover or run app functions. That is deliberate, and it is why a random app cannot quietly drive your code behind the user’s back.
It is early. The library is alpha and the details will move. Treat this as something to learn and prepare for, not something to promise in a roadmap.
You can already test it. Even though Gemini cannot call your functions in production yet, you are not stuck waiting. You can trigger your functions directly from your computer using the standard Android developer tools, with no AI in the loop at all. You send an exact request, you get an exact result, and it behaves the same way every time. For anyone who tests software, that is a rare gift for an AI feature, and it is what our step-by-step guide will cover.
So what should you do now?
Nothing dramatic. This is not a fire drill, and you cannot ship it to users today anyway.
What is worth doing is thinking. Look at your app and ask which one thing your users open it to do. That single thing is your first candidate. Then ask whether you could describe it, in two sentences, clearly enough that a stranger could use it without seeing your app. If you cannot, that is the work, and it is work you can do before any of this becomes urgent.
The teams who get value from this will not be the ones who rushed the integration. They will be the ones who thought carefully about which parts of their app deserve to be reachable in a sentence.
Common questions
1. What is the AppFunctions API?
AppFunctions is an Android feature that lets your app publish things it can do so an on-device AI agent can find and run them without opening your app. Google describes them as the mobile equivalent of tools in the Model Context Protocol, so your app behaves like an on-device MCP server. A user says “add oat milk to my shopping list”, the agent finds your app’s capability for adding items, and runs it with no screen drawn.
2. What is Gemini Spark?
Gemini Spark is the always-on personal agent Google launched at I/O 2026. It runs on Google’s cloud virtual machines and keeps working when your device is off, handling multi-step jobs across Gmail, Calendar and Docs through tasks, skills and schedules. It is a US-only beta for Google AI Ultra subscribers at $100 per month, and Google plans third-party integrations through open standards and MCP.
3. What is the StepX Neo agentic phone?
The StepX Neo is a smartphone from Chinese AI company StepFun, launched in July 2026 and billed as the world’s first agentic smartphone. Instead of a normal launcher, it runs an agent called Step Amoo inside a custom agent operating system called Step AOS, which chains tasks across apps from a single request. StepFun has lined up integrations with Ctrip, Alipay, Didi, Meituan, WPS and CapCut. Pricing and availability have not been announced.
4. How are AppFunctions different from MCP?
They are the same idea in a different place. MCP tools usually live on a server, so the agent reaches them over the network and someone has to host and secure that server. An AppFunction runs on the phone, inside your app, against data your app already holds, so there is no server and no round trip. Agents can consider both together rather than choosing one.
5. Can Gemini call my AppFunctions right now?
Not in production. As of May 2026 the Gemini integration was a private preview limited to trusted testers, and Google runs an Early Access Program for apps that want to try the end-to-end experience. The feature is an experimental preview, and only a limited number of apps and system agents can reach the full pipeline.
6. What do AppFunctions need to run?
AppFunctions is available on devices running Android 16 or higher, and your project needs to build against a recent Android version. Google does not state a minimum supported version for your app. The feature is still an experimental preview and the library is in alpha, so expect details to change.
7. Can I test AppFunctions before Gemini supports them?
Yes, and this is the best part. You can run your app’s functions directly from your computer using standard Android developer tools, without any AI involved. You control the exact input and see the exact output, and it behaves identically every time, which means you can test this like any ordinary interface rather than guessing at a model’s interpretation.
Closing thoughts
For fifteen years, the way into an Android app was the launcher icon. Gemini Spark and the StepX Neo are two very different bets on that ending, and neither involves a user hunting a home screen for your logo.
AppFunctions is early, narrow and not ready to ship. It is also the clearest signal yet of what is coming: a world where your app is judged not only on how it looks, but on how well it can be asked. When the front door becomes a sentence, the quality of your descriptions stops being documentation and starts being product.
We will follow this with a hands-on guide covering how to expose your first function, how to try it without Gemini, and what to watch for. For now, the useful move is to look at your app and ask a simple question: if a user could only ever say one sentence to it, what should that sentence do?
If you want to read ahead, Google’s AppFunctions overview is the place to start. We also wrote about Android 17’s agentic Gemini, which taps through your interface, and Ask Play, which decides whether users find you in the first place. AppFunctions is the third move, and the one that skips your screens entirely.
