Make your Android app agent-ready in 2026: AppFunctions, App Actions, and Gemini's 40-app wave

Summary. At Galaxy Unpacked on 22 July 2026, Google widened Gemini's task automation to more than 40 apps, up from a handful in its February 2026 beta, covering shopping, restaurant reservations, travel, and event tickets. The mechanism underneath is AppFunctions, an Android platform API and Jetpack library that lets your app act like an on-device server of tools for agents such as Gemini. As of May 2026 the Gemini integration is a private preview with trusted testers, and AppFunctions needs Android 16 or higher. This matters most where Android runs on over 92% of phones, as in India. An on-device AppFunction executes locally, so unlike a cloud tool call it adds ₹0 in server inference cost to you. This guide covers the three ways to make an app agent-ready, the Kotlin code for AppFunctions, how App Actions still fit, DPDP guardrails, and a rollout checklist.

The interaction model is changing. Matthew McCullough, VP of Product Management for Android Development, framed it plainly in February 2026: "success is shifting from getting users to open your app, to successfully fulfilling their tasks and helping them get more done faster." When a user tells Gemini to add an item to a shopping list or book a table, the assistant needs a function in your app it can call. If you have not exposed one, a competitor who has will get the task.

What "agent-ready" means

An agent-ready app publishes discrete, callable capabilities that an assistant can discover and invoke with the right parameters, then reports a structured result. The user speaks or types a goal, Gemini plans the steps, and your function does the work without the person navigating your UI. The Samsung Gallery integration on the Galaxy S26 series is the reference example: a user asks Gemini to "show me pictures of my cat from Samsung Gallery," and Gemini triggers the app's function and shows the photos inside the Gemini app.

There are three ways to reach this state in 2026, and they are not mutually exclusive.

Path	How it works	Developer effort	Status in 2026
AppFunctions	Annotate Kotlin functions the OS indexes as on-device tools for agents	Moderate, code-level	Experimental preview; Gemini integration in private preview
App Actions and built-in intents	Declare capabilities in shortcuts.xml mapped to built-in intents for Assistant	Low to moderate	Supported; the shortcuts framework, with actions.xml deprecated
UI automation	The platform drives your existing UI on the user's behalf, no integration	None, zero code	Early preview on Galaxy S26 and select Pixel 10

AppFunctions is the path Google is investing in for agentic control, App Actions is the long-standing predecessor that still works, and UI automation is a zero-code fallback the platform runs when no dedicated integration exists. The rest of this guide leads with AppFunctions, because that is where you get precision and control.

AppFunctions: the on-device tool model

AppFunctions is an Android platform API with a companion Jetpack library that lets your app behave like an on-device server of tools. Google describes it as the mobile equivalent of a tool in the Model Context Protocol, except the function runs locally on the device instead of on a cloud server. Callers such as Gemini need the EXECUTE_APP_FUNCTIONS permission to discover and run your functions, and the feature is available on Android 16 and higher.

You declare a capability by annotating a suspend function with @AppFunction and documenting it with KDoc, which the agent reads to decide when and how to call it. Here is a note-taking app exposing three capabilities, adapted from Google's documentation.

class NoteFunctions(
    private val noteRepository: NoteRepository
) {
    /**
     * Lists all available notes.
     * @param appFunctionContext The context in which the AppFunction is executed.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun listNotes(appFunctionContext: AppFunctionContext): List<Note>? {
        return noteRepository.appNotes.ifEmpty { null }?.toList()
    }

    /**
     * Adds a new note to the app.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }
}

@AppFunctionSerializable(isDescribedByKDoc = true)
data class Note(
    /** The note's identifier */
    val id: Int,
    /** The note's title */
    val title: String,
    /** The note's content */
    val content: String
)

The Jetpack library's annotation processor generates an XML schema listing your declared functions, and the Android OS indexes that file so agents can find them. On the caller side, code retrieves an AppFunctionManager and checks availability before invoking anything:

val manager = context.getSystemService(AppFunctionManager::class.java)
val enabled = manager?.isAppFunctionEnabled(
    packageName = "com.example.notes",
    functionId = "createNote"
) == true

Your app does not have to check whether the device supports the feature; the Jetpack library handles that. Declare the caller permission in the manifest, since querying functions in other packages requires it:

<uses-permission android:name="android.permission.EXECUTE_APP_FUNCTIONS" />

