Koog
JetBrains incubator Kotlin and JVM agent framework for building predictable, fault-tolerant AI agents with graph workflows, tools, MCP integration, memory, streaming, OpenTelemetry, Spring/Ktor integrations, and multiple LLM providers.
Open the source and read safety notes before installing.
Safety notes
- Koog is marked as a JetBrains incubator project and the README uses Kotlin Alpha language/project signals; production adopters should pin versions, test upgrades, and track breaking changes.
- Agents can call custom tools, MCP tools, graph workflow nodes, provider APIs, memory stores, and enterprise integrations; review permissions and side effects for every tool before enabling it.
- Fault tolerance, retries, state restoration, history compression, and graph workflows can replay or resume actions; design idempotency, compensation, and escalation behavior for side-effecting tools.
- Spring Boot, Ktor, Android, iOS, JS, WasmJS, and backend deployments each need separate security, platform, and packaging review.
- OpenTelemetry traces and model/tool logs help debug agents, but they can also expose sensitive prompts, tool results, and application state.
Privacy notes
- Prompts, system instructions, chat history, tool schemas, tool arguments, tool outputs, graph state, memory records, embeddings, traces, model responses, and errors can be sent to configured model providers or observability backends.
- MCP tools and custom Kotlin/JVM tools may expose databases, application internals, filesystem data, cloud resources, user records, credentials, or private business logic to the agent loop.
- History compression, persistence, shared memory, vector embeddings, and ranked document storage can retain user or workspace data across runs unless retention and deletion rules are explicit.
- Do not publish provider keys, internal service URLs, trace exports, memory dumps, mobile app data, user records, or production incident logs in examples, issues, screenshots, or PRs.
Prerequisites
- JDK 17 or newer for JVM usage, plus Kotlin and Gradle or Maven project setup.
- Current Koog docs and artifact version review before pinning dependencies; the live GitHub release and README examples may not match every package index yet.
- Model provider credentials for OpenAI, Anthropic, Google, DeepSeek, OpenRouter, Ollama, Bedrock, or the provider selected by the application.
- Clear tool, MCP, graph workflow, persistence, memory, and retry boundaries before connecting agents to production systems.
- Observability destination, retention policy, and redaction plan if using OpenTelemetry, W&B Weave, Langfuse, traces, or custom logs.
Schema details
- Install type
- cli
- Troubleshooting
- No
- Scope
- Source repo
- Estimated setup
- 30 minutes
- Difficulty
- advanced
- Website
- https://docs.koog.ai
- Pricing
- open-source
- Disclosure
- editorial
- Application category
- DeveloperApplication
- Operating system
- Cross-platform
Full copyable content
dependencies {
implementation("ai.koog:koog-agents:0.5.0")
}About this resource
Overview
Koog is JetBrains' Kotlin-based framework for building AI agents in idiomatic Kotlin and JVM projects. It targets agents that need tools, complex workflows, conversation history, provider switching, MCP integration, memory, streaming, OpenTelemetry observability, and framework integration with Spring Boot or Ktor.
Use this listing for the Koog framework itself. It is distinct from general Java or Kotlin MCP SDKs: Koog is an agent application framework, while the official MCP SDKs focus on implementing Model Context Protocol clients and servers.
Install
The README documents Gradle and Maven usage. For Gradle Kotlin DSL:
dependencies {
implementation("ai.koog:koog-agents:0.5.0")
}
Before adopting Koog in a production project, check the current Koog docs, GitHub release notes, and package index for the dependency version to pin. The repository is active, and version examples can move as the incubator project evolves.
Core Capabilities
| Area | Koog Coverage |
|---|---|
| Languages and platforms | Kotlin/JVM, JS, WasmJS, Android, iOS, and backend service use cases |
| Agent runtime | AIAgent, Kotlin DSLs, tool calls, graph workflows, streaming, retries, and state restoration |
| Providers | Google, OpenAI, Anthropic, DeepSeek, OpenRouter, Ollama, and Bedrock |
| MCP | Use Model Context Protocol tools from Koog agents |
| Memory and retrieval | Shared agent memory, vector embeddings, ranked document storage, and knowledge retrieval |
| Observability | OpenTelemetry exporters plus integrations such as W&B Weave and Langfuse |
| JVM integration | Spring Boot and Ktor application integration |
| Workflow design | Flexible graph workflows, modular features, custom tools, and tracing |
MCP Fit
Koog belongs in MCP-adjacent searches because the framework can use MCP tools inside Kotlin and JVM agent applications. That makes it useful for teams that already run Java/Kotlin backend systems and want agents to call standardized MCP tools without switching the whole agent runtime to Python or TypeScript.
Keep tool boundaries explicit. MCP tools can expose file systems, databases, cloud APIs, SaaS accounts, browser automation, or internal platform operations. Koog can orchestrate those calls, but your application still owns authorization, input validation, audit logs, human approval, retries, and rollback behavior.
Use Cases
- Build a Kotlin backend agent that calls typed tools and MCP servers.
- Add AI agent workflows to Spring Boot or Ktor applications.
- Run graph-based agent workflows with retries and state restoration.
- Switch between OpenAI, Anthropic, Google, OpenRouter, Ollama, DeepSeek, or Bedrock providers without redesigning the agent.
- Add memory, retrieval, and history compression to longer conversations.
- Export traces to observability systems while debugging agent behavior.
- Explore Kotlin Multiplatform agent surfaces for JVM, mobile, JS, or WasmJS.
Source Review
Verified on 2026-06-18:
- The upstream README describes Koog as a Kotlin-based framework for building and running AI agents in idiomatic Kotlin.
- The README lists multiplatform development, reliability and fault tolerance, history compression, Spring Boot and Ktor integration, OpenTelemetry exporters, provider switching, MCP tools, memory, streaming, modular features, graph workflows, custom tools, and tracing.
- The README lists Google, OpenAI, Anthropic, DeepSeek, OpenRouter, Ollama, and Bedrock as supported provider families.
- The README says JDK 17 or newer is required for JVM usage and documents Gradle and Maven dependency examples.
gradle/libs.versions.tomlrecords Kotlin, coroutine, serialization, Ktor, Spring Boot, Spring AI, OpenTelemetry, AWS SDK, and MCP Kotlin SDK dependency versions used by the repository.- GitHub reports JetBrains ownership, Apache-2.0 licensing, a current release, active repository updates, and topics including MCP, Kotlin, Java, JVM, OpenAI, Anthropic, Ollama, Bedrock, Ktor, Spring, and multi-agent systems.
Safety and Privacy
Koog's operational risk comes from what each agent can call and remember. Review every tool, MCP server, model provider, memory backend, trace exporter, and workflow node as an independent trust boundary. Use narrow credentials, idempotent tool behavior, timeouts, audit logs, and human approval for side-effecting actions.
Because Koog supports persistence, state restoration, memory, embeddings, and observability, sensitive user or workspace data can remain available beyond a single prompt. Define retention, deletion, access control, and redaction rules before using it for production or regulated workflows.
Duplicate Check
Checked current content/tools/, content/mcp/, content/agents/,
content/skills/, content/guides/, open pull requests, and repository-wide
content for Koog, JetBrains/koog, docs.koog.ai, koog-agents,
Kotlin AI agent framework, Koog MCP, and JVM AI agents. Existing Java,
Kotlin, MCP SDK, LangChain4j, Microsoft Agent Framework, and Spring-related
entries are adjacent, but no dedicated Koog tools entry, exact source URL
duplicate, target file, or open duplicate PR was found.
Disclosure
Editorial listing. No paid placement or affiliate link is used.
Source citations
Add this badge to your README
Show that Koog is listed on HeyClaude. Paste this Markdown into your README — it renders the badge and links back to this page.
[](https://heyclau.de/entry/tools/koog)How it compares
Koog side by side with 3 alternatives on trust, install, platform support, and disclosed safety notes — all from reviewed registry metadata.
| Field | Koog JetBrains incubator Kotlin and JVM agent framework for building predictable, fault-tolerant AI agents with graph workflows, tools, MCP integration, memory, streaming, OpenTelemetry, Spring/Ktor integrations, and multiple LLM providers. Open dossier | LangChain4j Idiomatic Java/JVM library for building LLM-powered applications with unified model APIs, tool calling, agentic workflows, RAG, chat memory, embedding stores, MCP client support, and Spring Boot, Quarkus, Helidon, and Micronaut integrations. Open dossier | LangGraph Agent orchestration framework for building stateful, controllable, multi-step LLM and agent workflows. Open dossier | Official MCP Kotlin SDK Official Kotlin Multiplatform SDK for Model Context Protocol clients and servers, maintained in collaboration with JetBrains, with JVM, Native, JS, and Wasm targets, coroutine APIs, Gradle artifacts, Ktor integration, stdio, SSE, Streamable HTTP, WebSocket, tools, resources, prompts, sampling, and roots. Open dossier |
|---|---|---|---|---|
| Trust | ||||
| Install risk | Review first | Review first | Review first | Review first |
| Notes | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ | Safety · Privacy ✓ | Safety ✓ Privacy ✓ |
| Category | tools | tools | tools | tools |
| Source | source-backed | source-backed | source-backed | source-backed |
| Author | JetBrains | LangChain4j | LangChain | Model Context Protocol |
| Added | 2026-06-18 | 2026-06-18 | 2026-04-27 | 2026-06-18 |
| Platforms | CLI | CLI | CLI | CLI |
| Source repo | — | — | — | — |
| Safety notes | ✓Koog is marked as a JetBrains incubator project and the README uses Kotlin Alpha language/project signals; production adopters should pin versions, test upgrades, and track breaking changes. Agents can call custom tools, MCP tools, graph workflow nodes, provider APIs, memory stores, and enterprise integrations; review permissions and side effects for every tool before enabling it. Fault tolerance, retries, state restoration, history compression, and graph workflows can replay or resume actions; design idempotency, compensation, and escalation behavior for side-effecting tools. Spring Boot, Ktor, Android, iOS, JS, WasmJS, and backend deployments each need separate security, platform, and packaging review. OpenTelemetry traces and model/tool logs help debug agents, but they can also expose sensitive prompts, tool results, and application state. | ✓LangChain4j can bind model calls to Java tools, MCP tools, RAG retrievers, and framework services. Treat each tool as application code with permissions, side effects, and audit requirements. The MCP tutorial supports stdio, Streamable HTTP, WebSocket, Docker stdio, and legacy HTTP/SSE transports. Review subprocess commands, Docker socket access, server URLs, and credentials before connecting agents. Use MCP tool filtering and tool-name mapping when a server exposes many tools or overlapping tool names; do not expose write-capable tools by default. RAG examples may read local directories, parse documents, and store embeddings in external vector stores. Scope ingestion paths and retention rules before indexing private data. The agentic module is documented as experimental, so teams should pin versions, test workflows, and avoid relying on unstable APIs for critical production behavior. | — missing | ✓The official Kotlin SDK is a protocol library; risk comes from your MCP tools, resources, prompts, transports, Ktor engine choices, and server deployment. Validate all tool inputs, enforce caller permissions, bound file and network access, and sanitize errors before returning MCP responses. HTTP, SSE, Streamable HTTP, WebSocket, and Ktor deployments need authentication, TLS, CORS/host review, request limits, logging policy, and abuse protection. Kotlin Multiplatform targets can behave differently across JVM, Native, JS, and Wasm; test transport and serialization behavior on the exact target you ship. |
| Privacy notes | ✓Prompts, system instructions, chat history, tool schemas, tool arguments, tool outputs, graph state, memory records, embeddings, traces, model responses, and errors can be sent to configured model providers or observability backends. MCP tools and custom Kotlin/JVM tools may expose databases, application internals, filesystem data, cloud resources, user records, credentials, or private business logic to the agent loop. History compression, persistence, shared memory, vector embeddings, and ranked document storage can retain user or workspace data across runs unless retention and deletion rules are explicit. Do not publish provider keys, internal service URLs, trace exports, memory dumps, mobile app data, user records, or production incident logs in examples, issues, screenshots, or PRs. | ✓Prompts, chat memory, tool arguments, tool outputs, retrieved document chunks, embeddings, vector-store metadata, model responses, logs, and MCP traffic may include private application or customer data. Model providers, embedding providers, vector stores, MCP servers, framework logs, tracing systems, and Java application logs may observe or retain LangChain4j workflow data. Do not commit provider keys, MCP server credentials, vector database secrets, local document paths, generated traces, or raw RAG datasets. If request/response or MCP transport logging is enabled for debugging, review logs before sharing them because they can include prompts, tool payloads, retrieved content, and credentials. | ✓LangGraph sends prompts and graph state to your configured model provider (including Claude); persisted state and checkpoints can contain message and tool-call data. | ✓Kotlin MCP clients and servers may expose tool arguments, tool results, resource contents, prompt templates, transport metadata, coroutine errors, logs, and traces. Avoid leaking secrets, customer data, private resources, internal identifiers, privileged paths, or raw stack traces through schemas, responses, errors, or logs. Document which MCP client, server target, Ktor engine, model provider, transport, and observability system can observe each request. |
| Prerequisites |
|
| — none listed |
|
| Install | | | — | |
| Config | — | — | — | — |
| Citations | ||||
| Claim | Unclaimed | Unclaimed | Unclaimed | Unclaimed |
Featured in
Signals
Loading live community signals…
A short, calm digest of reviewed Claude resources. Unsubscribe any time.