Google Agent Development Kit for Kotlin Reaches Feature Parity

Google shipped Agent Development Kit for Kotlin 1.0 on October 3, 2026, marking the first production-ready release of its AI agent framework for the Kotlin, Android, and JVM ecosystems. The release closes the gap that had kept Kotlin developers waiting while Python teams built with ADK, and introduces Android-specific capabilities that let agents run inference directly on device or split workloads between the handset and a remote model.

This piece breaks down what shipped in ADK for Kotlin 1.0, how it compares to the existing Python and Java editions, and what Android and JVM engineers need to do to start building production agents today.

What Google Agent Development Kit for Kotlin shipped

Google released ADK for Kotlin 1.0 as a production-ready framework targeting three surfaces simultaneously: idiomatic Kotlin applications, Android apps running on device, and JVM server workloads. The 1.0 designation signals that Google considers the API surface stable enough for production adoption, not a preview or experimental release. Unlike earlier SDK drops that required developers to wrap the Java ADK with Kotlin extensions, this release is authored for Kotlin from the ground up, exposing coroutine-friendly APIs and Kotlin-style DSLs where the Java edition uses callbacks and builder patterns.

The framework is designed to unify agent development across client and cloud. A developer can write an agent once and deploy it as an Android service running on-device inference, as a JVM microservice calling a remote model, or as a hybrid that switches between the two depending on connectivity and latency constraints. The 1.0 release includes the orchestration primitives, tool-calling abstractions, and memory interfaces that were already available in the Python edition.

What changed for builders in Google Agent Development Kit for Kotlin

The headline change is feature parity with ADK for Python. Before this release, Kotlin developers either worked through the Java ADK with verbose interop code or waited for capabilities to arrive in a later milestone.

The second major change is Android-native agent support. The framework exposes abstractions for on-device AI that map to Android's existing ML stack, meaning agents can consume local model inference without requiring a network round-trip. Hybrid routing allows a single agent definition to escalate to a cloud model when the task exceeds what the on-device model can handle.

How to install or upgrade Google Agent Development Kit for Kotlin

Add the ADK Kotlin dependency to your Gradle build file. For an Android project, add it to the module-level build.gradle.kts:

dependencies {
    implementation("com.google.adk:adk-kotlin:1.0.0")
}

For a JVM server project using Maven:

<dependency>
    <groupId>com.google.adk</groupId>
    <artifactId>adk-kotlin</artifactId>
    <version>1.0.0</version>
</dependency>

If you were previously pulling the Java ADK with Kotlin interop wrappers, remove the Java ADK dependency and replace it with the Kotlin artifact above. The Kotlin edition does not require the Java ADK as a transitive dependency. After syncing, verify the artifact resolves against Google's Maven repository; if your project does not already reference https://maven.google.com, add it to your repository block. Existing Java ADK agent code will continue to compile alongside new Kotlin ADK code during a gradual migration, since both target the JVM.

Gotchas and compatibility in Google Agent Development Kit for Kotlin

Android developers should confirm that their minSdk and compileSdk settings are sufficient for the on-device inference path. ADK for Kotlin targets Android and JVM, but on-device model inference capabilities depend on the Android ML stack, which varies by device tier and API level. Projects that previously pinned the Java ADK version should audit any custom serialization or tool-calling code before migrating; the Kotlin edition exposes a different DSL surface than the Java builder pattern, and naively copying agent definitions across will produce compile errors rather than runtime failures.

JVM server teams migrating from ADK for Python should note that while the framework reaches feature parity, the orchestration configuration format may differ between runtimes. Any agent configuration files serialized from the Python runtime should be validated against the Kotlin runtime's schema before being loaded in production. Google has not indicated a formal migration tool, so the safest path is to re-declare agent configurations using the Kotlin DSL directly rather than porting Python configuration files verbatim.

What to watch after Google Agent Development Kit for Kotlin

The most significant open question is how Google plans to evolve the on-device inference routing layer. Hybrid agent architectures that dynamically switch between local and remote models require a reliable signal for when to escalate, and the 1.0 release does not yet surface fine-grained latency or confidence thresholds to guide that decision automatically. Watch the ADK Kotlin release notes and the Android ML roadmap for updates to the routing APIs.

Android developers should also track how ADK for Kotlin integrates with Android Jetpack and Compose. The 1.0 release establishes the agent runtime, but lifecycle integration with ViewModel and coroutine scopes common in Compose-based apps will likely arrive as follow-on library support. Teams building production Android agents should design their integration layer with that anticipated Jetpack compatibility surface in mind rather than coupling tightly to the current lifecycle handling.