Intelligente Android-Apps erstellen: Agentische Workflows in der App
Lesezeit: 9 Minuten
Willkommen zurück bei der Blogpost-Reihe „Intelligente Android-Apps entwickeln“. Hier erfahren Sie, wie Sie eine einfache Android-App in eine personalisierte, intelligente und agentische Anwendung verwandeln. In unserem vorherigen Beitrag haben Sie erfahren, wie Sie mithilfe von AppFunctions eine Verbindung zum KI-System herstellen.
In diesem Beitrag erfahren Sie, wie Sie autonome In-App-Agentic-Workflows erstellen, die in der Cloud ausgeführt werden.
Manchmal ist eine Aufgabe zu komplex für eine einzelne Gerätesitzung. Wenn Sie beispielsweise einen kompletten Reiseplan buchen, müssen Sie Flugzeiten koordinieren, Hotelzimmer auswählen, Museumstickets reservieren und Restaurantreservierungen planen. Wenn Sie diesen mehrstufigen Prozess direkt auf einem Mobilgerät ausführen, wird die App möglicherweise geschlossen und Ihr Fortschritt geht verloren. Die Verwaltung all dieser Schritte und API-Anmeldedaten auf einem Smartphone wird ebenfalls schnell kompliziert.
Für diese langwierigen, mehrstufigen Workflows können Sie ein benutzerdefiniertes, selbst gehostetes Backend verwenden. Das Backend führt die Buchungs-Agents im Hintergrund aus, während die Android-App eine Verbindung zur Sitzung herstellt, den Fortschritt visualisiert und nur bei Bedarf Nutzereingaben anfordert.
Die Verwendung eines in der Cloud gehosteten agentischen Backends bietet einige Vorteile:
- Ausführung im Hintergrund: Buchungs-Agents werden autonom in der Cloud ausgeführt. Der Fortschritt geht also nicht verloren, wenn die mobile App in den Hintergrund wechselt oder die Internetverbindung unterbrochen wird.
- Komplexe Multi-Agenten-Orchestrierung: Ein Koordinator-Agent kann Buchungen an spezialisierte Sub-Agenten delegieren und Abhängigkeiten zwischen ihnen verwalten.
- Clientunabhängiges UI-Rendering: Das Backend beschreibt die Schnittstellenstruktur dynamisch, sodass Sie das UI-Layout aktualisieren können, ohne eine neue Clientversion zu veröffentlichen.
In Anbetracht dieser Vorteile haben wir Jetpacker einen Buchungsassistenten hinzugefügt, der Flüge, Hotels, Museen und Restaurantreservierungen koordiniert. Sehen wir uns an, wie wir ein Multi-Agenten-System mit dem Agent Development Kit (ADK) orchestriert haben, das das Agent-User Interaction-Protokoll (AG-UI) und das Agent-to-User Interface-Protokoll (A2UI) verwendet, um interaktive Karten nativ in Jetpack Compose zu senden und anzuzeigen.
Komplexe Workflows mit ADK-Agenten unterstützen
Anstatt den Orchestrierungsablauf manuell über benutzerdefinierte REST-Endpunkte oder komplexe Web-Sockets zu koordinieren, können Sie das Agent Development Kit (ADK) verwenden. Mit dem ADK können Sie Agenten definieren und mit Python-Funktionstools ausstatten, um Datenbanken abzufragen und Buchungen auszuführen.
So definieren Sie einen einfachen KI-Agenten und führen ihn mit dem ADK aus:
# 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)Wenn Sie einen KI-Agenten mit dieser Einrichtung ausführen, verwaltet das ADK die Ausführungsschritte für Sie. Der Kontext der Unterhaltung wird automatisch verfolgt, Nachrichten werden zwischen dem Nutzer und dem Modell weitergeleitet und die registrierten Tools werden ausgeführt, wenn das Modell sie anfordert. So können Sie sich auf das Schreiben einer sauberen prozeduralen Logik konzentrieren, während das Framework die Orchestrierung im Hintergrund übernimmt.
Damit dieser Backend-Agent mit unserer Jetpacker-App verbunden werden kann, muss der Server Updates in Echtzeit an das Gerät streamen können. Das wird über das AG-UI-Protokoll erledigt. Der KI-Agent benötigt außerdem eine strukturierte Möglichkeit, interaktive Komponenten (wie Optionsauswahl und Sitzpläne) dynamisch auf dem Smartphone zu beschreiben und zu aktualisieren. Hier kommt das A2UI-Protokoll ins Spiel.
Standardisierung der Kommunikation zwischen Agent und Client mit AG-UI
Für die Ausführung von KI-Agenten in der Cloud und das Rendern der Benutzeroberfläche auf Android ist ein standardmäßiger Kommunikationskanal erforderlich. Dazu verwenden Sie das AG-UI-Protokoll.
AG-UI ist ein bidirektionales Transportschichtprotokoll, das Nachrichtentypen zwischen Agenten und UI-Clients standardisiert. Der KI-Agent kann den Client über Lifecycle-Events, Textnachrichten, Toolaufrufe und die Statusverwaltung informieren. Der Client kann wiederum Textnachrichten, Toolaufrufergebnisse und benutzerdefinierte Aktionsereignisse an den Agenten senden.
Auf der Serverseite werden Aktualisierungen im Standardformat für Server-Sent Events (z. B. event: TEXT_MESSAGE_CONTENT mit dem JSON-Delta) ausgegeben. Unter Android überwacht das Kotlin SDK diesen Stream und ordnet die Nutzlasten automatisch typsicheren Clientereignissen zu:
// 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 } } }
Anschließend können Sie eine Benutzeroberfläche schreiben, um diese verschiedenen Arten von standardisierten AG-UI-Ereignissen zu rendern. So erhalten Sie die typische „Chatbot“-Erfahrung:
KI-Agenten mit A2UI die UI-Sprache beibringen
Herkömmliche Chatbots geben in der Regel Nur-Text- oder benutzerdefinierte JSON-Nutzlasten zurück. Beim Erstellen komplexer Benutzeroberflächen muss die Clientanwendung diese Nutzlasten parsen und bestimmten, vordefinierten Bildschirmen zuordnen. Dadurch entsteht eine Abhängigkeit: Jedes Mal, wenn Sie eine neue Funktion hinzufügen, das Layout ändern oder eine neue Nutzerinteraktion unterstützen, müssen Sie sowohl den Backend-Agenten als auch die mobile Anwendung aktualisieren. Dazu müssen Sie ein App-Update veröffentlichen und warten, bis Nutzer es installieren.
Verwenden Sie zur Lösung dieses Problems das A2UI-Protokoll. Mit A2UI können Agenten die UI-Komponenten beschreiben, die dynamisch auf dem Client gerendert werden sollen. Die Client-App deklariert einen Katalog der unterstützten Komponenten und der Server sendet eine JSON-Nutzlast, in der das Komponentenlayout und die Eigenschaften angegeben sind:
{
"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"
}
}
]
}
}Der Server gibt an, welche Katalogkomponenten zusammen mit ihren aktiven Attributwerten gerendert werden sollen. Dadurch werden die visuellen Implementierungsdetails des Clients sauber vom Workflowstatus des Agenten entkoppelt.
Backend-UI-Schema entwerfen
Damit der KI-Agent diese JSON-Nutzlasten korrekt generieren kann, muss er wissen, welche Komponenten verfügbar sind und welche Attribute sie akzeptieren.
Verwenden Sie dazu die ADK-A2UI-Integration. Anstatt für jede Komponente in unserem Katalog manuell Prompt-Anweisungen zu schreiben, kompiliert der A2uiSchemaManager die JSON-Schemas und Layoutanweisungen direkt in den System-Prompt. So lernt das Modell die genaue Struktur und die Formatierungsregeln, die es befolgen muss, um gültige A2UI-Nutzlasten zu generieren:
# 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"]
)Mit dieser generierten Systemanweisung wird das LLM auf das Schemalayout ausgerichtet und weiß genau, wie es Komponentenaktualisierungen formulieren muss, die der Android-Client rendern kann.
Natives Rendering von A2UI mit Jetpack Compose
Wenn Sie diese Komponentenstrukturen nativ auf Android-Geräten rendern möchten, verwenden Sie die neue Jetpack Compose A2UI Renderer-Bibliothek.
Fügen Sie zuerst die Abhängigkeiten zur Datei build.gradle.kts des Moduls hinzu:
// 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") }
Jede Komponentenklasse im Katalog (z. B. BookingStatusComponent) definiert, wie die aus der JSON-Nutzlast empfangenen Attribute einer zusammensetzbaren Jetpack Compose-Funktion zugeordnet werden.
Registrieren Sie die benutzerdefinierten Komponenten in einem Katalog:
// 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() ) ) }
Tipp: Jetpacker implementiert benutzerdefinierte Komponenten (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus), die auf Buchungsabläufe zugeschnitten sind. Wenn Ihr KI-Agent Standardelemente wie Text, Karten, Schaltflächen, Zeilen, Spalten, Kästchen und Datum-Uhrzeit-Auswahl verwendet, bietet material3-a2ui auch materialA2uiBasicCatalogV1(...). So erhalten Sie sofort einsatzbereite Material 3-Implementierungen, ohne benutzerdefinierte Komponenten schreiben zu müssen.
Hinweis: Damit das Backend und der mobile Client aufeinander abgestimmt bleiben, verwenden beide dieselbe Katalogdefinitions-ID (https://example.com/catalogs/booking_assistant/v1/catalog.json). Wenn Sie Attribute im Backend-Katalog hinzufügen oder ändern, müssen Sie die Versionsnummer erhöhen und die entsprechende Kotlin-Komponentenklasse aktualisieren, um Parsing-Fehler zu vermeiden.
Verarbeiten Sie in der BookingAssistantViewModel die A2UI-Nachrichten mit der A2uiMessageProcessor und aktualisieren Sie die aktiven Oberflächen:
// 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() } } // ... }
Erfasse diese Oberflächen auf dem Bildschirm „Compose“ und rendere jede mit dem offiziellen A2uiSurface-Composable aus androidx.compose.material3:material3-a2ui. A2uiSurface übernimmt automatisch die Beobachtung des reaktiven Komponentenstatus, die Material 3-Ladeanzeigen, die Fehler-Fallbacks und die animierten Übergänge zwischen Updates:
// 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() ) } } } }
Sie sehen jetzt mehrere UI-Oberflächen, die von unserem im Backend ausgeführten KI-Agenten generiert wurden:
Zusammenfassung
Durch das Hosten von Agent-Workflows in der Cloud und die gemeinsame Verwendung der AG-UI- und A2UI-Protokolle können wir dynamische, native Android-Oberflächen erstellen, die direkt von KI-Modellen gesteuert werden. AG-UI richtet den bidirektionalen Echtzeit-Streamingkanal für Nachrichten und Lifecycle-Events ein, während A2UI es dem Cloud-Agenten ermöglicht, interaktive UI-Komponenten dynamisch zu beschreiben. So bleibt die Clientanwendung vollständig von der schrittweisen Backend-Orchestrierungslogik entkoppelt.
Den vollständigen Quellcode für Jetpacker finden Sie auf GitHub. Im Video Intelligente Android-Apps mit der KI von Google erstellen erfahren Sie mehr darüber, wie Sie agentische Workflows direkt in Ihre App einbinden können.
Weitere Teile dieser Blogpost-Reihe:
▪️ Teil 1: Einführung in die App und allgemeiner Überblick
📱 Teil 2: On-Device-Intelligence In diesem Teil geht es um die GenAI APIs von ML Kit und Gemini Nano, mit denen Sie datenschutzorientierte Funktionen wie die Zusammenfassung von Reiseplänen, das Parsen von Belegen und die lokale Audioverarbeitung erstellen können.
☁️ Teil 3: Hybrid- und Cloud-Reasoning. Hier erfahren Sie, wie Sie mit Firebase AI Logic LLM-Antworten mit realen Daten wie Google Maps und Webinhalten fundieren können.
⚙️ Teil 4: Systemintegration. Integration in das Android-Intelligenzsystem mit AppFunctions.
🤖 Teil 5 (dieser Beitrag): Agentische Workflows in der App. Erweitern Sie die App mit End-to-End-Buchungsassistenten, die auf A2UI und ADK basieren.
Möchten Sie mehr über die Android-Entwicklung erfahren? Folgt Android-Entwickler auf YouTube oder LinkedIn.
Für alle Code-Snippets in diesem Blogpost gilt der folgende Urheberrechtshinweis:
Copyright 2026 Google LLC. SPDX-License-Identifier: Apache-2.0
-
AnleitungenWillkommen zurück bei der Blogpost-Reihe „Intelligente Android-Apps entwickeln“. Hier zeigen wir Ihnen, wie Sie eine einfache Android-App in eine personalisierte, intelligente und agentische Anwendung verwandeln.
Thomas Ezan, Jolanda Verhoef, Caren Chang • Lesezeit: 8 Minuten -
AnleitungenJetpacker ist eine technische Showcase-App, die unser Team für die diesjährige Google I/O von Grund auf neu entwickelt hat (mit Antigravity). Im Kern hilft Jetpacker Nutzern, ihr nächstes großes Abenteuer zu planen, zu erkunden und zu genießen.
Jolanda Verhoef • Lesezeit: 4 Minuten -
AnleitungenWillkommen zurück bei der Blogpost-Reihe „Intelligente Android-Apps entwickeln“. Hier zeigen wir Ihnen, wie Sie eine einfache Android-App in eine personalisierte, intelligente und agentische Anwendung verwandeln. In unserem vorherigen Beitrag haben wir Jetpacker vorgestellt, die Demo-App, die wir in dieser Reihe verwenden werden.
Caren Chang • Lesezeit: 6 Minuten
Lassen Sie sich Woche für Woche die neuesten Informationen zur Android-Entwicklung zusenden.