By JetBrains shipped Koog 1.0 last week — the first stable release of their JVM-native AI agent framework. The headline feature is a one-year API stability guarantee on all stable modules, which in the current AI tooling landscape is practically unheard of. If you build Java or Kotlin backends and have been watching the Python agent ecosystem churn through breaking changes every other month, this is worth paying attention to.
The Stability Guarantee Changes the Math
Koog 1.0 splits the framework into stable and beta module streams. Stable modules get no breaking changes for at least one year — all previously deprecated APIs have been removed, and the graph DSL node names are finalized. This is not just a versioning decision; it is a production signal. JetBrains is done experimenting with the core. Teams can pin to these APIs without a next-week refactor risk, which is something LangChain has never convincingly offered its Java wrappers.
The commitment matters more than it might seem. AI agent frameworks have been notoriously unstable as a category. Production teams have been waiting for a toolchain they can actually commit to. Koog 1.0 is that commitment, scoped for the JVM.
What Changed in 1.0
Three improvements stand out for teams already familiar with earlier Koog versions or evaluating it fresh.
Java interop is now consistent. All Java-facing entry points follow one pattern: xxxBlocking in Kotlin, plain xxx from Java. Explicit ExecutorService and Executor parameters are gone — the agent’s configured dispatcher handles it. This matters for legacy Java codebases where coroutine leakage across the API boundary was a practical objection to adopting Koog at all.
HTTP transport is no longer tied to Ktor. LLM client constructors previously required a Ktor HttpClient directly, locking you in even if your project used OkHttp or Apache HttpClient. In 1.0, you pass a KoogHttpClient.Factory instead — or omit it entirely and the framework picks the default. This is a quiet but meaningful architectural cleanup that removes one of the more common integration friction points.
OpenTelemetry now covers all Kotlin Multiplatform targets. Langfuse, Weave, and DataDog work on every Koog target — JVM, Android, iOS, JS — via an OTLP/JSON exporter. Agents emit standard gen_ai.client.token.usage, gen_ai.client.operation.duration, and a custom gen_ai.client.tool.count metric. If your team already runs Prometheus and Grafana for the rest of your stack, agent observability just plugged in.
Two other additions round out the release: Anthropic prompt caching (automatic, with explicit cache breakpoints and cache token counts in usage metrics) and a new LiteRT provider for running local models on Android without a cloud API.
Getting Started
Add the Gradle dependency:
dependencies {
implementation("ai.koog:koog-agents:1.0.0")
}A basic agent looks like this:
val agent = AIAgent(
promptExecutor = anthropic(apiKey),
systemPrompt = "You are a helpful assistant.",
model = AnthropicModels.Claude_Sonnet_3_5
)
val result = agent.run("Analyze this error log...")Complex multi-step workflows use Koog’s graph DSL, where nodes represent agent actions and edges define routing — including conditional branching for human-in-the-loop scenarios. Full documentation is at docs.koog.ai.
The Spring Boot Angle
The Spring AI integration, introduced ahead of this stable release, added two Spring Boot starters: koog-spring-ai-starter-model-chat and koog-spring-ai-starter-model-embedding. These let Spring Boot applications use any Spring AI-compatible LLM provider as a Koog backend. Teams do not need to swap out their existing provider configuration — Koog plugs into what is already there. For an ecosystem with millions of active Spring Boot applications, this is the most direct path to production AI agents on Java.
Where Koog Fits
The Python-first agent ecosystem has been telling JVM developers to “just use our SDK” for two years. Koog 1.0 is a credible rejection of that premise. LangChain4j remains a reasonable choice for teams that want maximum provider breadth or have existing Java-native integrations. But if you need Kotlin Multiplatform targets, fault-tolerant agent persistence that resumes from checkpoints, or on-device Android AI — Koog is the only option in the JVM space that covers all three.
The full release announcement is on the JetBrains AI blog. Source and issues are at github.com/JetBrains/koog.
