By ByteBot
JVM developers have been building AI agents in Python for one simple reason: there was no credible alternative on the JVM. That just changed. JetBrains shipped Koog 1.0 at KotlinConf 2026 — a stable, fault-tolerant AI agent framework for Kotlin and Java, running on the JVM, Android, iOS, and in-browser environments. The release comes with a one-year API stability guarantee, which is the detail that separates this from every pre-1.0 experiment that came before it.
What Makes 1.0 Different
Koog has been in development since 2025, but previous releases were risky for production adoption — APIs changed, integrations broke. The 1.0 release draws a line. JetBrains committed to no breaking changes in stable modules for at least one year, with the framework’s modules split into stable and beta streams so you know exactly what you are and are not locking in. For enterprise teams with proper change management processes, that distinction matters enormously.
The 1.0 release also ships a redesigned Java interop layer — cleaner API surface, more consistent method naming — and OpenTelemetry observability support across all Koog targets, including Kotlin Multiplatform deployments. These are not headline features, but they are the kind of polish that indicates a framework is ready for teams beyond early adopters.
The Core of the Framework
Koog provides the building blocks an agent runtime needs: tools, workflow strategies, persistence, memory management, and LLM provider routing. The workflow system is where Koog earns its complexity budget. Three strategies cover the full range of agent behavior:
- Functional chains — linear sequences for straightforward multi-step tasks
- Graph-based orchestration — branching pipelines for complex workflows where paths depend on intermediate results
- Planning — autonomous goal pursuit where the agent decides its own sequence of steps
Fault tolerance is built into the persistence layer. Koog saves intermediate agent state to disk, S3, or a database after each step. If an infrastructure failure or timeout occurs mid-workflow, the agent resumes from exactly where it stopped — not from scratch. That matters because planning steps using capable models can cost $2–5 per LLM call. A framework that retries from the beginning on failure is not a production tool; it is an expensive demonstration.
Adding Koog to a Spring Boot Project
The practical adoption path for most enterprise JVM teams runs through Spring Boot, and JetBrains built the integration accordingly. Adding Koog to an existing Spring Boot application requires two Gradle dependencies:
dependencies {
implementation("ai.koog:koog-agents:1.0.0")
implementation("ai.koog:koog-spring-ai:1.0.0")
}One distinction worth being clear about: Spring AI and Koog are not the same thing and are not competing. Spring AI is the client layer — it handles how your application talks to LLM providers and vector databases. Koog is the orchestration layer — it handles multi-step agent strategies, persistence, and workflow branching. JetBrains describes the integration as letting you “keep your current LLM providers and databases exactly as they are” while adding an agent runtime on top. That framing is accurate.
A Minimal Agent in Kotlin
Getting a basic agent running is straightforward:
val agent = AIAgent(
executor = simpleOpenAIExecutor(System.getenv("OPENAI_API_KEY")),
systemPrompt = "You are a helpful assistant. Answer concisely.",
model = OpenAIModels.Chat.GPT4o
)
val result = agent.run("Summarize what changed in Koog 1.0.")
println(result)Provider support is broad — OpenAI, Anthropic, Google, DeepSeek, and Ollama are all supported out of the box, and providers can be switched mid-workflow without losing conversation history. For teams managing cost by routing cheaper models to simpler subtasks, that routing capability is immediately useful.
Multiplatform and Protocol Support
Koog runs beyond the backend JVM. Via Kotlin Multiplatform, agents can be deployed to Android, iOS, JavaScript, and WasmJS targets from a shared codebase. The 1.0 release adds a LiteRT provider for running models locally on Android devices — relevant for mobile developers who want on-device inference without a network round-trip.
On the protocol front, Koog implements both MCP (Model Context Protocol) and the A2A protocol v0.3.0. MCP handles vertical tool integration — connecting your agent to external data sources and APIs through the standard tool interface. A2A handles horizontal coordination — agent discovery, task delegation, and streaming communication between agents. The two-layer stack is quickly becoming the architectural default for enterprise multi-agent deployments.
The JVM Finally Has a Stake in the Agent Race
Sixty-two percent of enterprises use Java for AI functionality as of 2026, up from 50% a year ago. The percentage running AI agents in Python because they had no serious JVM option was always an artificial constraint. Koog 1.0 removes it. The combination of a stable API, Spring Boot integration, fault-tolerant persistence, and modern protocol support makes this the framework JVM shops needed to stop apologizing for not using Python.
The Koog 1.0 release announcement is on the JetBrains AI blog. The quickstart gets a basic agent running in under ten minutes. The GitHub repository is open source under the Apache 2.0 license. For teams already running Spring AI, the Spring AI integration guide is the right starting point. Red Hat has also published a practical case for building enterprise agentic apps with Java that provides useful additional context.
