Netflix speeds up Java AI agents: IntelliJ engine saves 20–30% on typical tasks, up to 65% at best

Netflix teams (Application Development Platform, GenAI Platform and Agentic SDLC) set out to find what it costs when AI agents lack a proper understanding of code. They connected a headless version of JetBrains' code analysis engine, the same one that powers IntelliJ IDEA, to Claude Code and Codex. On real tasks, the agents used 20–30% fewer tokens and less time, and in the best case the savings reached about 65%. Correctness did not drop in any measurement. The tests ran in July–August 2026.

The problem: JAR files where the agent goes blind

In JVM projects, libraries usually ship as JAR archives without sources. The agent has to unpack the archives itself, guessing which ones matter, decompile class files if necessary, and then search that incomplete slice with grep. The search is slow and unreliable, and tokens are spent on wandering. Paul Bakker, Staff Software Engineer at Netflix, describes it this way: agents like Claude Code are slow and unreliable at navigating Java/Kotlin, especially at library boundaries.

JetBrains has spent years building a deterministic index of a project's sources together with all of its libraries. It is now available through LSP, including in VS Code-compatible editors. But LSP alone is not ready for agents: it is a server with a protocol that an agent cannot simply call, and it has no process management for reusing an instance that is already running.

A daemon that keeps the index warm

Building the index takes noticeable time, like the first time you open a large project in IntelliJ IDEA. An agent, however, hits LSP with many small steps, and a single task needs several such calls. If each call spins up a new server, each pays for a cold start of several seconds, even when the index was built a minute earlier.

JetBrains had not yet released a daemon at the time of the evaluation, so Netflix wrote one itself:

• each tool call is short-lived and stateless; it simply talks to the CLI;
• the daemon's session manager routes the call by project root to the right server process, which holds the index in memory;
• a repeat call on the same project skips indexing and goes to the "warm" server over stdio;
• the daemon and CLI are written in Java and distributed as a GraalVM executable, so there is no JVM startup overhead.

How it was measured and what came out

The setup was simple: one model, one task, one codebase, and a single variable: whether the agent has access to the JetBrains engine. Two real codebases were used:

• a mid-sized internal production service on Spring Boot 4 and Gradle;
• Netflix's open-source DGS Framework, a mixed Kotlin/Java GraphQL framework.

Tasks fell into two types. The first was small navigation tasks: where an interface is used, what its implementations are, what a class's structure looks like. The second was end-to-end tasks: implement a feature, refactor a class, delete code. The agent and model configurations were:

• Claude Code with Opus 5 (medium/high effort);
• Claude Code with Sonnet 5 (medium/high effort);
• Codex with GPT-5.6 Sol (medium/high effort).

The main metrics were token consumption and execution time. Correctness was checked by an LLM judge: against a reference set of changes for end-to-end tasks, and by a deterministic metric for navigation tasks. Tasks that failed, hit the budget limit or got stuck in a loop in at least one of the groups were excluded from both, so that a single failure would not skew the comparison. Runs were repeated several times.

On navigation tasks, every model and effort level used fewer tokens, and the strongest model gained the most. Correctness stayed the same in most runs, rose in two, and did not fall anywhere. There was one anomaly: one combination of tool and model batches several search calls into a single command and makes one call both with and without the engine.

For it, calling the engine is slightly slower, so there is no time gain there, and Netflix does not consider that data point representative of real work. It is more reliable to look at the end-to-end tasks, where the engine was faster for every model and agent, and part of the effect is explained by fewer tool calls for the same conclusions.

The largest gains came from strong models at a high effort level. They are more expensive, so savings on them are worth more, and they are better at working with the index. Netflix stresses that the numbers are a snapshot: every new model changes how agents search, reason and call tools.

What was rejected and where to go next

Before settling on the final design, Netflix discarded two options. The first was an in-house CLI that connected to a running IntelliJ IDEA: it requires an open IDE and does not work for headless environments such as Otto, Bitbot, distributed refactoring tools and CI. The second was Eclipse LSP, which VS Code uses for Java: it simply did not work with Netflix's Gradle build.

Next, the company will run the same methodology on Python, TypeScript/JavaScript and Go, where agents have similar problems, although the mechanics of loading libraries in those ecosystems differ. JetBrains has already shipped the Java intelligence that Netflix tested as part of the Java & Kotlin by IntelliJ IDEA extension, and it continues to experiment with the LSP+CLI approach.

Alexey Stukalov, head of JetBrains' IDE division, points to a weak spot in LSP itself: its basic primitive is a cursor position in text, while agents think in terms of symbols, diagnostics, test relationships and runtime behavior. A text position is fragile and shifts with a single inserted letter. In his words, agents do not need a virtual editor; they need a code engine with precise operations on the structure of a program.

For teams already paying for agents on the JVM, the takeaway is practical. If tokens on strong models are a noticeable cost item, a deterministic code analysis layer next to the agent pays off faster than a model upgrade. But there is no ready-made daemon in a box yet: teams will have to build one themselves following Netflix's design or wait for a JetBrains release.