Google ADK for Kotlin 1.0 Reaches Feature Parity with Python SDK

Google shipped ADK for Kotlin 1.0 on September 20, 2026, marking the point at which Kotlin developers can build production AI agents without deferring orchestration logic to Python. The release brings Kotlin to full feature parity with Google's ADK for Python and Java, and adds Android-specific capabilities that neither of those SDKs addresses: on-device inference via LiteRT-LM and ML Kit (currently in beta), plus cloud and hybrid routing through Firebase AI Logic.

The framework is built on Kotlin Multiplatform, targeting server-side JVM deployments and Android devices from a single codebase. Google describes the architecture as "completely agnostic to specific model backends, session providers, or memory systems" — a design stance that matters for teams who want to swap inference endpoints without re-engineering agent logic, a concern explored in our coverage of AI portability as the real production bottleneck.

What 1.0 ships

The production-ready feature set spans four areas. Hierarchical multi-agent support lets a parent agent delegate tasks to child agents. Context compaction provides automatic history summarisation to keep token usage bounded across multi-turn conversations. Session management allows agent state to be paused, serialised, and restored — essential for workflows that survive process restarts or Android activity lifecycle events. First-class Java interoperability rounds out the JVM-side story.

Tool declarations use @Tool and @Param annotations processed at compile time by KSP (Kotlin Symbol Processing), which generates function schemas without runtime reflection. PiNCAMP Android engineer Arjun Kumar noted on LinkedIn that compile-time schema generation keeps startup fast on mobile targets — a meaningful constraint given that on-device inference competes with an application's cold-start budget.

Human-in-the-loop control is exposed through a requireConfirmation flag in tool declarations. Any tool carrying this flag pauses execution and waits for explicit user approval before proceeding:

@Tool(
    name = "transferFunds",
    requireConfirmation = true
)
fun transferFunds(...)

Android persistence integrates directly: chat sessions can be stored in Room, indexed memory in AppSearch, and files in Android storage, making resumable confirmation flows practical on mobile. AI Dev Weekly maintainer Joske Vermeulen's published advice is to start with one resumable agent and explicit tool confirmation before reaching for a hierarchy of agents, on the grounds that production readiness depends more on lifecycle recovery and deterministic tool boundaries than on agent count.

The skills system stores procedural knowledge in SKILL.md files loaded dynamically on demand rather than injected wholesale into the model context. Google calls this progressive disclosure. Agents can access domain-specific playbooks without inflating the context window on every invocation — directly relevant to the token-budget pressures that make pipeline architecture a bigger lever than model selection in production systems.

On-device and hybrid inference

The hybrid routing capability — running locally when feasible, escalating to cloud models when capability demands it — is the architectural piece that distinguishes ADK for Kotlin from the Python SDK. No equivalent Android-native inference path exists in the Python release.

AI Mastery analysis

The compile-time KSP approach to tool schema generation is the most architecturally consequential choice in this release, and it carries a tradeoff the announcement underplays. Moving schema generation to build time eliminates a class of runtime errors and reduces startup latency, but it freezes tool signatures at compile time. Teams building agents whose tool surface changes dynamically — agents that discover and register external MCP endpoints at runtime, for example — will hit that boundary immediately.

The requireConfirmation mechanism is sound for high-impact discrete operations. Vermeulen's advice to reach for a single resumable agent with explicit tool confirmation before composing hierarchies is worth taking literally: the session serialisation and lifecycle recovery features are what make that advice actionable on Android, where process death is not an edge case.

ML Kit shipping as beta is the other flag worth tracking. On-device inference for agentic workloads is latency-sensitive in a different way than static model inference — agents issue multiple sequential tool calls, so per-call overhead compounds. Until ML Kit graduates from beta with documented latency characteristics for multi-turn agentic loops, LiteRT-LM is the only validated on-device path. The broader pattern — that production AI failures tend to be architectural rather than model-quality issues — is exactly what ADK's modular backend abstraction is designed to address, letting teams course-correct at the infrastructure layer without rewriting agent logic.

ADK for Kotlin 1.0 is open source and available on GitHub. Whether the on-device inference story matures fast enough to match server-side capability will determine how much of the mobile-to-backend architecture gap actually collapses into a single deployment target.

Primary source

Google Agent Development Kit for Kotlin Reaches Feature Parity with Python, Supports On-Device AI — InfoQ