Ai logo

JetBrains AI

Supercharge your tools with AI-powered features inside many JetBrains products

Agentic AI AI Customer Stories Java Use Case

Comment Netflix a boosté l’efficacité de ses agents de programmation IA grâce à l’intelligence des JetBrains IDEs

Read this post in other languages:

Netflix a intégré le moteur d’intelligence du code headless de JetBrains (le même que celui utilisé par IntelliJ IDEA) à Claude Code et Codex, puis l’a évalué à l’aide de différents scénarios de tests. Vous trouverez les détails et les chiffres ci-dessous.

En bref

Entreprise Netflix – équipes Application Development Platform (ADP), GenAI Platform et Agentic SDLC
Défi Les agents de programmation avaient du mal à naviguer dans le code Java/Kotlin, en particulier au-delà des limites des bibliothèques compilées (JAR)
Technologie Intelligence du code des JetBrains IDEs pour Java, reposant sur le même moteur d’indexation du code que celui d’IntelliJ IDEA, exécutée en mode headless, sans qu’un IDE soit ouvert.
Rôle de Netflix A conçu le daemon et l’interface en ligne de commande nécessaires pour permettre à un agent d’appeler le LSP (une infrastructure que JetBrains n’avait pas encore livrée).
Résultat En général, une efficacité supérieure de 20 à 30 % (moins de tokens et moins de temps), pouvant atteindre environ 65 % dans les meilleurs cas, sur des tâches de programmation réelles. Le gain dépend du modèle, de l’agent et de la tâche ; il est généralement plus important avec les modèles les plus performants et les niveaux d’effort les plus élevés.
Évalué sur Deux bases de code réelles (un service interne en production et le framework open source DGS de Netflix) évaluées avec plusieurs agents de programmation et modèles récents, en juillet et août 2026.

L’objectif : augmenter le ROI des agents

JetBrains et Netflix se sont donné pour objectif de fournir aux agents de programmation une compréhension précise du code, à la hauteur de celle d’IntelliJ IDEA, dans des environnements headless, sans qu’aucune instance d’IntelliJ IDEA ne soit en cours d’exécution.

« Les agents de programmation tels que Claude Code sont lents et peu fiables lorsqu’il s’agit de naviguer dans du code Java/Kotlin, en particulier au-delà des limites des bibliothèques (JAR). Nous avons intégré le moteur de code d’un JetBrains IDE conçu pour fonctionner en mode headless, afin de fournir aux agents une compréhension du code à la hauteur de celle des IDE JetBrains, dans des environnements sans interface graphique et sans IDE en cours d’exécution. Nous avons créé un benchmark avec des tâches de programmation réelles, qui montre qu’avec le moteur de code des JetBrains IDEs, les agents sont systématiquement plus efficaces : ils utilisent moins de tokens et et passent moins de temps à ffectuer les tâches, même si le gain exact dépend du modèle. »

— Paul Bakker, Staff Software Engineer chez Netflix

Le problème des fichiers JAR que Netflix essaie de résoudre, tel que décrit par Paul plus haut : les projets JVM ne distribuent généralement leurs bibliothèques que sous forme de fichiers JAR, jamais en tant que code source. Les agents doivent décompresser les fichiers JAR (en devinant lesquels sont pertinents), éventuellement décompiler les fichiers class, puis effectuer des recherches textuelles dans cette vue incomplète du code.

La solution : l’intelligence des JetBrains IDEs

JetBrains a passé des années à développer le moteur d’intelligence du code sur lequel repose IntelliJ IDEA. Il s’appuie sur un index déterministe des fichiers source de votre projet, incluant toutes les bibliothèques. Cette intelligence est désormais accessible via un LSP et disponible dans les éditeurs compatibles avec VS Code. Netflix a travaillé avec un build headless de ce moteur.

Le LSP à lui seul ne suffit pas pour qu’un agent de programmation puisse l’utiliser directement : il s’agit simplement d’un serveur qui communique via un protocole, sans moyen simple pour un agent de l’appeler ni mécanisme de gestion des processus intégré permettant de réutiliser une instance déjà en cours d’exécution d’un appel à l’autre. Netflix a comblé ce manque par ses propres moyens, grâce au daemon et à la CLI décrits dans la section suivante.

