O AppFunctions é uma API da plataforma Android com uma biblioteca Jetpack (link em inglês) para simplificar a integração do MCP no 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. Em maio de 2026, a integração do AppFunctions com o Gemini estará em prévia particular com trusted testers. Você já pode começar a preparar seus apps para usar o AppFunctions e as ferramentas de desenvolvimento.
Ao definir essas 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.
As AppFunctions são o equivalente móvel das ferramentas no Protocolo de Contexto de Modelo (MCP). Embora o MCP padronize tradicionalmente como os agentes
se conectam a ferramentas do lado do servidor, as AppFunctions oferecem o mesmo mecanismo para
apps Android. Isso permite expor os recursos do app como "ferramentas" orquestráveis
que apps autorizados (chamadores) podem descobrir e executar para atender às
intenções do usuário. Os chamadores precisam ter a permissão EXECUTE_APP_FUNCTIONS 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 Android 16 ou versões mais recentes.
Exemplos de casos de uso
As AppFunctions oferecem um mecanismo eficiente para automatizar tarefas e simplificar as interações do usuário. Ao abrir as funcionalidades do app, você permite que os usuários alcancem metas complexas usando linguagem natural, muitas vezes substituindo a necessidade de navegação manual e gradual com a interface.
Os cenários a seguir ilustram como o AppFunctions pode ser usado para impulsionar experiências em várias categorias de apps:
Gerenciamento de tarefas e produtividade
- Comando do usuário: "Me lembre de retirar meu pacote no trabalho hoje às 17h".
- Ação 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
- Comando do usuário: "Crie uma playlist com os melhores álbuns de jazz deste ano".
- Ação AppFunction: o usuário 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 da Lisa e adicione os ingredientes à minha lista de compras".
- Ação AppFunction: essa solicitação usa funções de vários apps. Primeiro, o usuário 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 uma função de 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
- Comando 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 AppFunction: o app agente aprovado invoca a função "criar evento" do app de 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 as AppFunctions funcionam
O diagrama a seguir ilustra o fluxo típico de como as AppFunctions são compartilhadas por apps com um agente e executadas posteriormente. É provável que os agentes considerem as ferramentas MCP remotas do lado do servidor e as AppFunctions locais ao processar solicitações do usuário. O fluxo detalhado para usar AppFunctions locais é o seguinte:
- Declaração AppFunction: o app Android é criado para usar AppFunctions e disponibilizar recursos como "Criar nota" ou "Enviar mensagem".
- Geração de esquema: a biblioteca AppFunctions do Jetpack gera um arquivo de esquema XML que lista todas as AppFunctions declaradas no app. O SO Android usa esse arquivo para indexar as AppFunctions disponíveis.
- Recuperação de metadados: o agente pode recuperar metadados de AppFunction consultando-os.
- Seleção e execução de AppFunction: com base nos comandos do usuário, o agente seleciona e executa a AppFunction adequada com os parâmetros apropriados.
A biblioteca AppFunctions do Jetpack simplifica a exposição da funcionalidade do app.
Com o processador de anotações, você anota as funções que quer disponibilizar para os agentes. Os chamadores podem descobrir e invocar essas funções indexadas usando AppFunctionManager.
Antes de invocar uma função, os chamadores precisam verificar se o dispositivo é compatível com o recurso
AppFunctions tentando recuperar uma instância de
AppFunctionManager. Quando estiver disponível, os chamadores poderão verificar se uma função específica
está ativada em um app de destino usando
isAppFunctionEnabled(packageName,functionId). Para consultar o status de
funções em outros pacotes, é necessário o
android.permission.EXECUTE_APP_FUNCTIONSpermission.
Não é necessário que o app verifique se o recurso AppFunction é compatível. Isso é processado automaticamente na biblioteca 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 observações:
/**
* 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
)
Perguntas frequentes
A seção a seguir aborda perguntas frequentes sobre o AppFunctions.
Sou desenvolvedor de apps. Posso implementar o AppFunctions hoje?
Sim, é possível implementar e testar AppFunctions no seu app seguindo as orientações detalhadas nas seções anteriores.
Qual é a diferença entre AppFunctions e MCP?
Ambos permitem que os agentes de IA orquestrem ferramentas, mas têm diferenças significativas na arquitetura, na latência e no esforço necessário do desenvolvedor. As 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 ida e volta na rede.
Em resumo, o desenvolvimento com AppFunctions permite usar o estado do app atual diretamente no dispositivo e não exige que você mantenha serviços fora do seu app Android.
Implementei AppFunctions no meu app. Por que meu agente de sistema não consegue acessar essas funções?
As 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 pode acessar todo o pipeline.
Como posso preparar meu app para a disponibilidade geral do AppFunctions?
Considere quais recursos do app você quer expor à automação com agentes.
Você pode implementar o AppFunctions no seu app. Para 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êntica de ponta a ponta?
Estamos realizando um Programa de acesso antecipado (PAA) para integrar alguns apps e testar a experiência de desenvolvedor completa necessária para lançar o AppFunctions em produção no Android. Registre seu interesse em integrar suas AppFunctions usando este formulário de inscrição no PAA. Ao registrar seu interesse, você NÃO recebe acesso automático à integração completa. Vamos enviar um e-mail se o app for selecionado para o EAP ou para avisar quando as AppFunctions estiverem disponíveis ao público.
Como posso dar feedback sobre o AppFunctions?
Para enviar feedback sobre a API, registre um problema e mostre seu interesse no formulário do Programa de acesso antecipado.