To confirm your functions are registered on a device, run the ADB command from Google's guide:

adb shell cmd app_function list-app-functions

Google also ships an agent skill in its skills repository that inspects your app's workflows, generates the required Kotlin, tunes your KDoc for agents, and gives you ADB commands for testing. There is a working sample app and a separate sample agent app for end-to-end testing. Use them; the KDoc quality is what decides whether an agent calls the right function with the right arguments.

AppFunctions versus a cloud MCP server

If your team already ships Model Context Protocol tools on a server, the question is when to add on-device AppFunctions. The trade-offs are concrete.

Aspect	AppFunctions	Cloud MCP server
Where it runs	On-device, locally	Remote server
Latency	No network round-trip	Network round-trip per call
Platform	Android only	Platform-agnostic
Data exposure	Uses existing app state on-device	Data leaves the device
Maintenance	Inside your Android app	A service you run and secure

The short version: AppFunctions gives you low latency and keeps data on the device, at the cost of being Android-only. A cloud MCP server reaches any platform but pays a network round-trip and moves data off-device on every call. For a mobile app whose data already lives on the phone, on-device functions are usually the better default, and you can still keep server tools for cross-platform reach. Our note on how Flutter exposes AI features through Gemini and the Dart MCP tooling covers the cross-platform side if you ship on more than Android.

App Actions and built-in intents still have a place

App Actions is the predecessor to AppFunctions, and it still works. You declare a capability in shortcuts.xml and map it to a built-in intent, one of the dozens Google defines across common task categories, so Assistant can launch a specific screen or complete a task. Google has ended support for the older actions.xml resource file and points developers to the Android shortcuts framework instead.

Reach for built-in intents when your goal is launching the right screen or fulfilling a well-known intent that Google already models, and reach for AppFunctions when you want an agent to call a specific capability with typed parameters and get a structured result back. If you have shipped App Intents on iOS, the mental model carries over; our iOS 27 App Intents developer guide is the Apple-side parallel.

The zero-code path: UI automation

Google is also building a UI automation framework where the platform drives your existing app UI for the user, with no integration from you. It launched as an early preview on the Galaxy S26 series and select Pixel 10 devices, triggered by a long press of the power button, starting with a curated set of food delivery, grocery, and rideshare apps in the US and Korea. Users can watch progress in a live view, switch to manual control, and Gemini asks for confirmation before sensitive steps such as a purchase.

This gives you agentic reach with zero engineering, but you give up control. The agent interprets your screens, so an unusual layout or an A/B test can break the flow, and you cannot shape how the task is fulfilled. Treat UI automation as a floor, not a strategy: useful reach today, while you build proper AppFunctions for the workflows that matter.

What to expose first, and how to keep it safe

Start with the capabilities users actually ask an assistant to do: create an item, search your content, add to a list, book or schedule, check a status. Write the KDoc as if an agent is the reader, because it is. State what the function does, what each parameter means, and what it returns, in plain language.

Three engineering rules keep agent access safe. First, make write functions idempotent or confirm before commit, because an agent may retry. Second, keep a confirmation step for anything that spends money, sends a message, or deletes data; the platform already prompts before sensitive actions, and your function should not assume otherwise. Third, treat function inputs as untrusted, since a prompt-injection attempt can reach your app through the agent. The controls in our note on guardrails against prompt injection apply directly to any function an agent can call. Scope each function narrowly, validate every argument, and log what was called.

India considerations

Android runs on over 92% of smartphones in India, so agent-readiness reaches almost your entire mobile audience there. That is a larger practical opportunity than on iOS-heavy markets, and it arrives with a data-protection obligation.

Any data your functions expose to an agent is personal data the moment it identifies a user, so the Digital Personal Data Protection Act 2023 applies. The on-device model helps: an AppFunction runs locally and uses existing app state, so data need not leave the phone, which is easier to defend than a design that ships personal data to a cloud tool on every call. Still, record the lawful basis for what an agent can read, honour deletion, and do not expose fields a user has not consented to share. Our DPDP engineering playbook for Indian startups sets out the data-flow work, and for the broader picture our notes on production AI-agent use cases cover where the pattern pays off.

Timeline and a rollout checklist

The sequence so far: Google introduced AppFunctions and the UI automation preview in February 2026, opened a private Gemini integration to trusted testers by May 2026, and expanded Gemini task automation to more than 40 apps at Galaxy Unpacked on 22 July 2026, alongside Gemini Nano 4 and Gemini Intelligence on the Galaxy Z Fold 8 and Flip 8. Google has said it will broaden these capabilities in Android 17.

