Technology RadarTechnology Radar

Koog

langchain4jmcpstreamingsdk
Trial

Koog is JetBrains' open-source JVM-native AI agent framework — built in Kotlin with first-class Java interoperability since v0.7. It provides structured workflow strategies (functional, graph-based, planning) for building predictable, fault-tolerant AI agents on the JVM. Version 1.0.0 (May 21, 2026) is the first stable release, establishing a long-term-supported API surface across the framework.

Why It's in Trial

Koog reached stable GA at KotlinConf 2026 (Munich) on May 21, 2026 — the "wait for GA" blocker is now resolved. The 1.0.0 release finalizes the API surface: deprecated APIs removed, graph DSL node names locked, Java blocking API redesigned for deadlock safety, and LongTermMemory promoted from experimental to stable. JetBrains has 4+ months of preview feedback integrated. The "no named production users" blocker has also started to crack: JetBrains' 1.0 announcement names Mercedes-Benz as a case study, with the team using Koog to build vehicle maintenance support agents with structured workflows and controlled execution logic. Trial remains the right call for teams building new Kotlin or Java agents — one named adopter is a meaningful first proof point, but Adopt needs more than one.

What makes it interesting:

  • Three workflow strategies: Functional chains (sequential steps), graph-based orchestration (complex pipelines), and planning (autonomous goal pursuit). This is more structured than LangChain4j's agent primitives.
  • Stable/beta module split: Production code can pin to stable APIs that won't break without a deprecation cycle. Experimental APIs continue to evolve in beta modules — a meaningful step toward commitment-safe adoption.
  • Spring AI integration: ChatMemoryRepository and VectorStore support — Koog can use Spring AI's persistence and vector infrastructure, positioning it as complementary to Spring AI rather than purely competitive.
  • Pluggable HTTP transport: KoogHttpClient.Factory abstraction enables drop-in use of Java's HTTP client, OkHttp, or Spring's RestClient instead of requiring Ktor.
  • Fault tolerance with persistence: Agent state can be checkpointed and recovered without repeating expensive LLM calls. Custom key-value data is now saved alongside checkpoints in 1.0.0. Note: LangChain4j 1.13.0 also offers agentic state persistence, so this is no longer Koog-unique in the JVM ecosystem.
  • Observability: Built-in OpenTelemetry spans with Langfuse, Weights & Biases Weave, DataDog LLM Observability, and Prometheus/Grafana built-in metrics — with multiplatform OTel via Ktor-based OTLP/JSON exporter.
  • Expanded backend support: LiteRT LLM client for local Google model execution; Oracle Database ChatHistoryProvider; Amazon Bedrock AgentCore as LongTermMemory backend.
  • Anthropic prompt caching: Automatic and explicit cache control reduces cost and latency for agents that re-send long system prompts.
  • Multi-provider: OpenAI, Anthropic, Google (including LiteRT), DeepSeek, Ollama, and more.

Breaking changes in 1.0.0 to plan for:

  • AgentMemory replaced by LongTermMemory (promoted from experimental) — migration required.
  • Planners moved to dedicated agents-planners module — update build dependencies.
  • ExecutorService parameters removed from blocking Java wrappers — the agent's configured dispatcher handles execution now.
  • OpenTelemetry event APIs deprecated and removed — use the new OTLP exporter.
  • Minimum Java version is now 17.

Why not Adopt yet:

  • Still only one named production deployment — Mercedes-Benz is the first publicly named adopter (vehicle maintenance support agents), but Adopt-level confidence needs multiple independent organizations at scale, not a single vendor-curated case study. This is the primary remaining blocker.
  • Kotlin-first design — while Java interop is now solid (deadlock-safe blocking API, uniform xxx()/xxxBlocking() pattern), the API idioms may feel less natural to pure Java teams than Spring AI's annotation-driven model.
  • Crowded space — Spring AI owns the Spring ecosystem, LangChain4j owns the framework-agnostic space. Koog needs production proof points to differentiate beyond "JetBrains made it."

When to Evaluate Koog Over Alternatives

Scenario Recommendation
Kotlin-first project needing agents Koog is the natural fit
Spring Boot app adding basic LLM features Spring AI — more mature, familiar abstractions
Framework-agnostic Java with complex agents LangChain4j — 1.x stable, wider community
Need fault-tolerant agent state recovery Koog or LangChain4j 1.13.0 — both now offer persistence
IntelliJ-heavy team wanting IDE integration Koog + ACP for JetBrains IDE connectivity

Key Characteristics

Property Value
Status v1.0.0 GA (May 21, 2026)
License Apache 2.0
Provider JetBrains
Requires Java 17+ / Kotlin 1.9+
GitHub JetBrains/koog
Website jetbrains.com/koog
Docs docs.koog.ai

Further Reading