Instruções

Crie apps Android inteligentes: Agentic Workflows no app

Leitura de 9 min
Ver o perfil de Jolanda Verhoef
Jolanda Verhoef Engenheiro de relações com desenvolvedores

Este é mais um post da série "Criar apps Android inteligentes", em que você transforma um app Android básico em uma experiência personalizada, inteligente e agêntica. Na postagem anterior, você aprendeu a se conectar ao sistema de inteligência usando as AppFunctions.

Neste post, você vai aprender a criar Agentic Workflows no app autônomos em execução na nuvem.

Às vezes, uma tarefa é muito complexa para uma única sessão de dispositivo. Por exemplo, reservar um itinerário de férias completo envolve coordenar horários de voos, selecionar quartos de hotel, reservar ingressos para museus e fazer reservas em restaurantes. Se você executar esse processo de várias etapas diretamente em um dispositivo móvel, o app poderá ser fechado e perder seu progresso. Gerenciar todas essas etapas e credenciais de API em um smartphone também se torna complicado rapidamente.

Para esses fluxos de trabalho de longa duração e várias etapas, use um back-end personalizado auto-hospedado. O back-end executa os agentes de reserva em segundo plano, enquanto o app Android se conecta à sessão, visualiza o progresso e solicita a entrada do usuário apenas quando necessário.

O uso de um back-end agêntico hospedado na nuvem oferece algumas vantagens:

  • Execução em segundo plano: os agentes de reserva são executados de forma autônoma na nuvem. Assim, o progresso nunca é perdido se o app para dispositivos móveis for para segundo plano ou perder a conexão de Internet.
  • Orquestração complexa de vários agentes: um agente coordenador pode delegar reservas a subagentes especializados e lidar com as dependências entre eles.
  • Renderização de interface independente do cliente: o back-end descreve a estrutura da interface de forma dinâmica, permitindo que você atualize o layout da interface sem lançar uma nova versão do cliente.
booking-assistant.png
O assistente de agendamento mostra todo o progresso das reservas, organizado por tipo de evento.

Com esses benefícios em mente, adicionamos um assistente de reservas ao Jetpacker que coordena voos, hotéis, museus e reservas de restaurantes. Vamos ver como orquestramos um sistema multiagente com o Kit de Desenvolvimento de Agente (ADK), o protocolo de interação entre agente e usuário (AG-UI) e o protocolo de interface entre agente e usuário (A2UI) para enviar e mostrar cards interativos de forma nativa no Jetpack Compose.

Como potencializar fluxos de trabalho complexos com agentes do ADK

Em vez de coordenar o fluxo de orquestração manualmente usando endpoints REST personalizados ou WebSockets complexos, use o Kit de Desenvolvimento de Agente (ADK). Com o ADK, é possível definir agentes e equipá-los com ferramentas de função do Python para consultar bancos de dados e fazer reservas.

diagram.png
O app Android envia os dados do itinerário da viagem atual para o servidor. O agente coordenador escolhe quais subagentes acionar. Cada subagente fornece os resultados para uma fila de sessão compartilhada que os transmite de volta ao app Android.

Veja como definir um agente simples e executá-lo usando o ADK:

# server/main.py

# Note: ADK supports many different coding languages. For now, we use the Python version as it includes support for A2UI which we'll use later in this blog post.

from google.adk import Agent
from google.adk.runners import InMemoryRunner
from google.adk.tools import FunctionTool

# Define custom tools to interact with database
def search_flights(destination: str, date: str) -> list[str]:
    # In production, here you would query our flight database and return dynamic results
    return ["10:00 AM", "2:00 PM"]

def reserve_flight(flight_time: str) -> str:
    # In production, here you would save the reservation transaction
    return "Reserved flight at " + flight_time

# Instantiate the booking agent with specialized tools
flight_agent = Agent(
    name="Flight Booker",
    model="gemini-3.1-flash-lite",
    instruction="Help the user search for flights and book a reservation.",
    tools=[
        FunctionTool(search_flights),
        FunctionTool(reserve_flight, require_confirmation=True)
    ]
)

# Run the agent in memory using a session ID
runner = InMemoryRunner(flight_agent)
async for event in runner.run_async(user_id=user_id, session_id=session_id):
    if event.content:
        print("Agent said:", event.content)

