O AppFunctions é uma API da plataforma Android com uma biblioteca do Jetpack que simplifica a integração do MCP do Android. Ele permite que seus apps se comportem como servidores MCP no dispositivo, contribuindo com funções que atuam como ferramentas para uso por recursos proativos, além de agentes e assistentes, como o Google Gemini. A partir de maio de 2026, a integração do AppFunctions com o Gemini estará em uma prévia particular com testadores confiáveis. Você já pode começar a preparar seus apps para usar o AppFunctions e as ferramentas de desenvolvimento.
Ao definir esses AppFunctions, você permite que seu app forneça serviços, dados e ações ao registro integrado ao SO Android, permitindo que os usuários concluam tarefas por meio de agentes e interações no nível do sistema.
Os AppFunctions servem como o equivalente móvel de ferramentas no Protocolo de Contexto de Modelo (MCP). Embora o MCP padronize tradicionalmente como os agentes se conectam a ferramentas do lado do servidor, os AppFunctions fornecem o mesmo mecanismo para apps Android. Isso permite que você exponha os recursos do seu app como "ferramentas" orquestráveis que apps autorizados (chamadores) podem descobrir e executar para atender às intents do usuário. Os chamadores precisam ter a EXECUTE_APP_FUNCTIONS permissão para
descobrir e executar AppFunctions, e podem incluir agentes, apps e assistentes de IA, como o Gemini.
O AppFunctions está disponível em dispositivos com o Android 16 ou mais recente.
Exemplos de casos de uso
Os AppFunctions fornecem um mecanismo eficiente para automatizar tarefas e simplificar as interações do usuário. Ao abrir os recursos do seu app, você permite que os usuários alcancem metas complexas usando linguagem natural, muitas vezes substituindo a necessidade de navegação manual e detalhada com a interface.
Os cenários a seguir ilustram como os AppFunctions podem ser usados para gerar experiências em várias categorias de apps:
Gerenciamento de tarefas e produtividade
- Solicitação do usuário: "Me lembre de retirar meu pacote no trabalho hoje às 17 h".
- Ação do AppFunction: o autor da chamada identifica o app de gerenciamento de tarefas relevante e invoca uma função para criar uma tarefa, preenchendo automaticamente os campos de título, hora e local com base no comando do usuário.
/** * Create a new task or reminder with a title, due time, and location. * * @param context The execution context provided by the system. * @param title The descriptive title of the task (e.g., "Pick up my package"). * @param dueDateTime The specific date and time when the task should be completed. * @param location The physical location associated with the task (e.g., "Work"). * @return The created Task */ @AppFunction(isDescribedByKDoc = true) suspend fun createTask( context: AppFunctionContext, title: String, dueDateTime: LocalDateTime? = null, location: String? = null ) : TaskMídia e entretenimento
- Solicitação do usuário: "Crie uma nova playlist com os melhores álbuns de jazz de este ano".
- Ação do AppFunction: o autor da chamada executa uma função de criação de playlist em um app de música, transmitindo contexto como "melhores álbuns de jazz de 2026" como a consulta para gerar a playlist imediatamente.
/** * Create a new music playlist based on a natural language query. * * @param context The execution context provided by the system. * @param query The description used to generate the playlist (e.g., "top jazz albums from 2026"). * @return The final created playlist based on songs. */ @AppFunction(isDescribedByKDoc = true) suspend fun createPlaylistFromQuery( context: AppFunctionContext, query: String ): PlaylistFluxos de trabalho entre apps
- Solicitação do usuário: "Encontre a receita de macarrão no e-mail de Lisa e adicione os ingredientes à minha lista de compras".
- Ação do AppFunction: essa solicitação usa funções de vários apps. Primeiro, o autor da chamada usa a função de pesquisa de um app de e-mail para recuperar o conteúdo. Em seguida, ele extrai os ingredientes relevantes e invoca a função de um app de lista de compras para preencher a lista do usuário.
/** * Search for emails matching a query or sender name to retrieve content like recipes. * * @param context The execution context provided by the system. * @param query The search term or contact name (e.g., "Lisa noodle recipe"). * @return A list of matching email summaries containing the requested information. */ @AppFunction(isDescribedByKDoc = true) suspend fun searchEmails( context: AppFunctionContext, query: String ): List<EmailSummary> /** * Add a list of items or ingredients to the user's active shopping list. * * @param context The execution context provided by the system. * @param items The names of the ingredients or products to add to the list. * @return The final shopping list with new items added */ @AppFunction(isDescribedByKDoc = true) suspend fun addItemsToShoppingList( context: AppFunctionContext, items: List<String> ): ShoppingListAgenda e programação
- Solicitação do usuário: "Adicione a festa de aniversário da minha mãe à minha agenda para a próxima segunda-feira às 18h".
- Ação do AppFunction: o app agêntico aprovado invoca a função "criar evento" do app Agenda , analisando o contexto relevante, como "próxima segunda-feira" e "18h", para criar a entrada sem que o usuário precise abrir a agenda manualmente.
/** * Schedule a new event on the user's primary calendar. * * @param context The execution context provided by the system. * @param title The name of the calendar event (e.g., "Mom's birthday party"). * @param startDateTime The specific date and time the event is scheduled to begin. * @return The created Event object. */ @AppFunction(isDescribedByKDoc = true) suspend fun createCalendarEvent( context: AppFunctionContext, title: String, startDateTime: LocalDateTime ): Event
Como os AppFunctions funcionam
O diagrama a seguir ilustra o fluxo típico de como os AppFunctions são compartilhados por apps com um agente e executados posteriormente. É provável que os agentes considerem as ferramentas MCP remotas do lado do servidor e os AppFunctions locais ao processar solicitações do usuário. O fluxo detalhado para usar AppFunctions locais é o seguinte:
- Declaração do AppFunction: o app Android é criado para usar AppFunctions para disponibilizar seus recursos, como "Criar nota" ou "Enviar mensagem".
- Geração de esquema: a biblioteca do Jetpack do AppFunctions gera um arquivo de esquema XML que lista todos os AppFunctions declarados no app. O SO Android usa esse arquivo para indexar os AppFunctions disponíveis.
- Recuperação de metadados: o agente pode recuperar os metadados do AppFunction consultando-os.
- Seleção e execução do AppFunction: com base nos comandos do usuário, o agente seleciona e executa o AppFunction apropriado com os parâmetros adequados.
A biblioteca do Jetpack do AppFunctions simplifica a exposição da funcionalidade do seu app.
Com o processador de anotações, você anota as funções que quer disponibilizar para os agentes. Os autores da chamada podem descobrir e invocar essas funções indexadas
usando AppFunctionManager.
Antes de invocar uma função, os autores da chamada precisam verificar se o dispositivo oferece suporte ao recurso AppFunctions tentando recuperar uma instância de AppFunctionManager. Depois de oferecer suporte, os autores da chamada podem verificar se uma
função específica está ativada em um app de destino usando
isAppFunctionEnabled(packageName,functionId). A consulta do status das
funções em outros pacotes exige a
android.permission.EXECUTE_APP_FUNCTIONSpermission.
Não é necessário que seu app verifique se o recurso AppFunction é compatível. Isso é processado automaticamente na biblioteca do Jetpack. Por exemplo,
AppFunctionManager pode verificar se o recurso é compatível ou não.
Confira um exemplo de AppFunctions para um app de anotações com recursos para criar, editar e listar notas:
/**
* A note app's [AppFunction]s.
*/
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 appFunctionContext The context in which the AppFunction is executed.
* @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)
}
/**
* Edits a single note.
*
* @param appFunctionContext The context in which the AppFunction is executed.
* @param noteId The target note's ID.
* @param title The note's title if it should be updated.
* @param content The new content if it should be updated.
*/
@AppFunction(isDescribedByKDoc = true)
suspend fun editNote(
appFunctionContext: AppFunctionContext,
noteId: Int,
title: String?,
content: String?,
): Note? {
return noteRepository.updateNote(noteId, title, content)
}
}
/**
* A note.
*/
@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
)
Amostras, habilidade e agente de teste
Disponibilizamos o seguinte para ajudar você a melhorar suas habilidades no AppFunctions:
- Confira o exemplo do AppFunctions para verificar e explorar como tudo funciona nos seus dispositivos.
- A habilidade do AppFunctions descobre e recomenda recursos do seu app que podem ser implementados como AppFunctions. Ele também pode implementar e refinar AppFunctions atuais para você.
- Para testes de ponta a ponta, use o app de agente de amostra.
Perguntas frequentes
A seção a seguir aborda as perguntas frequentes sobre o AppFunctions.
Sou um desenvolvedor de apps. Posso implementar o AppFunctions hoje?
Sim, é possível implementar e testar o AppFunctions no seu app seguindo as orientações detalhadas nas seções anteriores.
Qual é a diferença entre o AppFunctions e o MCP?
Ambos permitem que agentes de IA orquestrem ferramentas, mas têm diferenças significativas na arquitetura, latência e esforço necessário do desenvolvedor. Os AppFunctions são hooks integrados no nível do SO exclusivos do Android que são executados localmente. Por outro lado, um servidor MCP padrão é uma solução independente de plataforma que depende da execução na nuvem e de viagens de rede.
Em resumo, o desenvolvimento com o AppFunctions permite que você use o estado do app atual diretamente no dispositivo e não exige que você mantenha serviços fora do app Android.
Implementei o AppFunctions no meu app. Por que meu agente do sistema não consegue acessá-los?
Os AppFunctions são um recurso experimental. Para avaliar cuidadosamente a qualidade da experiência geral durante essa fase experimental, apenas um número limitado de apps e agentes do sistema podem acessar todo o pipeline.
Como posso preparar meu app para a disponibilidade geral do AppFunctions?
Considere quais recursos do seu app você quer expor à automação agêntica.
Você pode implementar o AppFunctions no seu app. Para fazer isso, siga as etapas nas seções anteriores desta página e verifique se elas estão registradas no dispositivo chamando adb shell cmd app_function list-app-functions.
Posso ter acesso antecipado à experiência de desenvolvedor agêntico de ponta a ponta?
Estamos conduzindo um Programa de Acesso Antecipado (EAP, na sigla em inglês) para integrar apps selecionados no teste da experiência de desenvolvedor de ponta a ponta necessária para lançar o AppFunctions na produção no Android. Você pode registrar seu interesse em integrar seus AppFunctions neste formulário de inscrição do EAP. Ao registrar seu interesse, você NÃO terá acesso automático à integração completa. Vamos enviar um e-mail se o app for selecionado para o EAP ou para informar quando o AppFunctions estiver disponível publicamente.
Como posso enviar feedback sobre o AppFunctions?
Você pode enviar feedback sobre a API registrando um problema e registrando seu interesse no formulário do Programa de Acesso Antecipado.