Guide · 7 min read
Google AppFunctions: How to Make Your Android App Callable by Gemini and AI Agents in 2026
Google AppFunctions is Android's version of Apple App Intents — a framework that lets AI assistants like Gemini execute your app's actions directly, without the user opening the Play Store or typing a keyword. Announced in February 2026 and now in private preview for Gemini integration, AppFunctions turns your app into an on-device agent tool: exposing discrete callable actions to Android's AI ecosystem. For indie developers, this is a secondary discovery surface worth understanding now, while competition for Gemini's function registry is still low.
AppFunctions is Android's on-device MCP — a new discovery path that bypasses the Play Store
AppFunctions makes your app callable by AI agents, not just navigable via a deep link. When a user asks Gemini 'add eggs to my grocery list,' Gemini checks the AppFunctions registry for apps that expose a grocery-add action, matches the intent, and calls that function directly — returning a result without the user ever opening your app's UI. This is meaningfully different from a deep link, which routes users to a screen but still requires them to complete the action manually.
Google introduced AppFunctions in February 2026 as part of the Android Intelligence platform, positioning it as Android's native answer to MCP (Model Context Protocol). Unlike cloud-based MCP servers, AppFunctions run entirely on-device — no server roundtrip, no API to maintain. As of May 2026, Gemini integration is in private preview with selected partner apps; the broader registry is functional for developers building their own AI agents using Android's agent APIs.
The model inverts traditional app discovery. Right now, a user finds your app in the Play Store, installs it, opens it, and completes a task. AppFunctions creates a second path: user asks Gemini a question → Gemini surfaces your app's capability → user completes the task via Gemini → possibly installs your app afterward. The install can come after demonstrated utility rather than before it — and that inversion is the early-mover advantage indie developers can capture right now.
What your app can expose: the four AppFunctions action categories Gemini calls
AppFunctions are Kotlin methods annotated with the Jetpack AppFunctions library — specifically the @AppFunction annotation — that describe discrete actions your app performs. Google's documentation defines four practical categories: read actions (retrieve and return information), write actions (create or modify data), navigation actions (open a specific in-app context), and rich-response actions (return structured content an AI agent can render inline). Each function must have a clear name, typed parameters, and a meaningful return type.
The KDoc comment on each AppFunction is not documentation for human readers — it's the description Gemini uses to match user intent to your function. Write KDoc as you'd brief a language model: state the function's purpose in the first sentence, name parameters using the words a user would actually say, and include the natural-language query the function handles. 'Adds a named grocery item to the user's active shopping list' matches 'add eggs to my list' correctly. 'Appends an item record to the primary list entity' does not.
The AppFunctions most likely to surface in Gemini's current preview are: task-completion actions (add item, set reminder, start timer), lookup actions (check status, find record, get balance), and content-creation actions (create note, start session, initiate recording). Start with your app's most-used single action. A one-function implementation with a well-written KDoc outperforms a ten-function implementation with vague descriptions every time.
How Gemini discovers which app's function to call: semantic matching, not keyword rank
Gemini matches user queries to AppFunctions through semantic intent analysis, not keyword overlap. When a user asks 'track my water intake,' Gemini evaluates registered functions describing hydration, wellness, or daily intake tracking — regardless of whether 'water' appears in the function name. The match happens on the meaning of the KDoc description versus the meaning of the query. This is the same semantic interpretation Google applied to Play Store search — described in the ASO semantic search guide — now operating at the function level.
Ranking within a category of matching apps appears to weight prior usage history. If a user has previously called your AppFunction through Gemini, it surfaces higher in future matches — the same retention-over-acquisition signal Google has been building into Play Store ranking since 2026. Apps with consistently high engagement rates benefit disproportionately from this weighting, which creates a compounding advantage for apps that earn early adoption and consistent re-use.
A naming convention insight: a function named addToGroceryList with KDoc that reads 'Adds a named grocery item to the user's active list. Use when the user wants to add food, household, or shopping items' handles a far wider range of natural-language queries than createListItem with no KDoc. The investment in precise KDoc authorship pays back every time Gemini evaluates your function against a new user query.
AppFunctions vs. Apple App Intents: what Android does differently
Apple App Intents (updated for iOS 26) surface through Siri, Spotlight, Shortcuts, and Control Center widgets — the full surface breakdown is in the App Intents guide. AppFunctions follows the same principle — structured function declarations for AI routing — but differs in architecture. App Intents carry more boilerplate around confirmation dialogs and system UI integration. AppFunctions are MCP-compatible tool calls, which makes them accessible to third-party AI agents beyond Gemini.
The implementation contrast is practical: App Intents in Swift require protocol conformance, result value types, and system prompt handling. AppFunctions are annotated Kotlin methods — the Jetpack library handles serialization and binding. Google designed the lower friction intentionally: the goal was a broad base of apps in the registry quickly, so the implementation was built to be a focused day's work rather than a week's. The Android Studio Gemini plug-in generates the scaffolding from your existing Activity and ViewModel code.
For cross-platform teams: AppFunctions currently require Android 16 on device, though Google's documentation indicates Play Services delivery may extend compatibility to Android 15 as the rollout matures. Apple App Intents require iOS 16 at minimum, with the richest Siri integration from iOS 26. The annotation conventions differ enough that a shared abstraction layer is premature — implement each platform separately and treat them as parallel features with a common discovery goal.
Implementation path: Jetpack library, KDoc annotations, and ADB testing
Implementing AppFunctions involves four concrete steps. First, add the Jetpack AppFunctions dependency to your module's build.gradle. Second, create a class implementing AppFunctionService and annotate callable methods with @AppFunction. Third, write KDoc for every function using user-intent language rather than developer jargon — the KDoc is parsed by AI agents, not IDEs. Fourth, declare the service in AndroidManifest.xml with the required intent filter and permission.
Google's AppFunctions agent skill — available as an Android Studio Gemini plug-in — reads your Activity and ViewModel code, identifies logical functions to expose, and generates Kotlin scaffolding. Treat the output as a first draft: the generated KDoc uses developer language, not user-intent language, and needs revision before shipping. Reviewing and rewriting that KDoc is where most of the implementation value lies.
Testing happens through ADB. Once you declare AppFunctions in your manifest, query the on-device registry using the ADB commands documented in Google's testing guide — confirming functions appear, parameters are correctly typed, and KDoc text is visible to the agent API. Run this on a physical Android 16 device; the emulator's AppFunctions registry has known gaps that produce false positives. Before any AppFunctions-enabled release, confirm your Play Store feature graphic and icon exports at every required size are current — these remain the primary conversion layer for users arriving through every channel.
Which app categories benefit most from AppFunctions right now
Task-completion apps benefit most: grocery list managers, to-do tools, expense trackers, fitness logging apps, and journal apps. These share a structure where the core value is a single repeatable action — add item, log workout, record expense — performed frequently through the same gesture. That gesture maps directly onto what AppFunctions expose: a callable action with a predictable input and a confirmable output. If your app's core loop is one action repeated many times per week, AppFunctions is the right surface to implement first.
Content apps — news readers, recipe apps, podcast players, learning tools — benefit from read-action AppFunctions. A function returning 'three recipes matching the user's dietary preferences' or 'today's top stories in the user's chosen categories' is a natural fit for Gemini's query patterns. The Engage SDK and AppFunctions can run in parallel for these apps: the Engage SDK surfaces content on your Play Store listing as covered in the Google Play v51 in-app content guide, while AppFunctions surfaces retrievable content directly through Gemini.
Utilities, developer tools, and games are weaker candidates in the current preview period. Utility apps often lack a bounded callable action — their value is ambient configuration rather than a discrete function. Games have session logic that doesn't map to the tool-call model. For those app types, development time returns more through semantic metadata improvements using Gemini-powered Play Console keyword recommendations and strong visual assets — improvements that compound for every user who lands on your listing regardless of how they arrived.
Start with one function, not a full API
The most common AppFunctions mistake is trying to expose every app capability at once. Start with the single most-used action in your app — the one function that captures your core value in one call. Write the KDoc as if you're training a language model, apply to Google's early access program, and instrument your analytics to detect calls arriving from outside your app's UI. One well-described function will surface in Gemini before a poorly-described ten.
Before AppFunctions moves the needle on acquisition, the rest of your Play Store presence must be solid. A strong description, well-optimized screenshots, and a clear feature graphic are the primary conversion surface for the vast majority of users. AppsTemple's editor builds and exports every Play Store visual asset to spec — so the visual layer is right before the AI layer amplifies it.
Build your Play Store visual assets →
Frequently asked questions
what is google appfunctions?
Google AppFunctions is an Android framework that lets developers expose callable functions from their app to AI assistants like Gemini. Announced in February 2026, it is Android's equivalent of Apple's App Intents — a way for AI agents to trigger specific app actions in response to user requests, without requiring the user to open the app. Functions are defined using the Jetpack AppFunctions library and run locally on the device, not through a server.
what android version does appfunctions require?
AppFunctions targets Android 16 (API 36) as its primary platform. Google's documentation notes that Play Services delivery may extend registry functionality to Android 15 and some earlier versions as the rollout matures. For testing, use a physical Android 16 device — the emulator's AppFunctions registry has documented gaps that can produce false-positive results in ADB queries.
how does appfunctions differ from android deep links?
Deep links navigate a user to a specific screen inside your app — the user still performs the action manually in your UI. AppFunctions execute app logic and return a result directly to the AI agent, with no UI navigation required. A deep link opens your grocery list screen; an AppFunction adds the item and returns a confirmation to Gemini, which relays it to the user. AppFunctions are for executing actions; deep links are for navigating to UI contexts.
is appfunctions only available for google gemini?
No. AppFunctions registers callable functions in Android's OS-level agent registry, making them available to any AI agent following Android's agent protocol. Gemini is the first prominent consumer of the registry, but Google's design explicitly supports third-party AI agents. The Gemini integration is in private preview as of mid-2026; the broader registry is functional for developers building their own agent experiences.
do i need to join an early access program to implement appfunctions?
You can implement AppFunctions — add the Jetpack library, annotate methods, declare the service, and test with ADB — without joining any program. The AppFunctions registry is open. The private preview applies specifically to Gemini surfacing your functions in its responses; for that, your app needs to be accepted into Google's early access program. The right sequence: implement first, then apply — Google's review is easier when they can inspect a working implementation.