Quando você executa um agente usando essa configuração, o ADK gerencia as etapas de execução para você. Ele rastreia automaticamente o contexto da conversa, encaminha mensagens entre o usuário e o modelo e executa as ferramentas registradas quando o modelo as solicita. Isso permite que você se concentre em escrever uma lógica de procedimento limpa, enquanto o framework lida com a orquestração em segundo plano.

web_debug.png


Para conectar esse agente de back-end ao nosso app Jetpacker, o servidor precisa de uma maneira de transmitir atualizações em tempo real para o dispositivo, o que é feito usando o protocolo AG-UI. O agente também precisa de uma maneira estruturada de descrever e atualizar componentes interativos (como seletores de opções e grades de assentos) de forma dinâmica no smartphone, que é onde o protocolo A2UI entra.

Padronização da comunicação entre agente e cliente com a AG-UI

A execução de agentes na nuvem e a renderização da interface no Android exigem um canal de comunicação padrão. Para isso, você vai usar o protocolo AG-UI.

A AG-UI é um protocolo de camada de transporte bidirecional que padroniza os tipos de mensagem entre agentes e clientes de UI. O agente pode informar o cliente sobre eventos de ciclo de vida, mensagens de texto, chamadas de ferramentas e gerenciamento de estado. O cliente, por sua vez, pode enviar mensagens de texto do usuário, resultados de chamadas de ferramentas e eventos de ações personalizadas de volta ao agente.

No lado do servidor, ele gera atualizações formatadas como eventos padrão enviados pelo servidor (como event: TEXT_MESSAGE_CONTENT contendo o delta JSON). No Android, o SDK do Kotlin detecta esse stream e mapeia automaticamente os payloads para eventos de cliente com segurança de tipos:

// BookingAssistantViewModel.kt

import com.agui.client.agent.HttpAgent
import com.agui.client.agent.HttpAgentConfig
import com.agui.core.types.RunAgentInput
import com.agui.core.types.UserMessage
import com.agui.core.types.TextMessageStartEvent
import com.agui.core.types.TextMessageContentEvent
import com.agui.core.types.TextMessageEndEvent

val config = HttpAgentConfig(
    agentId = "booking-assistant",
    threadId = threadId,
    url = "https://<your-backend-url>"
)
val agent = HttpAgent(config, httpClient)

// Set up the input with the session thread and user instruction
val input = RunAgentInput(
    threadId = threadId,
    runId = runId,
    messages = listOf(UserMessage("Book a flight to Paris"))
)

// Run the agent flow and collect lifecycle events
agent.runAgentObservable(input)
    .collect { event ->
        when (event) {
            is TextMessageStartEvent -> { /* ... */ }
            is TextMessageContentEvent -> { /* ... */ }
            is TextMessageEndEvent -> {
                // Handle the completed message
            }
        }
    }

Em seguida, você pode criar uma interface para renderizar esses diferentes tipos de eventos padronizados da AG-UI. Isso vai proporcionar a experiência típica de um chatbot:

manage_bookings.png
Uma interface básica que permite ao usuário conversar com um assistente.

Permitir que o agente fale com a interface usando a A2UI

Os chatbots tradicionais geralmente retornam texto simples ou payloads JSON personalizados. Ao criar interfaces complexas, o aplicativo cliente precisa analisar esses payloads e mapeá-los para telas específicas pré-criadas. Isso cria uma dependência: sempre que você adiciona um novo recurso, muda o layout ou oferece suporte a uma nova interação do usuário, é necessário atualizar o agente de back-end e o aplicativo para dispositivos móveis. Isso exige a publicação de uma atualização do app e que os usuários a instalem.

Para resolver isso, use o protocolo A2UI. A A2UI permite que os agentes descrevam os componentes da interface que serão renderizados no cliente de forma dinâmica. O app cliente declara um catálogo de componentes compatíveis, e o servidor envia um payload JSON especificando o layout e as propriedades do componente:

