Building Autonomous In-App Agentic Workflows in Android with Cloud-Hosted AI and Jetpack Compose

The landscape of mobile application development is undergoing a paradigm shift as developers move beyond static user interfaces and conventional chatbots toward fully autonomous, agentic experiences. As part of an ongoing series exploring intelligent mobile architecture, Android Developer Relations Senior Developer Relations Engineer Jolanda Verhoef has detailed how developers can leverage cloud-hosted backends, the Agent Development Kit (ADK), and specialized transport protocols to construct long-running, multi-step workflows. Focusing on the sample travel application "Jetpacker," the architectural framework demonstrates how modern mobile apps can delegate complex, multi-device session tasks to cloud agents while rendering dynamic, native UI components via Jetpack Compose.

The technical challenge of executing multi-step workflows entirely on a mobile device has long plagued developers. Complex operations—such as planning a comprehensive holiday itinerary that involves securing flights, reserving hotel rooms, booking museum tickets, and arranging restaurant reservations—frequently span extended periods. Running these processes locally introduces significant vulnerabilities: if a user inadvertently closes the application or experiences a network interruption, progress is often lost. Furthermore, managing multiple third-party API credentials, heavy computational logic, and asynchronous state synchronization on resource-constrained mobile hardware quickly complicates application architecture.

To mitigate these constraints, industry architectural standards are increasingly shifting toward a hybrid model. In this setup, a custom self-hosted backend executes autonomous booking agents in the background. Meanwhile, the client-side Android application simply connects to the active session, visualizes real-time progress, and prompts the user for manual input exclusively when critical authorization is required. This cloud-centric methodology ensures that long-running transactions persist safely outside the mobile environment, optimizing battery consumption, streamlining credential security, and preventing data loss.

Orchestrating Complex Workflows via the Agent Development Kit

To manage multi-agent orchestration without relying on manually maintained REST endpoints or convoluted web socket implementations, developers can implement the Agent Development Kit (ADK). The ADK allows engineers to define specialized agents equipped with programmatic function tools capable of querying databases and executing transactional tasks.

In the Jetpacker reference application, a central coordinator agent manages a suite of subagents designed to handle distinct elements of a travel itinerary. When a user requests a vacation package, the Android client transmits the initial trip parameters to the server. The coordinator agent evaluates the request and delegates tasks to domain-specific subagents, such as a flight booker or a hotel reservation assistant. Each subagent processes its respective domain logic using registered Python function tools—such as search_flights or reserve_flight—and posts results to a shared session queue. This queue subsequently streams updates back to the mobile application in real time.

The ADK framework inherently handles execution overhead, including conversation context tracking, message routing between the user and the underlying large language model (LLM), and tool execution triggered by model requests. This abstraction allows developers to focus strictly on procedural application logic while the framework orchestrates background operations.

Standardizing Agent-Client Communication with AG-UI

Bridging the operational gap between cloud-hosted agents and native mobile user interfaces requires a robust, standardized communication channel. To achieve this, the architecture implements the AG-UI protocol, a bidirectional transport layer specifically designed to harmonize message types between backend agents and client interfaces.

AG-UI standardizes a wide array of payloads, enabling agents to broadcast lifecycle events, text messages, tool execution calls, and state management updates. Conversely, client applications can transmit user text messages, tool call results, and custom action events back to the cloud agent. On the server side, updates are yielded as standard Server-Sent Events, transmitting JSON deltas that the mobile client’s Kotlin SDK ingests and maps into type-safe client events. This structured pipeline ensures seamless synchronization between backend execution states and front-end rendering engines.

Dynamic UI Generation with A2UI

Traditional chatbot architectures typically rely on plain text or custom JSON payloads. When constructing intricate user interfaces, client applications must manually parse these payloads and map them to rigid, pre-compiled screens. Consequently, any modifications to layout designs, feature expansions, or new user interaction models necessitate simultaneous updates to both the backend agent and the mobile application, requiring developers to publish formal application updates and wait for users to install them.

To eliminate this deployment friction, the architecture incorporates the A2UI (Agent-to-User Interface) protocol. A2UI empowers cloud-hosted agents to dynamically describe the UI components that should be rendered on the client device. The mobile application pre-declares a catalog of supported components, while the server transmits lightweight JSON payloads detailing the precise component layout and associated properties.

By utilizing the ADK A2UI integration, developers can streamline this process further. Instead of manually writing exhaustive prompt instructions for every individual catalog component, the A2uiSchemaManager automatically compiles JSON schemas and layout instructions directly into the system prompt of the LLM. This grounding ensures the model strictly adheres to the formatting rules required to generate valid A2UI payloads compatible with the client-side rendering capabilities.

Native Rendering with Jetpack Compose

To render these dynamic component trees natively within the Android ecosystem, developers utilize the Jetpack Compose A2UI Renderer library. By incorporating specialized Gradle dependencies, applications gain access to runtime and UI modules designed to interpret A2UI data streams.

Custom component classes—such as InteractiveOptionPicker, SeatSelectionPicker, and BookingStatus—map properties received from server-side JSON payloads directly into Jetpack Compose composable functions. For standard UI elements, the material3-a2ui library provides pre-built Material 3 implementations, eliminating the need to write custom components for basic text, cards, buttons, checkboxes, and pickers.

Within the application’s ViewModel, an A2uiMessageProcessor monitors incoming data streams against registered component catalogs, exposing active surface models as observable StateFlows. The user interface then collects these surfaces using the official A2uiSurface composable. The rendering engine automatically manages reactive component state observation, Material 3 loading indicators, error fallbacks, and animated transitions between updates, resulting in a fluid, native user experience driven entirely by artificial intelligence models operating in the cloud.

Broader Implications and Industry Impact

The integration of cloud-hosted agentic workflows, AG-UI, and A2UI protocols represents a significant maturation in mobile application design. By decoupling the presentation layer from backend orchestration logic, developers can iterate on complex business workflows and user interface layouts instantly via the cloud, bypassing traditional app store deployment cycles for UI updates.

This methodology shifts mobile applications from static containers of pre-compiled logic into dynamic clients capable of interpreting and displaying complex, multi-agent systems on the fly. As generative AI models continue to evolve from conversational novelties into autonomous digital assistants, architectures like the one demonstrated in the Jetpacker framework provide a scalable blueprint for building reliable, long-running, and deeply personalized enterprise and consumer applications on Android.

Developers seeking to examine the practical implementation of these concepts can access the complete source code via the official Android AI samples repository on GitHub, or review the comprehensive documentation and video resources provided through the Android Developer Relations channel.