Kotlin AI Agents with Koog: Build Agentic AI Apps on the JVM

Discover how the Kotlin AI stack positions Koog among JetBrains tools, enabling agentic AI apps on the JVM with KUG, MCP Kotlin SDK, Spring AI, and Juni.

Wire Koog into the project by adding two Koog libraries—kug agents and the kug executor llmall—via the Gradle version catalog, with separate stable and beta versions.

Build your first AI agent in Kotlin Koog in five meaningful lines and run it with Gradle, then compare outputs across GPT-40 and GPT-53 codecs.

Run the same agent locally with Ollama, using Llama 3.2 and the Llama AI executor, with no API key and tools to ground answers from your own documents.

Learn how prompts shape the assistant, manage the context window and token costs, and use temperature to balance focus and creativity, delivering typed Kotlin objects.

Learn to convert model output into a Kotlin data class with @Serializable using Kotlin serialization, generate a JSON schema, and parse JSON back into typed objects via the executor workflow.

Steer agent behavior by tuning the system prompt and temperature, balancing structured extraction with brainstorming; learn to parse typed Kotlin objects and repair JSON with a fixing parser using tools.

Explore how tool calling with Kotlin functions makes a chatbot an agent by letting the model call tools, run them via cook, and return results in a complete round trip.

Create a shared llm providers module and a multi llm prompt executor in Kotlin, then register tools with tool annotations for runtime tool calls.

Demonstrates a multi-tool agent with three tools and a registry, solving a single question by using math and word count, then shows how to call docs for accurate facts.

Learn to implement parallel tool calls and streaming output in Kotlin agents using Koog, with a parallel tools module, batch vs parallel execution, and streaming tokens via Kotlin flow.

Explore three agent driving styles—LLM-driven single-run, functional Kotlin suspending lambda, and graph-based with typed nodes and edges—and learn to build readable graphs with retries and conditional branches on the JVM.

Build a graph strategy with nodes and edges using a Kotlin strategy agent on the JVM. Learn run blocking versus suspend main and how to enable parallel tool execution.

Learn to handle tool failures within a graph by converting exceptions to failure results, routing via on condition branches, and using a retrying LLM client with max iterations.

Explore four production failure modes for agents—crashes, costly history, missing project docs, and forgotten data—and apply four fixes: persistence checkpoints, history compression, RAG, and memory.

Enable automatic persistence in Koog to snapshot agent state after each node, store checkpoints in memory or on disk, and resume from the latest snapshot after restart.

Apply history compression to control costs by summarizing the conversation instead of sending full history. Implement a compression node using the whole-history strategy to keep prompts small across long sessions.

Implement retrieval augmented generation with rack vector by embedding questions and docs with OpenAI embeddings and using a similarity search to fetch relevant, grounded snippets.

demonstrates cross-session memory by persisting user facts to a json file, enabling the agent to recall remembered facts across restarts with memory tools.

Explore the model context protocol (MCP) that lets your Kotlin AI agent connect to external tools via a standard server–client model, using stdio or SSE transports with KUK.

Connects the Kotlin MCP SDK to a public MCP server, pulls remote tools into the agent, and merges them with local tools for a unified registry.

Switch providers without losing history by using a single executor to route a conversation across OpenAI and local models, with history kept in the prompt.

MCP connects agents to tools, while A2A and ACP connect agents to other agents, all via modular plug-ins.

Turn your dev helper into a deployable HTTP service by embedding the agent behind a Ktor endpoint, with production observability, guardrails, and a post chat API.

Learn to enable observability with OpenTelemetry and LangFuse for Kotlin AI agents, generating traces of LLM calls, tools, latency, tokens, and cost for end-to-end visibility.

Implement a guardrail in a Kotlin HTTP server to block disallowed input before the model is called. Build a simple evaluation harness to regression-test prompts and detect failures.

Explore Kotlin multi-platform with KUG to write agent logic once and run on JVM back-end, android, ios, and browser, building truly agentic apps across platforms.