Instructivos

Crea apps para Android inteligentes: Flujos de trabajo de agentes en la app

Lectura de 9 min
Ver el perfil de Jolanda Verhoef
Jolanda Verhoef Ingeniero de relaciones con desarrolladores

Te damos la bienvenida de nuevo a la serie de entradas de blog "Crea apps inteligentes para Android", en la que tomarás una app básica para Android y la transformarás en una experiencia personalizada, inteligente y basada en agentes. En nuestra publicación anterior, aprendiste a conectarte al sistema de inteligencia con AppFunctions.

En esta publicación, aprenderás a crear flujos de trabajo de agentes integrados en la app autónomos que se ejecutan en la nube.

A veces, una tarea es demasiado compleja para una sola sesión de dispositivo. Por ejemplo, reservar un itinerario de vacaciones completo implica coordinar los horarios de los vuelos, seleccionar las habitaciones de hotel, reservar las entradas a los museos y planificar las reservas en restaurantes. Si ejecutas este proceso de varios pasos directamente en un dispositivo móvil, es posible que la app se cierre y pierdas el progreso. Administrar todos estos pasos y las credenciales de la API en un teléfono también se vuelve complicado rápidamente.

Para estos flujos de trabajo de varios pasos y de larga duración, puedes usar un backend personalizado alojado de forma independiente. El backend ejecuta los agentes de reserva en segundo plano, mientras que la app para Android se conecta a la sesión, visualiza el progreso y solicita la entrada del usuario solo cuando es necesario.

Usar un backend de agentes alojado en la nube ofrece algunas ventajas:

  • Ejecución en segundo plano: Los agentes de reservas se ejecutan de forma autónoma en la nube, por lo que el progreso nunca se pierde si la app para dispositivos móviles pasa a segundo plano o pierde la conectividad a Internet.
  • Orquestación multiagente compleja: Un agente coordinador puede delegar reservas a agentes secundarios especializados y controlar las dependencias entre ellos.
  • Renderización de la IU independiente del cliente: El backend describe la estructura de la interfaz de forma dinámica, lo que te permite actualizar el diseño de la IU sin lanzar una nueva versión del cliente.
booking-assistant.png
El asistente de reservas muestra todo el progreso de las reservas, organizado por tipo de evento.

Teniendo en cuenta estos beneficios, agregamos un asistente de reservas a Jetpacker que coordina vuelos, hoteles, museos y reservas de restaurantes. Veamos cómo organizamos un sistema multiagente con la tecnología del Kit de desarrollo de agentes (ADK), con el protocolo de interacción entre agente y usuario (AG-UI) y el protocolo de interfaz entre agente y usuario (A2UI) para enviar y mostrar tarjetas interactivas de forma nativa en Jetpack Compose.

Potencia flujos de trabajo complejos con agentes del ADK

En lugar de coordinar el flujo de organización de forma manual con extremos de REST personalizados o sockets web complejos, puedes usar el Kit de desarrollo de agentes (ADK). Con el ADK, puedes definir agentes y equiparlos con herramientas de funciones de Python para consultar bases de datos y realizar reservas.

diagram.png
La app para Android envía los datos del itinerario del viaje actual al servidor. El agente coordinador elige qué agentes secundarios activar. Cada agente secundario proporciona sus resultados a una cola de sesión compartida que los transmite de vuelta a la app para Android.

A continuación, se muestra cómo definir un agente simple y ejecutarlo con el 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)

Cuando ejecutas un agente con esta configuración, el ADK administra los pasos de ejecución por ti. Realiza un seguimiento automático del contexto de la conversación, enruta los mensajes entre el usuario y el modelo, y ejecuta las herramientas registradas cuando el modelo las solicita. Esto te permite enfocarte en escribir una lógica de procedimiento limpia mientras el framework se encarga de la organización en segundo plano.

web_debug.png


Para conectar este agente de backend a nuestra app de Jetpacker, el servidor necesita una forma de transmitir actualizaciones en tiempo real al dispositivo, lo que se controla con el protocolo AG-UI. El agente también necesita una forma estructurada de describir y actualizar los componentes interactivos (como los selectores de opciones y las cuadrículas de asientos) de forma dinámica en el teléfono, que es donde entra en juego el protocolo A2UI.

Estandariza la comunicación entre el agente y el cliente con AG-UI

Ejecutar agentes en la nube y renderizar la IU en Android requiere un canal de comunicación estándar. Para ello, usarás el protocolo AG-UI.

AG-UI es un protocolo de capa de transporte bidireccional que estandariza los tipos de mensajes entre los agentes y los clientes de la IU. El agente puede informar al cliente sobre los eventos del ciclo de vida, los mensajes de texto, las llamadas a herramientas y la administración de estados. A su vez, el cliente puede enviar mensajes de texto del usuario, resultados de llamadas a herramientas y eventos de acciones personalizadas de vuelta al agente.

En el servidor, genera actualizaciones con el formato de eventos estándar enviados por el servidor (como event: TEXT_MESSAGE_CONTENT, que contiene la diferencia de JSON). En Android, el SDK de Kotlin escucha este flujo y asigna automáticamente las cargas útiles a eventos de cliente con seguridad 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
            }
        }
    }

Luego, puedes escribir una IU para renderizar estos diferentes tipos de eventos estandarizados de AG-UI. Esto te dará la experiencia prototípica de un "chatbot":

manage_bookings.png
Una interfaz básica que permite que un usuario chatee con un asistente.

Permite que el agente entienda la IU con A2UI

