Announcing ADK for Kotlin & ADK for Android 0.1.0 — Building AI Agents on Android and Beyond 🚀

Google introduces Agent Development Kit (ADK) for Kotlin and Android, bringing powerful agentic AI workflows to mobile, backend, and edge computing.

AI on Android is entering a completely new era.

At Google I/O 2026, Google officially announced ADK for Kotlin and ADK for Android 0.1.0, extending the Agent Development Kit ecosystem beyond Python, Java, and Go.

This release enables developers to build intelligent multi-agent AI systems directly in Kotlin while also unlocking on-device AI agents powered by Gemini Nano on Android.

And honestly?

This feels like one of the most important announcements for Android AI development since Gemini Nano arrived on-device.

---

Why This Matters

The AI ecosystem is rapidly shifting toward edge computing.

With Gemini Nano already available across more than 140 million Android devices, developers are now thinking beyond cloud-only AI architectures.

The new reality is:

• Some AI tasks belong in the cloud

• Some AI tasks should stay on-device

• Privacy matters more than ever

• Latency and offline support are becoming critical

• AI agents need orchestration, memory, tooling, and delegation

That’s exactly where ADK comes in.

ADK (Agent Development Kit) is Google’s open-source framework for building and orchestrating AI agents.

Now with Kotlin and Android support, developers can create:

✅ Cloud agents
✅ On-device agents
✅ Hybrid AI systems
✅ Multi-agent architectures
✅ Retrieval pipelines
✅ AI workflows in pure Kotlin

---

What Exactly Is ADK?

ADK is a code-first AI agent framework.

Instead of manually wiring prompts, tools, memory, routing, and orchestration logic together, ADK provides structured primitives for building sophisticated AI systems.

Think of it as:

“Jetpack Compose for AI Agents.”

You define:

• Agents

• Instructions

• Tools

• Sub-agents

• Memory

• Execution flow

And ADK handles:

• Orchestration

• Context passing

• Agent delegation

• Tool execution

• State management

• Error handling

---

ADK for Kotlin vs ADK for Android

Google launched two separate but complementary libraries.

ADK for Kotlin

Focused on:

• Backend systems

• JVM apps

• Cloud-based orchestration

• Kotlin server development

Dependency:

implementation("com.google.adk:google-adk-kotlin-core:0.1.0")

---

ADK for Android

Focused on:

• On-device AI agents

• Gemini Nano

• Mobile AI orchestration

• Privacy-first AI experiences

Dependency:

implementation("com.google.adk:google-adk-kotlin-core-android:0.1.0")

This version includes integrations with:

• ML Kit GenAI

• Gemini Nano via AI Core

• Firebase AI Logic

• Cloud Gemini models

---

The Big Shift: Hybrid AI Architectures

One of the most exciting concepts introduced is Hybrid Orchestration.

Instead of forcing all AI processing into the cloud, ADK allows developers to distribute intelligence across:

☁️ Cloud Models
📱 On-device Models
🔄 Sub-agents
🧠 Retrieval Pipelines

The orchestrator agent can delegate tasks dynamically.

Example:

• Cloud model handles reasoning

• On-device agent processes private files

• Retrieval agent searches local documents

• Validation agent verifies results

All coordinated automatically.

This architecture solves major problems:

• Privacy

• Cost

• Latency

• Offline support

• Context switching

---

Real-World Example: AI Travel Assistant ✈️

During Google I/O, Google demonstrated a travel assistant built using ADK for Kotlin.

Here’s how it worked.

Step 1 — Cloud Orchestrator Handles Conversation

The main cloud-based agent communicates with the user.

Example:

“I can’t find my hotel reservation.”

The orchestrator understands the request and plans the workflow.

---

Step 2 — On-Device Agent Accesses Local Documents

Instead of uploading sensitive files to the cloud:

📄 Booking confirmations
📧 Emails
🧾 PDFs

are processed directly on-device using Gemini Nano.

This keeps user data private.

---

Step 3 — Retrieval Agents Parse Information

Specialized sub-agents:

• Extract hotel data

• Parse travel documents

• Validate reservations

• Cross-reference itinerary details

---

Step 4 — Validation Agent Confirms Results

A final agent verifies consistency between:

• Cloud reasoning

• Local retrieval

• Extracted documents

The result is:

• Secure

• Fast

• Intelligent

• Privacy-preserving AI

This is exactly the type of architecture Android developers have been waiting for.

---

Feature Highlights

ADK for Kotlin & Android ships with an impressive foundational feature set.

---

1. Hybrid Orchestration

Use cloud models as orchestrators while delegating tasks to on-device sub-agents.

Perfect for:

• Secure apps

• Enterprise AI

• Offline workflows

• Privacy-sensitive features

---

2. Sequential On-Device Agents

Run multi-step workflows entirely on-device.

Example:

1. Read PDF

2. Extract text

3. Summarize content

4. Generate action items

Without sending anything to the cloud.