Architecture détaillée : maintenir l’index prêt à l’emploi

Indexer un projet prend un temps non négligeable, tout comme lors de la première ouverture d’un projet volumineux dans IntelliJ IDEA. Un agent de programmation interroge le LSP en de nombreuses petites étapes successives, et une tâche réaliste nécessite plusieurs appels de ce type. Si chaque appel lançait un nouveau serveur LSP, chacun entraînerait un délai de démarrage à froid de plusieurs secondes, même pour un projet dont l’index aurait été créé une minute auparavant.

Un processus daemon est nécessaire pour éviter les surcoûts liés au démarrage à froid du serveur LSP à chaque nouvel appel. JetBrains travaille actuellement au développement d’un daemon, mais aucun daemon n’était disponible au moment de l’évaluation. Netflix en a donc créé un pour répondre à ses propres besoins :

  1. Chaque appel d’outil était éphémère et sans état persistant : il se contentait de lancer la CLI via un shell.
  2. Le daemon est le composant qui reste actif : son gestionnaire de sessions achemine chaque appel vers le processus serveur correspondant à la racine du projet. Ce processus conserve l’index du projet en mémoire.
  3. Un deuxième appel portant sur le même projet ignore entièrement l’étape d’indexation et communique directement, via stdio, avec un serveur déjà opérationnel.
  4. Le daemon et la CLI sont tous deux développés en Java et distribués sous forme d’exécutables GraalVM, ce qui évite toute surcharge liée au démarrage ou à l’exécution de la JVM.

Comment Netflix a mesuré le ROI de l’intelligence des JetBrains IDEs

Une série de benchmarks a été développée pour comprendre si l’intelligence des JetBrains IDEs améliorait les performances d’un agent de programmation, et dans quelle mesure. Même modèle, même tâche, même base de code : la seule variable était la possibilité pour l’agent d’exploiter l’intelligence du code des IDE JetBrains. Les résultats sont présentés sous forme d’écart de performance entre les exécutions bénéficiant de l’intelligence des JetBrains IDEs et les autres.

Environnement et approche d’évaluation :

Jeux de données Deux bases de code réelles : un service interne (projet de taille moyenne) utilisant Spring Boot 4 et Gradle.
Le framework open source DGS Framework de Netflix : un framework GraphQL public combinant Kotlin et Java.
Tâches Deux types de tâches :
De petites tâches ciblées dans lesquelles l’agent tente de comprendre des spécificités de la base de code, par exemple « où cette interface est-elle utilisée dans le projet », « quelles implémentations existent pour cette interface », « quelle est la structure de cette classe ».
Des tâches complètes de bout en bout, telles que l’implémentation d’une nouvelle fonctionnalité, la refactorisation d’une classe ou la suppression de code.
Modèles Claude Code avec Opus 5 (effort moyen/élevé)
Claude Code avec Sonnet 5 (effort moyen/élevé)
Codex avec GPT-5.6 Sol (effort moyen/élevé)
Évaluation Même si les principaux indicateurs de l’expérience étaient le nombre de tokens consommés et le temps nécessaire à l’exécution des tâches, un système d’évaluation par un LLM (« LLM-as-a-judge ») a été mis en place pour vérifier la justesse des résultats. Il s’appuie sur un ensemble de modifications de référence pour évaluer les tâches de bout en bout et applique une métrique de notation déterministe pour les tâches de navigation.
Traitement des valeurs aberrantes Toute tâche ayant provoqué un plantage, atteint la limite de budget ou entraîné un comportement instable dans l’une ou l’autre des deux configurations a été exclue des deux, afin qu’un incident isolé ne fausse pas la comparaison.

Les benchmarks ont été exécutés plusieurs fois afin de valider les résultats et d’observer les effets des modifications apportées par les nouvelles versions du LSP.

Résultats

Pour tous les modèles, agents et types de tâches testés, l’intelligence des JetBrains IDEs a permis un gain d’efficacité global des agents de programmation, généralement de 20 à 30 %, et jusqu’à environ 65 % dans le meilleur des cas, en fonction du modèle, de l’agent et de la tâche. Les modèles les plus puissants, avec un niveau d’effort plus élevé, ont enregistré les meilleurs gains. Ces modèles sont plus coûteux, donc les gains d’efficacité sont d’autant plus importants. Mais ils sont également plus performants pour exploiter efficacement les index.