Los chatbots tradicionales suelen devolver texto sin formato o cargas útiles de JSON personalizadas. Cuando se crean interfaces complejas, la aplicación cliente debe analizar estas cargas útiles y asignarlas a pantallas específicas compiladas previamente. Esto crea una dependencia: cada vez que agregas una función nueva, cambias el diseño o admites una interacción del usuario nueva, debes actualizar el agente de backend y la aplicación para dispositivos móviles. Para ello, debes publicar una actualización de la app y esperar a que los usuarios la instalen.

Para resolver este problema, usa el protocolo A2UI. A2UI permite que los agentes describan los componentes de la IU que se renderizarán en el cliente de forma dinámica. La app cliente declara un catálogo de componentes que admite, y el servidor envía una carga útil de JSON que especifica el diseño y las propiedades de los componentes:

{
  "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"
        }
      }
    ]
  }
}

El servidor especifica qué componentes del catálogo se deben renderizar junto con sus valores de propiedad activos, lo que desvincula de forma clara los detalles de la implementación visual del cliente del estado del flujo de trabajo del agente.

Diseña el esquema de la IU del backend

Para que el agente genere estas cargas útiles de JSON correctamente, necesita saber qué componentes están disponibles y qué propiedades aceptan.

Para ello, usa la integración de A2UI del ADK. En lugar de escribir manualmente instrucciones de instrucciones para cada componente de nuestro catálogo, A2uiSchemaManager compila sus esquemas JSON y las instrucciones de diseño directamente en la instrucción del sistema. Esto garantiza que el modelo aprenda la estructura exacta y las reglas de formato que debe seguir para generar cargas útiles de A2UI válidas:

# 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"]
)

Con esta instrucción del sistema generada, el LLM se basa en el diseño del esquema y sabe exactamente cómo formular actualizaciones de componentes que el cliente de Android puede renderizar.

Renderización nativa de A2UI con Jetpack Compose

Para renderizar estos árboles de componentes de forma nativa en Android, usa la nueva biblioteca de renderizador de A2UI de Jetpack Compose.

Primero, agrega las dependencias al archivo build.gradle.kts de nuestro 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 clase de componente del catálogo (como BookingStatusComponent) define cómo asignar las propiedades recibidas de la carga útil de JSON a una función de componibilidad de Jetpack Compose.

Registra los componentes personalizados en un 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()
        )
    )
}

Sugerencia: Jetpacker implementa componentes personalizados (InteractiveOptionPicker, SeatSelectionPicker y BookingStatus) adaptados para los flujos de reserva. Si tu agente usa elementos estándar (como texto, tarjetas, botones, filas, columnas, casillas de verificación y selectores de fecha y hora), material3-a2ui también proporciona materialA2uiBasicCatalogV1(...), lo que te brinda implementaciones de Material 3 listas para usar sin escribir ningún componente personalizado.

Nota: Para mantener alineados el backend y el cliente móvil, ambos se basan en el mismo ID de definición de catálogo (https://example.com/catalogs/booking_assistant/v1/catalog.json). Si agregas o modificas propiedades en el catálogo de backend, debes aumentar el número de versión y actualizar la clase de componente de Kotlin coincidente para evitar errores de análisis.

En BookingAssistantViewModel, procesa los mensajes de A2UI con A2uiMessageProcessor y actualiza nuestras plataformas activas:

// 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() }
    }

    // ...
}

En la pantalla de Compose, recopila estas plataformas y renderiza cada una con el elemento A2uiSurface componible oficial de androidx.compose.material3:material3-a2ui. A2uiSurface controla automáticamente la observación del estado de los componentes reactivos, los indicadores de carga de Material 3, las alternativas de error y las transiciones animadas entre actualizaciones:

// 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()
                )
            }
        }
    }
}

Ahora verás varias plataformas de IU generadas por nuestro agente que se ejecuta en el backend:

booking-assistant.png
Un asistente de reservas bien diseñado que se basa en la IU en lugar de texto para interactuar con el usuario.

Resumen

Si alojamos los flujos de trabajo de los agentes en la nube y usamos los protocolos AG-UI y A2UI juntos, podemos crear interfaces nativas y dinámicas de Android impulsadas directamente por modelos de IA. AG-UI establece el canal de transmisión bidireccional en tiempo real para los mensajes y los eventos del ciclo de vida, mientras que A2UI permite que el agente de la nube describa de forma dinámica los componentes interactivos de la IU, lo que mantiene la aplicación cliente perfectamente desacoplada de la lógica de organización del backend paso a paso.

Consulta el código fuente completo de Jetpacker en GitHub y mira el video Crea apps para Android inteligentes con la IA de Google para obtener más información sobre cómo integrar flujos de trabajo de agentes directamente en tu app.

Consulta las otras partes de esta serie de entradas de blog:
▪️ Parte 1: Introducción de la app y descripción general de alto nivel.
📱 Parte 2: Inteligencia integrada en el dispositivo. Profundiza en las APIs de IA generativa de ML Kit y Gemini Nano para crear funciones que prioricen la privacidad, como el resumen de itinerarios, el análisis de recibos y el procesamiento de audio local.
☁️ Parte 3: Razonamiento híbrido y en la nube. Explora cómo usar Firebase AI Logic para fundamentar las respuestas de los LLM en datos del mundo real, como Google Maps y el contexto web.
⚙️ Parte 4: Integración del sistema. Integración con el sistema de inteligencia de Android con AppFunctions
🤖 Parte 5 (esta publicación): Flujos de trabajo de agentes en la app Extiende la app con asistentes de reservas de extremo a extremo con la tecnología de A2UI y ADK.

¿Te interesa obtener más información sobre el desarrollo para Android? Sigue a Android Developers en YouTube o LinkedIn.

Todos los fragmentos de código de esta entrada de blog siguen el siguiente aviso sobre derechos de autor:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Escrito por:
Seguir leyendo