A practical rollout: list the five capabilities users most often ask an assistant to perform. Implement two as AppFunctions with careful KDoc, and verify them with adb shell cmd app_function list-app-functions. Add confirmation and validation to every write. Register interest in the Early Access Program so your functions can reach the end-to-end Gemini pipeline. Keep built-in intents for launch-and-fulfil cases, and let UI automation cover the rest until your functions catch up. Ship, watch the logs, and expand only the functions that get called.

FAQ

What are AppFunctions on Android?

AppFunctions is an Android platform API with a Jetpack library that lets an app expose capabilities as on-device tools for AI agents and assistants like Gemini. You annotate Kotlin functions with @AppFunction, the OS indexes them, and callers with the right permission discover and run them locally, returning a structured result rather than opening your UI.

Do AppFunctions need a specific Android version?

Yes. AppFunctions is available on devices running Android 16 or higher. It remains an experimental preview as Google refines the API, and as of May 2026 the integration with Gemini is a private preview limited to trusted testers, so only a curated set of apps and system agents can reach the full pipeline today.

How are AppFunctions different from a cloud MCP server?

Both let an agent call tools, but AppFunctions are built-in Android hooks that run locally on the device, while a Model Context Protocol server is platform-agnostic and runs in the cloud with a network round-trip per call. AppFunctions keep data on-device and cut latency; an MCP server reaches other platforms but moves data off-device.

Is App Actions dead now that AppFunctions exists?

No. App Actions is the predecessor and still works through the shortcuts framework and built-in intents, though the older actions.xml file is deprecated. Use built-in intents to launch a screen or fulfil a well-known intent, and use AppFunctions when you want an agent to call a specific capability with typed parameters and receive a structured result.

What is the zero-code UI automation path?

Google's UI automation framework lets the platform drive your existing app UI for the user with no integration from you. It launched in early preview on the Galaxy S26 and select Pixel 10 devices for food delivery, grocery, and rideshare apps in the US and Korea. You gain reach without engineering, but lose control over how tasks run.

How many apps does Gemini automate as of July 2026?

Gemini task automation reached more than 40 apps at Galaxy Unpacked on 22 July 2026, up from a handful in its February 2026 beta. Coverage spans shopping, restaurant reservations, travel booking, and event tickets. Gemini can already automate tasks across categories such as calendar, notes, and tasks on devices from several manufacturers.

What does agent-readiness mean for DPDP compliance in India?

Data your functions expose to an agent is personal data once it identifies a user, so the DPDP Act 2023 applies. The on-device AppFunctions model helps because functions run locally and use existing app state, so data need not leave the phone. Record the lawful basis, honour deletion, and expose only fields the user consented to share.

How do I test that my AppFunctions are registered?

Run the ADB command from Google's guide, adb shell cmd app_function list-app-functions, to verify your functions are registered on the device. Google also provides an agent skill that generates Kotlin and tunes your KDoc, a sample app, and a separate sample agent app for end-to-end testing before the private Gemini pipeline becomes available to you.

How eCorpIT can help

eCorpIT is a Gurugram-based, senior-led engineering organisation, founded in 2021, CMMI Level 5 assessed and MSME certified, and a Google, Microsoft, and AWS partner. We help Android teams decide which capabilities to expose, implement AppFunctions and built-in intents with agent-grade KDoc and validation, and design the data flows aligned with DPDP Act requirements so an agent only sees what a user consented to share. If you want your app ready for Gemini's automation wave, talk to our Android team.

References

1. Android Developers: Overview of AppFunctions
2. Android Developers: Add AppFunctions to your app
3. Android Developers Blog: The Intelligent OS, making AI agents more helpful for Android apps
4. Android Developers: AppFunctionManager reference
5. Android Developers: Built-in intents for App Actions
6. Android Developers: Create shortcuts.xml
7. 9to5Google: Gemini task automation expands to 40+ apps at Galaxy Unpacked
8. Google: Galaxy Unpacked, Gemini and Samsung are better together
9. GitHub: AppFunctions sample app
10. GitHub: AppFunctions agent skill
11. Model Context Protocol: introduction
12. Axis Intelligence: iPhone vs Android market share 2026

Last updated: 26 July 2026.