ADK for Kotlin 1.0: Production AI Agents on Android

Google’s ADK for Kotlin 1.0, announced on September 9, 2026, gives Android and Kotlin Multiplatform teams a production-oriented way to orchestrate AI agents across on-device and cloud models. It is not a new foundation model: it is an agent runtime and SDK for connecting models to tools, memory, user confirmation and application code. The important change is architectural—agent behaviour can now live closer to the Kotlin app stack instead of being isolated in a separate Python service.

What ADK for Kotlin 1.0 adds

Google describes the release as reaching feature parity with ADK 1.0 Core, with a Kotlin Multiplatform core and Android-first extensions. The announced integrations include:

LiteRT-LM for on-device inference and tool use.
ML Kit, currently presented in the announcement as a beta integration for selected Android capabilities.
Firebase AI Logic for cloud-hosted models and hybrid experiences.
Room for structured, durable agent state.
AppSearch for searchable local context.
Kotlin Multiplatform support for sharing agent logic beyond the Android client.

That list matters because a useful mobile agent needs more than a prompt. It needs a runtime, a tool boundary, persistence, a model-routing decision and a way to ask the user before performing a consequential action.

The practical architecture: local, cloud and shared logic

ADK for Kotlin 1.0 is best understood as an orchestration layer. The model proposes a response or tool call; the application decides what the tool is allowed to do and where the data is processed.

Layer	What it can handle	Constraint to test
Agent runtime	Instructions, tools, sessions and multi-agent coordination	Failure recovery and traceability
On-device path	Low-latency or privacy-sensitive tasks through Android integrations	Model size, RAM, battery and device coverage
Cloud path	Larger models and hybrid workflows through Firebase AI Logic	Network dependency, cost and data governance
Memory	Structured state in Room and searchable context in AppSearch	Schema changes, stale context and process death
Shared code	Kotlin Multiplatform agent logic for Android and server targets	Platform-specific APIs and deployment boundaries

The key design choice is not “local or cloud” in the abstract. It is which step deserves each path. A device can handle classification, extraction or a private first pass, while a cloud model handles a harder synthesis task. That split should be explicit in the product’s threat model and latency budget, not left to an opaque fallback.

What an Android agent can do with the SDK

A useful starting pattern is a root agent with narrow specialist tools:

The Android UI sends a user request to the root agent.
The root agent selects a specialist or a typed tool instead of receiving unrestricted application access.
Local context is read from approved stores, such as Room or AppSearch.
Sensitive actions pause for human confirmation.
The result and the relevant session state are persisted for the next interaction.

Google’s announcement illustrates this pattern with a financial assistant that can combine specialised agents and request confirmation before a transfer. The example is an architectural demonstration, not evidence that an application built with ADK is automatically safe for financial use. Teams still need authentication, authorization, audit logs, rate limits and domain-specific testing.

What it does not solve automatically

ADK for Kotlin lowers the distance between an Android codebase and an agent runtime. It does not remove the difficult production decisions:

Permissions: a tool must expose the smallest action surface possible. “Send money” is a poor tool boundary; a constrained operation with a visible confirmation step is safer.
Privacy: on-device execution can reduce data movement, but the app still needs to map every tool and memory store to a data policy.
Reliability: a model can select the wrong tool or produce malformed arguments. Validate inputs before side effects and make retries idempotent.
Device fragmentation: on-device support depends on hardware, model availability, storage and thermal conditions. Test the slowest supported device, not only a flagship.
Operations: hybrid systems add model routing, versioning, cloud costs and observability. The existing observability practices for AI agents remain relevant even when the client is written in Kotlin.

These are engineering constraints, not reasons to avoid the SDK. They define the boundary between a convincing demo and a maintainable mobile product.

A sensible adoption path

For an existing Android team, the safest first project is a read-heavy assistant with reversible actions. Start with one domain, a small tool catalogue and a clear offline policy. Then measure:

cold-start time and first useful response;
battery, memory and model-download impact on real devices;
the percentage of requests routed locally versus to the cloud;
tool-call errors, retries and confirmation abandonment;
what remains available after process death or temporary network loss.

Keep the agent contract separate from the UI. The app should be able to replace a model, disable a tool or move a step from device to server without rewriting the screen. Kotlin Multiplatform can help share the contract, but platform-specific concerns—permissions, secure storage, lifecycle and connectivity—still belong at the platform boundary.

The official Kotlin quickstart for ADK and the ADK Kotlin repository are the right starting points for checking the current API surface. The release is new, so teams should pin versions, read changelogs and verify the status of beta integrations before committing to a production dependency.

FAQ

Is ADK for Kotlin a new AI model?

No. It is an agent development kit and runtime. It coordinates models, tools, sessions and application logic; the model provider and deployment choice remain separate decisions.

Does an ADK agent run entirely on the phone?

Not necessarily. The Kotlin stack is designed to support on-device, cloud and hybrid paths. Whether a task runs locally depends on the selected model, device capability, data policy and network requirements.

Is it only for Android apps?

The release includes Android-first extensions, while the core targets Kotlin Multiplatform. That makes shared logic possible, but it does not make every Android integration portable without adaptation.

Should a team use it for an autonomous agent immediately?

Usually no. Begin with bounded tools, explicit permissions, reversible actions and observable workflows. Autonomy should be earned through tests and operating evidence, not assumed from the presence of an agent SDK.

Sources

If your team is evaluating a mobile AI agent and needs help with the architecture, tool boundaries or integration plan, contact SignorCrypto.