---

3. Local Retrieval Pipelines

Build Retrieval-Augmented Generation (RAG) systems directly on Android.

Use Gemini Nano to:

• Parse local documents

• Search notes

• Analyze files

• Process images

All locally.

---

4. Flexible Tooling System

Agents can use:

• Function tools

• MCP tools

• Long-running tools

• Plugins

• A2A integrations

This makes ADK extremely extensible.

---

5. Multi-Agent Systems

ADK allows hierarchical agent design.

You can create:

• Root orchestrators

• Specialist agents

• Validator agents

• Retrieval agents

• Workflow pipelines

This mirrors how advanced enterprise AI systems are built.

---

Building Your First AI Agent in Kotlin

Let’s walk through a simple example.

---

Step 1 — Add Dependencies

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

---

Step 2 — Create a Tool

ADK tools allow agents to interact with external systems or custom logic.

Example:

class ImprobabilityDriveService {

 @Tool
 fun calculateImprobability(
   @Param("Event to analyze")
   event: String
 ): String {

   return "The improbability of '$event' is approximately 42 to 1 against."
 }
}

Notice the annotations:

• @Tool

• @Param

These describe capabilities to the LLM.

---

Step 3 — Create a Specialized Agent

val heartOfGoldAgent =
    LlmAgent(
      name = "HeartOfGold",
      description = "Handles improbability queries",
      model = Gemini(
          apiKey = apiKey,
          name = "gemini-2.5-flash"
      ),
      instruction = Instruction(
          "You are cheerful and slightly annoying."
      ),
      tools = ImprobabilityDriveService().generatedTools()
    )

---

Step 4 — Create a Root Orchestrator

val rootAgent =
  LlmAgent(
    name = "MissionControl",
    subAgents = listOf(heartOfGoldAgent),
    model = Gemini(
        apiKey = apiKey,
        name = "gemini-2.5-flash"
    ),
    instruction = Instruction(
        "Route queries to the appropriate agent."
    )
  )

Now the orchestrator can delegate tasks automatically.

This is where ADK becomes incredibly powerful.

---

Android + Gemini Nano = Massive Opportunity

The most exciting part of this release is the Android angle.

For years, mobile AI was mostly:

• Chat interfaces

• Cloud APIs

• Prompt wrappers

But now Android apps can host:

• Real AI agents

• Local reasoning systems

• Autonomous workflows

• Context-aware assistants

Directly on-device.

This changes the game for:

• Productivity apps

• Travel apps

• Health apps

• Enterprise apps

• Offline-first apps

• Privacy-focused products

---

Supported AI Models

ADK for Android currently supports:

On-Device

✅ Gemini Nano via ML Kit GenAI + AI Core

Cloud

✅ Gemini models via Firebase AI Logic
✅ Google GenAI SDK

---

Runtime & Observability Features

ADK also includes production-oriented tooling.

Memory & Session State

• Short-term memory

• Long-term memory services

• Shared agent context

---

Telemetry

Built-in:

• OpenTelemetry support

• Observability hooks

• Execution tracing

Huge for debugging multi-agent systems.

---

Developer Experience

Google also ships a built-in development UI for:

• Testing agents

• Evaluating flows

• Debugging orchestration

• Experimentation

This mirrors the much-loved Python ADK tooling.

---

Why Kotlin Developers Should Care

Kotlin is uniquely positioned for AI agents because it works across:

• Android

• Backend

• Multiplatform

• Cloud services

ADK turns Kotlin into a full-stack AI orchestration language.

That’s a very big deal.

Especially for teams already invested in:

• Android

• Ktor

• Spring Boot

• Firebase

• Compose Multiplatform

---

Current Limitations

This is still an experimental 0.1 release.

Some limitations:

• Early APIs

• Limited model integrations

• Rapidly evolving architecture

• Documentation still growing

But the foundation is extremely promising.

---

What Comes Next?

Google clearly sees AI agents as the future of app development.

And Android may become one of the most important platforms for:

• Edge AI

• Privacy-preserving AI

• Offline AI

• Personalized AI systems

ADK for Kotlin and Android is the first major step in that direction.

---

Final Thoughts

This release feels bigger than just another SDK launch.

It represents:

• The rise of on-device AI agents

• Hybrid cloud-edge orchestration

• AI-native Android apps

• Multi-agent mobile systems

And most importantly:

It gives Android developers first-class tooling for the AI agent era.

The future of Android apps won’t just be AI-powered.

They’ll be agentic.

And Kotlin is now officially part of that future.

---

Resources

GitHub

https://github.com/google/adk-kotlin

Documentation

https://developers.google.com/adk-kotlin

Samples

https://github.com/google/adk-kotlin/tree/main/samples

---

Happy Agent Building 🤖✨

#Android #Kotlin #AI #GenerativeAI #AndroidDev #Gemini #GoogleIO #LLM #AIAgents #MobileAI #AndroidEngineering