Google ADK for Kotlin 1.0 Quickstart: Android and JVM Setup

Quick answer: Google ADK for Kotlin 1.0 is now generally available for JVM, Java and Android agent projects. For a new JVM project, use Java 17+, Gradle 8+, the ADK core library and its KSP processor. For Android, choose Firebase AI for cloud Gemini, LiteRT-LM for on-device models with tool calling, or ML Kit’s Gemini Nano integration for on-device generation where its current limitations fit your app. [1][2]

Version note (checked September 13, 2026): Google’s launch example uses 1.0.0, while Maven Central now reports 1.0.1 as the latest core release. The official quickstart and some Android documentation still show older pre-1.0 coordinates, so confirm Maven Central before copying a version into production. [1][4]

What shipped in ADK for Kotlin 1.0?

The 1.0 release brings ADK Core feature parity to an idiomatic Kotlin API. Google lists hierarchical multi-agent systems, context compaction, multi-turn conversations, human approval flows, long-running tools, session resumability, Java interoperability and integrations for its enterprise agent platform. Tool schemas can be generated at compile time from @Tool and @Param annotations through KSP, avoiding runtime reflection for Kotlin tools. [1]

Target	Recommended starting backend	Best fit
JVM/server	ADK core + Gemini	Backend agents, APIs and orchestration
Android, cloud	Firebase AI Logic	Cloud Gemini with tool calling; avoids embedding a raw API key in the app
Android, on-device	LiteRT-LM	Offline/private inference with tool calling
Android, Gemini Nano	ML Kit GenAI (beta)	On-device chat or generation; the repository notes that tool calling is not yet supported

The backend distinctions above come from Google’s Android guide and repository. Device/model availability still matters, so validate on your actual supported hardware rather than assuming every Android device can run the same on-device model. [2][3]

JVM quickstart: project checklist

1. Install Java 17 or newer and Gradle 8 or newer.
2. Create a Kotlin/JVM project with Maven Central enabled.
3. Add matching versions of the ADK core and KSP processor.
4. Store the Gemini API key in an environment variable, never in source control.
5. Define one small tool and one agent before adding memory, sub-agents or external systems.
6. Run the agent in a CLI loop first; add the development web UI only after the core path works.

Google’s launch materials and official Kotlin quickstart provide the dependency and CLI-first starting path. [1] The linked official quickstart contains the complete current project structure.

1. Add the ADK dependencies

dependencies {
    implementation("com.google.adk:google-adk-kotlin-core:1.0.1")
    ksp("com.google.adk:google-adk-kotlin-processor:1.0.1")

    // Optional: local development server/UI
    implementation("com.google.adk:google-adk-kotlin-webserver:1.0.1")
}

Keep all ADK modules on the same release line. If 1.0.1 is no longer current when you read this, replace it with the latest stable version shown by Maven Central. [4]

2. Define a typed tool and agent

package com.example.agent

import com.google.adk.kt.agents.Instruction
import com.google.adk.kt.agents.LlmAgent
import com.google.adk.kt.annotations.Param
import com.google.adk.kt.annotations.Tool
import com.google.adk.kt.models.Gemini

class StatusTools {
    @Tool
    fun checkService(
        @Param("Service name to inspect") service: String
    ): Map<String, String> = mapOf(
        "service" to service,
        "status" to "unknown — connect your real monitor"
    )
}

object StatusAgent {
    @JvmField
    val rootAgent = LlmAgent(
        name = "status_agent",
        description = "Checks a named service safely.",
        model = Gemini(
            name = "gemini-flash-latest",
            apiKey = System.getenv("GOOGLE_API_KEY")
                ?: error("GOOGLE_API_KEY is not set")
        ),
        instruction = Instruction(
            "Use checkService when asked about service status. " +
            "Never claim a service is healthy without tool output."
        ),
        tools = StatusTools().generatedTools()
    )
}

The generatedTools() function is produced by KSP at build time. The example intentionally returns “unknown” until you connect a real monitoring service; do not replace missing operational data with a plausible status. Google’s launch post demonstrates the same annotation-driven pattern. [1]

3. Run it from a CLI entry point

package com.example.agent

