O AppFunctions é uma API da plataforma Android com uma biblioteca do Jetpack para simplificar 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. Em maio de 2026, a integração do AppFunctions com o Gemini estará em uma prévia particular com testadores confiáveis. Você pode começar a preparar seus apps agora 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, na sigla em inglês). Embora o MCP padronize tradicionalmente a forma 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 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( title: String, dueDateTime: LocalDateTime? = null, location: String? = null, ): Task = TODO()
Mí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 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( query: String, ): Playlist = TODO()
Fluxos 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 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( query: String, ): List<EmailSummary> = TODO() /** * Add a list of items or ingredients to the user's active shopping list. * * @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( items: List<String>, ): ShoppingList = TODO()
Agenda 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 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( title: String, startDateTime: LocalDateTime, ): Event = TODO()
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 lidar com 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 AppFunctions Jetpack 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. Além dos KDocs específicos da função, os desenvolvedores podem definir padrões e restrições operacionais no nível do app nos metadados do app para orientar a orquestração de agentes em várias ferramentas.
- 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 AppFunctions Jetpack 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 de
funções em outros pacotes requer a
android.permission.EXECUTE_APP_FUNCTIONS permissão.
Seu app não precisa verificar 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:
@RequiresApi(36) @AndroidEntryPoint @AppFunctionServiceEntryPoint( serviceName = "TaskAppFunctionService", appFunctionXmlFileName = "task_app_function_service", ) abstract class BaseTaskAppFunctionService : AppFunctionService() { @Inject internal lateinit var taskRepository: TaskRepository /** * Creates a task based on [createTaskParams]. * * @param createTaskParams The parameter to describe how to create the task. */ @AppFunction(isDescribedByKDoc = true) suspend fun createTask( createTaskParams: CreateTaskParams, ): Task = withContext(Dispatchers.IO) { // Developers can use predefined exceptions to let the agent know // why it failed. if (createTaskParams.title == null && createTaskParams.content == null) { throw AppFunctionInvalidArgumentException("Title or content should be non-null") } val id = taskRepository.createTask( createTaskParams.title, createTaskParams.content ) return@withContext taskRepository .getTask(id) ?.toTask() ?: throw AppFunctionElementNotFoundException("Task not found for ID = $id") } // Maps internal TaskEntity private fun TaskEntity.toTask() = Task(id = id, title = title, content = description) }
/** The parameter to create the task. */ @AppFunctionSerializable(isDescribedByKDoc = true) data class CreateTaskParams( /** The title of the task. */ val title: String?, /** The content of the task. */ val content: String?, ) /** The user-created task. */ @AppFunctionSerializable(isDescribedByKDoc = true) data class Task( /** The ID of the task. */ val id: String, /** The title of the task. */ val title: String, /** The content of the task. */ val content: String, )
Amostras, habilidades e ferramentas de teste
Disponibilizamos o seguinte para ajudar você a melhorar suas habilidades no AppFunctions:
- Confira a amostra do AppFunctions para verificar e conferir como tudo funciona nos seus dispositivos.
- Use a habilidade de agente do AppFunctions para acelerar
o desenvolvimento em todo o ciclo de vida de quatro etapas:
- Descoberta: analise sua base de código para identificar e recomendar recursos de alto valor para a orquestração de IA.
- Implementação e configuração: gere implementações do Kotlin e configure metadados do sistema e dependências de build.
- Refinamento do KDoc: otimize a documentação de funções e propriedades para agentes de IA e MCP do Android.
- Teste e depuração: forneça comandos adb para avaliação local e depuração no dispositivo.
- Para testes e verificações de linha de comando, use comandos adb, como
adb shell cmd app_function ..., como uma maneira direta e leve de testar o registro de funções, inspecionar descrições de metadados e executar funções no dispositivo.
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 usando este 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.