ADK for Kotlin brings agentic workflows to your backend initiatives, whereas ADK for Android offers specialised on-device optimizations
Following the current 1.0.0 releases of ADK for Java and Go, in addition to the beta of ADK for Python 2.0, we’re thrilled to announce the launch of model 0.1.0 of Agent Improvement Equipment (ADK) for Kotlin! As well as, we’re additionally launching a further specialised library referred to as ADK for Android. ADK is a versatile and open-source framework for creating and working AI brokers, and is now accessible in Kotlin. With the Android model you’ll be able to create AI brokers that may function on-device instantly inside your apps with native on-device LLMs, enhancing privateness, however with the flexibleness to bridge the hole with cloud-based fashions.
Why ADK for Kotlin?
The AI ecosystem is experiencing a large shift towards the sting, for the reason that introduction of Gemini Nano as a mannequin on Android, it has develop into accessible on over 140 million units. As builders look to construct quicker, less expensive, and privacy-enhancing functions, the power to run AI fashions instantly on cellular {hardware} (fashions like Gemini Nano) has by no means been extra vital. Nonetheless, constructing agentic techniques could be complicated, particularly when coordinating duties between the cloud and the sting. ADK removes that friction by managing all of the complicated orchestration, context dealing with, and error dealing with for you.
With just some strains of Kotlin, you’ll be able to:
- Simply swap out fashions relying in your wants
- Select between numerous on-device and cloud fashions for various components of your multi-agent system
- Seamlessly share session state between a number of brokers
- Run brokers instantly on Android units
Function Highlights
- Hybrid Orchestration: You should use a cloud mannequin as your foremost orchestrator, which may then offload particular duties to sub-agents that run absolutely on-device. The ADK library takes care of adapting generic agent implementations to the proper cloud or on-device APIs.
- On-Gadget Sequential Brokers: You may outline sub-agents as sequential brokers, excellent for a number of duties that must run one after the opposite.
- Native Retrieval: By using on-device fashions like Gemini Nano, you’ll be able to create retrieval brokers that entry and parse paperwork domestically, making certain information by no means has to depart the {hardware}.
- Versatile Tooling: You may equip your brokers with particular instruments and supply top-level directions in order that they know precisely easy methods to behave and when to delegate to subagents.
Actual-World Instance: The Journey Assistant
Throughout our I/O session, we showcased how ADK for Kotlin powers an in-app journey assistant.
If a person encounters a problem whereas touring, the cloud-based orchestrator interacts with the person to grasp the issue. Nonetheless, when it must confirm a reserving affirmation, it delegates the duty to an on-device subagent. Numerous retrieval brokers use the on-device Gemini Nano mannequin to extract information from the person’s domestically saved paperwork. Lastly, a validation agent compares the information coming from these analyses. This retains non-public information offline whereas leveraging the reasoning capabilities of the cloud orchestrator.
Getting began with ADK for Android
So as to add ADK to your Android app, add the next dependency to your construct.gradle.kts file:
implementation("com.google.adk:google-adk-kotlin-core-android:0.1.0")Kotlin
You may then simply construct your ADK brokers:
val orchestrator = LlmAgent(
title = "genius_orchestrator",
mannequin = Gemini(apiKey = apiKey, title = MODEL_NAME),
instruction = Instruction("""
You're a journey genius assistant.
First, use `get_trip_details` to get the complete itinerary of the journey and
perceive what occasions are scheduled.
Then, reply with a welcome message tailor-made to the journey state.
""".trimIndent()),
instruments = listOf(GetTripDetailsTool(tripId)),
subAgents = listOf(carRentalPipeline, hotelPipeline),
disallowTransferToPeers = true,
disallowTransferToParent = true,
)Kotlin
For extra prolonged agent setups, try the ADK for Android demos.
Getting Began with ADK for Kotlin
In your construct.gradle.kts file, add the next dependencies:
dependencies {
// Implementation dependency for ADK Core
implementation("com.google.adk:google-adk-kotlin-core:0.1.0")
// KSP processor for producing @AdkTools
ksp("com.google.adk:google-adk-kotlin-processor:0.1.0")
}Kotlin
ADK for Kotlin helps you to outline instruments to equip the LLM with additional powers. Let’s create an imagined “improbability drive” service, impressed from the Hitchhiker’s Information to the Galaxy:
class ImprobabilityDriveService {
/** Calculates the improbability of a given occasion. */
@Software
enjoyable calculateImprobability(
@Param("The occasion to calculate the improbability for, e.g., 'A cup of tea materializing'")
occasion: String
): String {
return "The improbability of '$occasion' is roughly 42 to 1 towards."
}
}Kotlin
Discover using the @Software and @Param annotations to explain the software to the LLM.
Now, we will create a primary agent, which would be the sub-agent of a foremost agent we’ll outline afterward. The HeartOfGold agent represents the spaceship’s laptop:
val heartOfGoldAgent =
LlmAgent(
title = "HeartOfGold",
description = "The Coronary heart of Gold ship laptop. Handles improbability drive queries.",
mannequin = Gemini(apiKey = apiKey, title = "gemini-2.5-flash"),
instruction =
Instruction(
"""
You're the ship laptop of the Coronary heart of Gold. You might be cheerful, useful, and barely annoying.
You've got entry to the Infinite Improbability Drive.
Use actual details about your self if requested, however hold it humorous.
"""
.trimIndent()
),
instruments = ImprobabilityDriveService().generatedTools()
)Kotlin
Now we will use this sub-agent in our root agent:
val rootAgent =
LlmAgent(
title = "MissionControl",
description = "The central router for house queries. Routes to HeartOfGold.",
subAgents = listOf(heartOfGoldAgent),
mannequin = Gemini(apiKey = apiKey, title = "gemini-2.5-flash"),
instruction =
Instruction(
"""
You might be Mission Management. You're the central hub for all communications.
Your foremost job is to route the person's question to probably the most applicable agent.
- If the question is about improbability, the Infinite Improbability Drive, or the Coronary heart of Gold, switch to `HeartOfGold`.
- In any other case, reply instantly with knowledgeable however careworn persona.
"""
.trimIndent()
)
)Kotlin
The heartOfGoldAgent is outlined as a subagent within the agent configuration of this foremost agent.
When the person asks questions concerning the improbability of an odd occasion to occur, the primary agent delegates the duty to the heartOfGoldAgent, which in flip will name the native perform software to calculate the likelihood, earlier than replying to the person.
This can be a easy instance of how one can outline instruments and sub brokers in ADK for Kotlin.
ADK characteristic set
The ADK for Kotlin & ADK for Android 0.1.0 releases include the foundational characteristic set required for constructing AI brokers on Android and past, together with superior management over agent execution, complete tooling, and important companies for state administration.
Brokers
Tooling & Integrations
Runtime & Observability
Developer Expertise
Android Fashions
- ML Equipment GenAI to entry on-device Gemini Nano through AICore
- Firebase AI Logic to entry Gemini fashions working within the cloud
- Google GenAI for fast prototyping
What’s Subsequent?
This 0.1 launch is our first experimental model of the library, at the moment that includes default brokers for the ML Equipment GenAI APIs and direct connections to Gemini within the Cloud. However we’re simply getting began!
We’re extremely enthusiastic about the way forward for in-app AI and may’t wait to see the clever experiences you construct. Remember to try the challenge on GitHub!
