Koog: JetBrains' Kotlin Framework for AI Agents

Introducing Koog: A JVM AI Agent Framework

Koog is a JVM framework from JetBrains that lets you write AI agents directly in Kotlin or Java, without going through a separate Python layer. It covers agents that call external tools, run multi-step workflows, and hold a conversation with a user, and it ships as Maven Central artifacts under the ai.koog group rather than as a hosted service, so you add it to a Gradle or Maven build like any other JVM dependency.

Core Capabilities for Building AI Agents

• ✓Built-in retries and agent-state persistence let a run resume from a checkpoint instead of restarting after a failure.
• ✓Automatic history compression trims conversation context so long-running agent sessions don't exhaust the LLM's token budget.
• ✓A provider-agnostic prompt executor can switch the underlying LLM mid-conversation without losing existing chat history.
• ✓Spring Boot and Ktor integrations let you wire Koog into an existing JVM service instead of standing up a separate agent process.
• ✓OpenTelemetry-based observability sends execution traces to providers such as W&B Weave and Langfuse.
• ✓Model Context Protocol (MCP) support lets agents call MCP tools, and Agent Client Protocol (ACP) support lets them talk to standardized client applications.
• ✓A graph-based workflow API plus a modular feature system for composing agent behavior from smaller, swappable pieces.
• ✓Vector-embedding-backed knowledge retrieval and RAG carry context across multiple conversations.

Where Koog Agents Shine

• •Adding an agent to an existing Spring Boot or Ktor service without bringing in a second language runtime.
• •Building agents inside Android or JVM desktop apps where the rest of the codebase is already Kotlin.
• •Workflows that need to survive a failed LLM call mid-task, since agent-state persistence resumes a run instead of starting it over.
• •Teams that want to swap LLM providers, say from OpenAI to Anthropic or a local Ollama model, without rewriting the agent or losing conversation history.

Getting Started with Koog

Koog installs as a Gradle or Maven dependency; there's no separate CLI or service to run. In Gradle Kotlin DSL, add implementation("ai.koog:koog-agents:1.1.1") and implementation("ai.koog:koog-agents-additions:1.1.1-beta") to build.gradle.kts, with matching coordinates for Groovy's build.gradle. Maven users add the ai.koog:koog-agents-jvm and ai.koog:koog-agents-additions-jvm artifacts at version 1.1.1 to pom.xml. In every case, mavenCentral() needs to be in your repository list. The README specifies JDK 17 or higher and Kotlin 2.3.10 or higher, built against kotlinx-coroutines version 1.10.2, kotlinx-serialization version 1.10.0, and kotlinx-datetime version 0.7.1.

Your First Koog AI Agent

The README's quickstart wraps an LLM client (OpenAILLMClient in the example, with Anthropic, Google, and OpenRouter clients as drop-in swaps) inside a MultiLLMPromptExecutor, then passes that executor, a system prompt string, and a model constant like OpenAIModels.Chat.GPT4o into an AIAgent constructor. It reads the API key from an environment variable, and calling agent.run() with a user message returns a result you can print directly. The whole example runs inside a single runBlocking coroutine block.

Koog Alternatives for AI Agent Development

Frequently Asked Questions about Koog

The problem it solves

Building an AI agent on the JVM usually means writing it in Python and bridging the result back into a Kotlin or Java service, or hand-rolling retry logic, state checkpoints, and provider-switching code around a raw LLM SDK. Koog's README frames its own reason for existing around that gap: a Kotlin- and Java-native framework meant to handle agent failures, state restoration, and multi-provider LLM access inside the same JVM process a Spring Boot or Ktor app already runs in, instead of adding a separate Python service to the stack.

Who should try it — and who should skip

Try Koog if you're a Kotlin or Java team adding agent behavior to an existing Spring Boot, Ktor, or Android codebase and want built-in retries, state persistence, and LLM-provider switching without leaving the JVM. Skip it if your team's stack is Python, or if you want a hosted, no-code way to assemble agents — Koog is a library you compile against, not a UI you drag boxes in.

Related repositories