On March 19, 2026, JetBrains announced the public beta of **Koog**, a revolutionary framework designed to bring **Agentic AI** natively to the Java Virtual Machine (JVM). By leveraging the power of Java Agents, Koog allows developers to transform existing applications into intelligent, autonomous systems without rewriting a single line of business logic.
At its core, **JetBrains Koog** is a Java agent that runs alongside your application. It utilizes **ASM-based bytecode manipulation** to instrument your classes at runtime. This instrumentation serves two primary purposes: **Automatic Tool Discovery** and **Context Enrichment**.
When Koog is attached to a JVM process, it scans the classpath for methods annotated with standard Java metadata (or its own custom `@AgentTool` annotation). These methods are then dynamically exposed as "tools" to an integrated Large Language Model (LLM). This means that a legacy `OrderService.calculateTotal()` method can suddenly become a capability that an AI agent can call to resolve a customer query.
The "Native" part of the name comes from Koog's ability to handle **in-process memory sharing**. Unlike Python-based agent frameworks that rely on slow REST APIs to interact with your data, Koog interacts with your objects directly in the heap. This eliminates the serialization overhead and allows for real-time reasoning on complex object graphs.
Koog includes a lightweight **Reasoning Engine** (the Koog Kernel) that coordinates between the user, the LLM, and the application's bytecode. It implements a variant of the **ReAct (Reason + Act)** pattern but optimized for the strict typing of the JVM.
One of the most impressive features is the **Dynamic Context Window**. Koog monitors the execution stack and automatically injects relevant local variables and object states into the LLM's prompt. If an exception occurs in your application, Koog captures the full stack trace and heap dump, analyzes it using its reasoning loop, and can even propose (or apply) a bytecode-level hotfix at runtime.
In our synthetic tests on a Spring Boot 4.0 application, Koog demonstrated a massive performance advantage over traditional external agent architectures.
While Koog can run in any JVM environment, it truly shines when paired with **IntelliJ IDEA 2026.1**. The IDE provides a dedicated **Agent Inspector** that allows you to see exactly which methods are exposed to the AI and monitor the "thought process" of the agent in real-time. You can set "AI Breakpoints" that pause the execution only when the agent's confidence score drops below a certain threshold.
Furthermore, Koog supports the **Model Context Protocol (MCP)**, allowing it to seamlessly connect to other agents in the ecosystem. You could have a Koog-powered Java backend communicating with an Anthropic-powered frontend agent, sharing the same technical context and tool definitions through a unified standard.
Executing AI-generated code or allowing an LLM to call arbitrary Java methods is inherently risky. JetBrains has addressed this by implementing a **Bytecode Sandbox**. When an LLM requests a tool call, Koog validates the arguments against the method's signature and runs the execution within a restricted **Security Manager** context (or its 2026 equivalent). This prevents the agent from performing unauthorized file I/O or network calls unless explicitly permitted in the `koog-config.yaml`.
Phase 1: Instrumentation Audit: Use the IntelliJ Agent Inspector to scan your classpath and identify high-value service methods for AI exposure. Focus on stateless logic first.
Phase 2: Sandbox Configuration: Define granular permissions in `koog-config.yaml`. Explicitly block destructive operations and restrict external API access from the agent context.
Phase 3: Agentic Feedback Loops: Deploy in "Audit Mode" initially, allowing the Koog reasoning kernel to propose fixes to logs and metrics before granting autonomous execution rights.
Evaluate high-traffic service methods for @AgentTool exposure. Prioritize read-only lookup services to minimize side-effect risks during initial beta testing.
Review koog-config.yaml templates. Implement strict RBAC for method invocation and ensure all AI-triggered transactions are logged in existing SIEM pipelines.
JetBrains Koog represents a significant shift in how we think about "AI-enabled" software. Instead of building AI *on top* of our apps, we are now building AI *into* the runtime itself. For the millions of enterprise Java applications running today, Koog provides the most practical and performant path to the Agentic Web.
The beta is available now for all JetBrains subscribers. If you are running Java 17 or higher, it is time to attach the agent and see what your application can do when it starts thinking for itself.
Check out our recent post on **Claude Code** to see how JetBrains is competing in the autonomous coding space.
Join 50,000+ engineers getting daily deep dives into AI, Security, and Architecture.