Google ADK for Kotlin 1.0 Brings Production-Ready AI Agents to Android and JVM

Google has officially released Agent Development Kit (ADK) for Kotlin 1.0, bringing production-ready AI agent development to Kotlin, Android, and server-side JVM applications.

The 1.0 release gives Kotlin developers access to advanced agent orchestration capabilities while adding Android-focused options for running AI workloads on devices, connecting to cloud services, and storing agent data locally.

With support for multi-agent workflows, human approval, persistent sessions, function calling, and Kotlin Multiplatform, ADK for Kotlin 1.0 is designed to make it easier for developers to build sophisticated AI-powered applications without leaving the Kotlin ecosystem.

What Is ADK for Kotlin 1.0?

ADK for Kotlin is Google’s framework for developing AI agents with Kotlin. It provides the building blocks developers need to create agents that can reason about tasks, call tools, maintain conversations, use external knowledge, and coordinate with other agents.

The framework is built around a Kotlin Multiplatform (KMP) core, allowing developers to use it beyond traditional Android applications.

This means Kotlin developers can build AI agents for:

• Android applications
• JVM and server-side applications
• Enterprise software
• Cloud-based AI workflows
• On-device AI experiences
• Hybrid cloud and device applications

The 1.0 release brings the Kotlin implementation into alignment with the core capabilities available in Google’s ADK ecosystem.

Major Features Introduced With ADK for Kotlin 1.0

The new release combines core AI-agent functionality with Android-specific capabilities.

1. Multi-Agent Orchestration

Complex applications often require more than one AI agent. ADK for Kotlin supports hierarchical agent architectures where a primary agent can delegate specific tasks to specialized child agents.

For example, an enterprise application could use separate agents for:

• Customer support
• Data analysis
• Database diagnostics
• Security checks
• Report generation

The agents can work together as part of a larger workflow rather than forcing one model to handle every responsibility.

2. Context Management and Multi-Turn Conversations

AI applications frequently need to process long conversations.

ADK for Kotlin 1.0 includes context-compaction capabilities that can summarize conversation history when necessary. This helps agents continue working across multiple turns while managing model context limits.

This is particularly useful for applications where users interact with an agent over extended sessions.

3. Human-in-the-Loop Workflows

Not every AI-generated action should happen automatically.

ADK for Kotlin supports human-in-the-loop workflows that allow an agent to pause before performing sensitive operations and request confirmation from the user.

This can be useful for applications involving:

• Financial transactions
• Account changes
• Production operations
• Data deletion
• Security-sensitive actions

The agent can wait for approval and then continue the workflow after receiving confirmation.

Kotlin Function Calling With Compile-Time Tool Generation

One of the important technical features in ADK for Kotlin 1.0 is its annotation-based tool system.

Developers can mark Kotlin functions with @Tool and describe parameters using @Param. Kotlin Symbol Processing, or KSP, can then generate the required function definitions during compilation.

For example:

class InfrastructureDiagnosticsService {

    @Tool
    suspend fun getServiceMetrics(
        @Param("Target service or database cluster") serviceName: String,
        @Param("Time window in minutes") windowMinutes: Int? = 15,
    ): ServiceMetrics {
        return ServiceMetrics(
            serviceName = serviceName,
            cpuUsagePercent = 91.4,
            connectionPoolUsagePercent = 98.5,
            activeConnections = 492,
            maxConnections = 500,
            p99LatencyMs = 2450,
            errorRatePercent = 4.2,
        )
    }
}

The key advantage is that developers can work with normal Kotlin functions while the framework generates the necessary tool metadata.

According to Google’s announcement, this approach provides type-safe schemas, support for suspend functions, and avoids runtime reflection for tool generation.

Skills Bring Procedural Knowledge to AI Agents

ADK for Kotlin 1.0 also introduces a skill-based approach for giving agents access to specialized procedures and operational knowledge.

Instead of embedding every instruction directly into application code, developers can create a SKILL.md file containing a specific procedure.

For example, a database incident-response skill could describe a workflow such as:

1. Collect database telemetry.
2. Check recent deployments.
3. Review safety rules.
4. Identify a likely cause.
5. Notify the operations team.

Additional resources can be loaded only when they are required.

This approach is known as progressive disclosure. Rather than sending every available piece of information to the model at once, the agent retrieves additional resources when the current task requires them.

Example: AI Agent for Database Incident Response

A practical use case for ADK for Kotlin 1.0 is production incident diagnosis.

Imagine a database suddenly experiences high latency and connection-pool saturation.

An ADK-powered agent could:

1. Receive the production alert.
2. Load the appropriate incident-response skill.
3. Query service metrics.
4. Examine recent deployments.
5. Correlate the available information.
6. Identify a likely root cause.
7. Notify the on-call team.
8. Recommend a mitigation such as a rollback.

This architecture allows the AI agent to combine tools, procedural knowledge, telemetry, and decision-making within one workflow.

The important distinction is that the agent isn’t simply generating a text response. It can interact with defined tools and follow operational procedures.

Android Gets On-Device AI Capabilities

ADK for Kotlin 1.0 is not limited to server-side applications.

Google has also introduced Android-oriented extensions designed for applications that need a combination of cloud intelligence, local processing, privacy, and offline capabilities.