import com.google.adk.kt.runners.ReplRunner

fun main() {
    ReplRunner(StatusAgent.rootAgent).start()
}

export GOOGLE_API_KEY="your-key"
./gradlew run

Keep the key outside the repository and outside any agent sandbox. Add .env to .gitignore if you use a local environment file.

Android setup: choose cloud, on-device or hybrid

Android uses the same agent concepts, but the runtime and model backend change. Google’s Android guide shows agents being invoked with InMemoryRunner from a coroutine and responses collected as events. For cloud inference, the project repository recommends Firebase AI rather than shipping a Google API key inside the application. [2][3]

Android dependencies from the 1.0 launch

dependencies {
    implementation("com.google.adk:google-adk-kotlin-core:1.0.1")
    ksp("com.google.adk:google-adk-kotlin-processor:1.0.1")

    // Pick only what your architecture needs:
    implementation("com.google.adk:google-adk-kotlin-firebase-android:1.0.1")
    implementation("com.google.adk:google-adk-kotlin-litertlm:1.0.1")
    implementation("com.google.adk:google-adk-kotlin-mlkit-android:1.0.1-beta")
}

Google’s announcement used the initial 1.0.0 coordinates; this guide updates the stable modules to the Maven release observed on September 13. Confirm the beta suffix and current availability of the ML Kit artifact before building because beta coordinates can move independently. [1][4]

Production safety checklist

• Require confirmation for side effects: money movement, deletion, publishing and account changes should pause for explicit approval.
• Use least-privilege tools: expose a narrow function instead of a shell or broad database credential.
• Do not trust model narration: return structured tool results and verify the external state after writes.
• Persist deliberately: choose Room/AppSearch or a server-side session store only after defining retention and deletion rules.
• Protect secrets: use Firebase AI on Android for cloud Gemini or retrieve short-lived credentials from a trusted backend.
• Keep the development UI private: Google’s repository says its server binds to loopback by default and warns that unauthenticated endpoints need your own authentication before wider exposure.
• Test failure paths: simulate quota errors, tool timeouts, missing fields, process death and rejected confirmations.

ADK 1.0 includes human-in-the-loop confirmation and resumable sessions, but the application still owns policy, authorization and verification. The launch’s financial-assistant sample explicitly says it is a demonstration and is not designed to meet compliance requirements. [1]

Common setup problems

Problem	What to check
generatedTools() is unresolved	KSP plugin is applied, processor version matches core, annotated function is supported, then clean/rebuild.
Dependency not found	Use Maven Central and check the live metadata; documentation pages may still show a pre-1.0 version.
Agent has no API key	Export GOOGLE_API_KEY in the process running Gradle; do not put it in Kotlin source.
Android cloud call needs a key	Use the Firebase AI backend rather than embedding a raw API key in the APK.
ML Kit tool call does nothing	The repository says its current Gemini Nano backend does not yet support tool calling; use LiteRT-LM or Firebase AI where appropriate.
State disappears after restart	An in-memory runner is temporary; configure a persistent session service such as the Android integrations described by Google.

Frequently asked questions

Is ADK for Kotlin 1.0 production-ready?

Google calls version 1.0 generally available and describes it as a production-ready toolkit. Individual integrations can still be beta or have limitations, so evaluate each module separately. [1]

Can ADK for Kotlin run without the cloud?

Yes, on supported Android or JVM setups you can use LiteRT-LM, and Android can use Gemini Nano through ML Kit. On-device model support and tool-calling capability differ by backend. [3]

Does ADK for Kotlin work with Java?

Yes. The 1.0 announcement lists first-party Java interoperability, allowing Java applications to call ADK Kotlin agents. [1]

Should I use version 1.0.0 or 1.0.1?

For a new project, use the newest stable matching versions available from Maven Central after reviewing the changelog. At the time of this check, the core and processor metadata reported 1.0.1, while the launch article’s original snippet showed 1.0.0. [4][1]

Official resources

1. Google Developers Blog: ADK for Kotlin 1.0 announcement
2. ADK Kotlin JVM quickstart
3. Android Developers: Build ADK agents for Android
4. Google ADK Kotlin repository, modules and examples
5. Maven Central core-version metadata