Gain d’efficacité par configuration, combinant économies de jetons et de temps. Chaque comparaison exécute la même tâche, avec le même modèle et sur la même base de code à deux reprises : une fois en disposant de l’intelligence des JetBrains IDEs, une fois sans.

~25%
Gain moyen
20–30%
Fourchette typique
~65%
Meilleur cas
Configuration Navigation dans le code De bout en bout
Modèle le plus performant, effort élevé ~65% ~24%
Modèle intermédiaire, effort élevé ~29% ~30%
Modèle intermédiaire, effort moyen ~24% ~22%
Configuration allégée, effort élevé ~17%* ~21%

L’efficacité correspond à la moyenne des gains en jetons et en temps pour chaque configuration. La justesse est restée stable ou s’est améliorée à chaque exécution. *Tokens uniquement : les appels de recherche groupés de cette configuration rendent la comparaison des temps de navigation dans le code non représentative. Voir le texte de l’article. Ces chiffres représentent un instantané et évolueront avec la sortie de nouveaux modèles.

Ces résultats représentent un instantané, et non un résultat de benchmark figé. Chaque nouvelle version de modèle modifie la façon dont les agents cherchent, raisonnent et utilisent les outils, si bien que les pourcentages exacts continueront d’évoluer. C’est pourquoi cet article présente des fourchettes de résultats plutôt que des résultats par modèle. Dans l’ensemble des tests menés par Netflix, une tendance générale a émergé : tous les modèles et agents testés ont gagné en efficacité. Les gains les plus importants provenaient du modèle le plus performant utilisé avec un niveau d’effort élevé, et l’ampleur de ce gain variait sensiblement d’un modèle à l’autre.

Tâches de navigation dans le code : une efficacité accrue dans tous les cas, sans baisse de la justesse des résultats, qui est restée stable ou s’est améliorée.

Tous les modèles et niveaux d’effort testés ont consommé moins de jetons grâce à l’intelligence des JetBrains IDEs (sans aucune exception), avec des économies allant de 15 à 60 %. L’ampleur du gain dépendait surtout du modèle : le modèle le plus puissant a montré de loin les meilleures améliorations, tandis que les configurations plus légères se situaient plutôt en bas de ces deux fourchettes. La justesse est restée stable dans la plupart des exécutions et s’est améliorée dans deux d’entre elles ; elle n’a jamais diminué.

Pour les tâches de navigation dans le code en particulier, une combinaison d’outil et de modèle regroupe déjà plusieurs appels de recherche en une seule commande. Ainsi, avec ou sans l’intelligence du code d’un IDE JetBrains, un seul appel d’outil est effectué dans ce cas. L’appel à l’intelligence du code des IDE JetBrains est légèrement plus lent que la commande de recherche groupée pour cet appel unique. C’est ce qui explique l’absence de gain de temps notable pour cette combinaison, un résultat qui ne reflète pas fidèlement les conditions d’utilisation réelles. C’est pourquoi il est plus pertinent de se fier à la série plus large de tests de bout en bout pour évaluer les gains de temps : l’intelligence du code des IDE JetBrains a permis d’accélérer l’exécution pour tous les modèles et agents testés.

Tâches de bout en bout : une efficacité systématiquement accrue, sans incidence sur la justesse

Sur la série élargie de tests de bout en bout, la justesse des résultats est restée stable pour tous les modèles et agents testés. Le gain porte donc entièrement sur l’efficacité, et non sur la capacité à mener la tâche à bien. Chaque combinaison de modèle et d’agent a gagné environ de 10 à 30 % en efficacité grâce à l’intelligence du code des IDE JetBrains, en termes de temps d’exécution et de consommation de tokens. Cela s’explique en grande partie par le fait que les agents ont besoin de moins d’appels d’outils pour parvenir aux mêmes conclusions.

Autres alternatives évaluées