Developers can combine ADK with technologies such as:

• LiteRT-LM
• ML Kit
• Firebase AI Logic
• Room
• AndroidX AppSearch
• Android file storage

This modular approach allows developers to choose where different parts of an AI application should run.

Some operations can use cloud models, while other workloads can potentially run locally on the device.

Building a Financial Assistant With ADK for Kotlin

A financial assistant provides a useful example of how human approval can be incorporated into an Android AI application.

Suppose an AI assistant receives a request to transfer money.

Rather than immediately executing the transaction, the application can configure the transfer tool to require confirmation:

@Tool(
    name = "transferFunds",
    description = "Transfers money to another account. Requires explicit user approval.",
    requireConfirmation = true
)
fun transferFunds(
    @Param("Recipient account ID") recipientId: String,
    @Param("Amount in USD") amount: Double
): String {
    return "Successfully scheduled transfer."
}

The agent can identify that the requested action requires approval and pause execution.

The Android application can then display a confirmation interface to the user.

After the user approves the transaction, the workflow can resume and execute the tool.

This pattern provides a useful foundation for AI applications where autonomous reasoning needs to be combined with explicit user control.

Persistent AI Conversations With Room

AI applications often need to preserve conversations even when an Android process is stopped or restarted.

ADK for Kotlin can integrate with Room for persistent session storage.

This makes it possible to retain agent session information across application lifecycle events rather than relying entirely on in-memory state.

For applications with long-running conversations, persistent sessions can significantly improve continuity.

AppSearch for Local Agent Memory

ADK for Kotlin can also use AndroidX AppSearch for indexed memory.

This can allow applications to search locally stored information and use relevant data as part of future interactions.

For example, an assistant could potentially retrieve information from previous interactions instead of treating every conversation as completely independent.

Combining persistent sessions with searchable local memory creates a stronger foundation for personalized Android AI experiences.

Firebase AI Logic Enables Hybrid AI Applications

Developers can also connect ADK for Kotlin applications to Firebase AI Logic.

This creates an option for applications that need cloud-based model capabilities while still using native Android architecture and Kotlin-based agent logic.

A hybrid architecture could therefore divide responsibilities between:

On-device components

• Local storage
• Local search
• Device-specific operations
• Potential offline AI workloads

Cloud components

• Large-model reasoning
• Cloud-based AI services
• Enterprise integrations
• Remote data processing

This flexibility is especially important for mobile applications where privacy, latency, connectivity, and model capability all have to be considered.

Java Interoperability for Enterprise Applications

Although ADK for Kotlin is designed around Kotlin, Google is also emphasizing Java interoperability.

This means existing Java applications can work with Kotlin-based agents instead of requiring organizations to completely rewrite their technology stack.

For enterprise teams with established JVM applications, this could make it easier to introduce AI-agent functionality incrementally.

Getting Started With ADK for Kotlin 1.0

Developers can add the core ADK Kotlin engine and KSP processor to a Kotlin project with dependencies similar to:

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

    implementation("com.google.adk:google-adk-kotlin-litertlm:1.0.0")
    implementation("com.google.adk:google-adk-kotlin-firebase-android:1.0.0")
}

Additional modules can be added depending on whether the application requires Android-specific AI or storage functionality.

Why ADK for Kotlin 1.0 Matters

The release is significant because AI agent development is moving beyond simple chatbot interfaces.

Modern agents increasingly need to:

• Use external tools
• Remember information
• Coordinate multiple agents
• Follow business procedures
• Request human approval
• Operate across multiple sessions
• Work with cloud and local resources

ADK for Kotlin brings these concepts into an ecosystem familiar to Kotlin and Android developers.

For mobile developers, the combination of on-device AI and cloud AI is particularly interesting. It allows developers to consider privacy-sensitive and latency-sensitive workloads alongside more powerful cloud-based reasoning.

For enterprise JVM developers, Kotlin’s interoperability with Java and the framework’s multi-agent capabilities could make AI integration more accessible.

The Future of Kotlin-Based AI Agents

AI agents are becoming an increasingly important application-development pattern, and programming-language support will play a major role in making these systems easier to build.

With ADK for Kotlin 1.0, Google is positioning Kotlin as an environment for developing agents across both Android and server-side applications.

The combination of multi-agent orchestration, compile-time tool generation, human approval workflows, persistent sessions, local memory, and Android-focused extensions gives developers a broad foundation for building more capable AI applications.

For developers already working with Kotlin, Android, or JVM-based enterprise systems, ADK for Kotlin 1.0 offers a new route toward building production-oriented AI agents without abandoning the Kotlin ecosystem.

Final Thoughts

Google’s ADK for Kotlin 1.0 release represents a significant step toward bringing AI-agent development deeper into Kotlin and Android development.

Its strongest feature may not be any single capability, but rather the way different components can be combined. Developers can create an agent, give it type-safe tools, load specialized skills, maintain persistent sessions, request human approval for sensitive operations, and choose between on-device and cloud-based AI.

As AI applications become more autonomous and integrated into everyday software, frameworks like ADK for Kotlin could help developers move from experimental chatbots toward structured, tool-using and production-oriented AI agents.