{
  "version": "v0.9",
  "updateComponents": {
    "surfaceId": "Flight Reservation",
    "components": [
      {
        "id": "flight_option_picker",
        "component": "InteractiveOptionPicker",
        "properties": {
          "prompt": "Select a flight time:",
          "options": [
            "10:00 AM",
            "2:00 PM"
          ],
          "selectedIdx": null,
          "confirmBtnText": "Confirm Flight"
        }
      }
    ]
  }
}

O servidor especifica quais componentes do catálogo serão renderizados, junto com os valores de propriedade ativos, separando de forma clara os detalhes de implementação visual do cliente do estado do fluxo de trabalho do agente.

Como projetar o esquema de UI de back-end

Para que o agente gere esses payloads JSON corretamente, ele precisa saber quais componentes estão disponíveis e quais propriedades eles aceitam.

Para isso, use a integração do ADK com a A2UI. Em vez de escrever manualmente as instruções de comando para cada componente do nosso catálogo, o A2uiSchemaManager compila os esquemas JSON e as instruções de layout diretamente no comando do sistema. Isso garante que o modelo aprenda a estrutura exata e as regras de formatação que precisa seguir para gerar payloads válidos da A2UI:

# server/main.py

from a2ui.schema.manager import A2uiSchemaManager
from a2ui.schema.constants import VERSION_0_9
from a2ui.schema.catalog import CatalogConfig
from a2ui.basic_catalog.provider import BasicCatalog

# Initialize A2UI Schema Manager with custom booking component catalog
schema_manager = A2uiSchemaManager(
    version=VERSION_0_9,
    catalogs=[
        BasicCatalog.get_config(version=VERSION_0_9),
        CatalogConfig.from_path(
            name="https://example.com/catalogs/booking_assistant/v1/catalog.json",
            catalog_path="booking_catalog.json"
        )
    ]
)

# Compile prompt instructions including the A2UI JSON schema
A2UI_SYSTEM_INSTRUCTION = schema_manager.generate_system_prompt(
    role_description="You are a helpful travel booking assistant.",
    ui_description="Use InteractiveOptionPicker for choices, SeatSelectionPicker for seat selection...",
    include_schema=True,
    include_examples=True,
    allowed_components=["InteractiveOptionPicker", "SeatSelectionPicker", "BookingStatus"]
)

Com essa instrução de sistema gerada, o LLM é fundamentado no layout do esquema e sabe exatamente como formular atualizações de componentes que o cliente Android é capaz de renderizar.

Renderização nativa da A2UI com o Jetpack Compose

Para renderizar essas árvores de componentes de forma nativa no Android, use a nova biblioteca do renderizador da A2UI do Jetpack Compose.

Primeiro, adicione as dependências ao arquivo build.gradle.kts do módulo:

// android/feature/trip/booking_assistant/build.gradle.kts
dependencies {
    implementation("androidx.a2ui:a2ui-model:1.0.0-alpha01")
    implementation("androidx.a2ui.compose:compose-runtime:1.0.0-alpha01")
    implementation("androidx.a2ui.compose:compose-ui:1.0.0-alpha01")
    implementation("androidx.compose.material3:material3-a2ui:1.0.0-alpha01")
}

Cada classe de componente no catálogo (como BookingStatusComponent) define como mapear as propriedades recebidas do payload JSON para uma função combinável do Jetpack Compose.

Registre os componentes personalizados em um catálogo:

// CustomBookingAssistantCatalog.kt

import androidx.a2ui.compose.ui.A2uiCatalog

fun bookingAssistantCatalog(): A2uiCatalog {
    return A2uiCatalog(
        catalogId = "https://example.com/catalogs/booking_assistant/v1/catalog.json",
        components = listOf(
            InteractiveOptionPickerComponent(),
            SeatSelectionPickerComponent(),
            BookingStatusComponent()
        )
    )
}

Dica: o Jetpacker implementa componentes personalizados (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) adaptados para fluxos de reserva. Se o agente usa elementos padrão (como texto, cards, botões, linhas, colunas, caixas de seleção e seletores de data e hora), o material3-a2ui também oferece o materialA2uiBasicCatalogV1(...), que disponibiliza implementações do Material 3 prontas para uso sem que você precise criar componentes personalizados.