Avant d’adopter l’approche décrite, Netflix a écarté deux autres solutions. La première solution écartée était une CLI interne développée en interne, qui se connectait à une instance d’IntelliJ IDEA en cours d’exécution pour accéder à l’index d’un projet. Le processus est similaire à celui décrit dans cet article, mais il nécessite qu’un IDE soit en cours d’exécution. Cette approche ne convenait pas aux agents fonctionnant en mode headless dans des environnements tels qu’Otto, Bitbot, les outils de refactorisation distribués ou les pipelines d’intégration continue (CI).

En deuxième solution, un LSP Eclipse existant, utilisé pour Java dans VS Code, a été envisagé. Mais pour le système de build de Netflix (basé sur Gradle), cela ne fonctionnait tout simplement pas.

Ce qui est prévu par la suite 

Quelles sont les prochaines étapes pour Netflix ?

Après ce test, Netflix a conclu que « les benchmarks démontrent un intérêt réel à disposer d’une couche d’intelligence déterministe en parallèle de votre agent ». Bien sûr, le gain d’efficacité n’est pas identique pour toutes les tâches confiées à un agent de programmation. Mais pour ce problème précis (comprendre la structure réelle du code au-delà des frontières entre fichiers JAR), le gain est important, se confirme quel que soit le modèle utilisé et ne se fait au détriment d’aucune perte de justesse des résultats.

Netflix prévoit d’appliquer la même méthodologie de benchmark pour Python, TypeScript/JavaScript et Go. Les agents de programmation pour ces langages rencontrent des problèmes similaires. Bien sûr, les modalités de téléchargement des bibliothèques dans un projet varient selon le langage utilisé. Les mécanismes en jeu et les solutions possibles diffèrent donc eux aussi. JetBrains prévoit de poursuivre cette collaboration et de continuer à soutenir cette évaluation.

Le point de vue de JetBrains : le LSP n’est qu’une étape, pas une fin en soi.

L’intelligence des JetBrains IDEs pour Java a été testée par Netflix et elle est désormais intégrée à l’extension Java & Kotlin by IntelliJ IDEA. JetBrains poursuit également ses expérimentations avec l’approche LSP+CLI et en communiquera les résultats dès qu’ils seront prêts.

L’unité de base du LSP est une position dans un document texte. La spécification définit cette position comme étant « située entre deux caractères, comme un curseur d’insertion dans un éditeur ». C’est une unité de base naturelle pour un humain qui travaille au clavier. Mais les agents ne raisonnent pas vraiment en termes de position du curseur. Ils posent des questions sur le programme, du type « Pourquoi cet appel à l’intérieur de createUser() est-il non résolu ? » ou « Quels tests couvrent cette méthode ? », etc. Il s’agit de comprendre les relations entre les différentes parties du code, plutôt que de se concentrer sur la position du curseur. Et la position d’un texte est un repère fragile : l’insertion d’un seul caractère avant une position donnée suffit à la décaler.

Ce dont un agent a besoin, ce n’est pas d’un curseur plus précis, mais d’une couche qui fournisse des réponses formulées dans les mêmes termes que les tâches elles-mêmes (c’est-à-dire en termes de symboles, de diagnostics, de relations entre les tests et de comportement à l’exécution) et qui renvoie suffisamment de contexte pour lui permettre de raisonner, plutôt que de simples emplacements dans un document texte.

« C’est ce que j’entends par moteur d’intelligence du code : non pas un protocole supplémentaire permettant à un agent de reproduire les interactions avec un éditeur, mais un ensemble d’opérations précises sur la structure et l’exécution des programmes, qui fournit suffisamment de contexte pour pouvoir réellement raisonner sur le résultat. Le LSP est utile, mais il ne devrait pas définir l’abstraction finale destinée aux agents. Si vous concevez les outils destinés aux agents comme si ces derniers étaient de minuscules humains devant un éditeur, vous les obligez à s’exprimer en coordonnées de curseur. Les agents ont besoin d’un moteur de code, pas d’un éditeur virtuel. »

— Aleksey Stukalov, Directeur de la division IDE chez JetBrains

Les chiffres de Netflix prouvent que l’intelligence du code est un investissement rentable. Le défi qui nous attend consiste à déterminer quelle forme cette intelligence doit prendre.

Anastasia Kazakova

Anastasia Kazakova

Discover more