Observação: para manter o back-end e o cliente móvel alinhados, ambos dependem do mesmo ID de definição de catálogo (https://example.com/catalogs/booking_assistant/v1/catalog.json). Se você adicionar ou modificar propriedades no catálogo de back-end, aumente o número da versão e atualize a classe de componente Kotlin correspondente para evitar erros de análise.

No BookingAssistantViewModel, processe as mensagens do A2UI usando o A2uiMessageProcessor e atualize as plataformas ativas:

// BookingAssistantViewModel.kt
import androidx.lifecycle.ViewModel
import androidx.a2ui.model.processor.A2uiSurfaceModel
import androidx.a2ui.compose.ui.A2uiMessageProcessor
import kotlinx.coroutines.flow.StateFlow

class BookingAssistantViewModel : ViewModel() {
    private val messageProcessor = A2uiMessageProcessor(
        catalogs = listOf(bookingAssistantCatalog())
    )
    val activeSurfaces: StateFlow<List<A2uiSurfaceModel>> = messageProcessor.activeSurfaces
    
    init {
        viewModelScope.launch(Dispatchers.Default) { processor.collectMessages() }
    }

    // ...
}

Na tela do Compose, colete essas superfícies e renderize cada uma usando o elemento combinável oficial A2uiSurface do androidx.compose.material3:material3-a2ui. A A2uiSurface processa automaticamente a observação do estado do componente reativo, os indicadores de carregamento do Material 3, os substitutos de erro e as transições animadas entre as atualizações:

// BookingAssistantScreen.kt
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.a2ui.A2uiSurface

@Composable
fun BookingAssistantScreen(
    viewModel: BookingAssistantViewModel,
    modifier: Modifier = Modifier
) {
    val activeSurfaces by viewModel.activeSurfaces.collectAsState()
    LazyColumn(
        modifier = modifier.fillMaxWidth(),
        verticalArrangement = Arrangement.spacedBy(16.dp)
    ) {
        items(activeSurfaces) { surfaceModel ->
            Card(modifier = Modifier.fillMaxWidth()) {
                A2uiSurface(
                    surfaceModel = surfaceModel,
                    modifier = Modifier.fillMaxWidth().wrapContentHeight()
                )
            }
        }
    }
}

Agora você vai ver várias superfícies de interface geradas pelo nosso agente em execução no back-end:

booking-assistant.png
Um assistente de reservas bem projetado que usa a interface em vez de texto para interagir com o usuário.

Resumo geral

Ao hospedar fluxos de trabalho de agentes na nuvem e usar os protocolos AG-UI e A2UI juntos, podemos criar interfaces dinâmicas e nativas do Android, orientadas diretamente por modelos de IA. A AG-UI estabelece o canal de streaming bidirecional em tempo real para mensagens e eventos de ciclo de vida, enquanto a A2UI permite que o agente de nuvem descreva dinamicamente componentes interativos da interface, mantendo o aplicativo cliente perfeitamente dissociado da lógica de orquestração de back-end passo a passo.

Confira o código-fonte completo do Jetpacker no GitHub e assista ao vídeo Criar apps Android inteligentes com a IA do Google para saber mais sobre como integrar Agentic Workflows diretamente no seu app.

Confira as outras partes desta série de postagens do blog:
▪️ Parte 1: introdução ao app e uma visão geral de alto nível.
📱 Parte 2: inteligência no dispositivo. Conheça as APIs de IA generativa do Kit de ML e o Gemini Nano para criar recursos com foco em privacidade, como resumo de itinerários, análise de recibos e processamento de áudio local.
☁️ Parte 3: raciocínio híbrido e na nuvem. Saiba como usar a Firebase AI Logic para embasar as respostas de LLMs em dados do mundo real, como o Google Maps e o contexto da Web.
⚙️ Parte 4: integração do sistema. Integração com o sistema de inteligência do Android usando AppFunctions.
🤖 Parte 5 (este post!): Agentic Workflows no app. Amplie o app com assistentes de reserva completos, com tecnologia da A2UI e do ADK.

Quer saber mais sobre o desenvolvimento para Android? Siga o Desenvolvedores Android no YouTube ou no LinkedIn!

Todos os snippets de código neste post do blog seguem o seguinte aviso de direitos autorais:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Escrito por:
Continue lendo