IntelliJev · Find context

Give your coding agent the right files sooner.

IntelliJev is one IntelliJ plugin. In its Find context workspace, you describe a change; its Jev engine ranks the project's source files and hands back the handful that change will touch, ranked, with the reason each one matters. People use it from a panel in the IDE, and AI agents get it automatically before they start.

Provider scope: the measurements and pipeline below use Jev. The combined plugin also offers Fast keywords and local Laya. Those have a separate local benchmark; the Jev speed and quality figures do not apply to them. Automatic agent delivery requires installing the hook.

4 s
measured Jev pack on a 1,700-file Kotlin project
69%
of the files a real change touched land in its top 10. Keyword search: 53%.
−25%
fewer steps for Claude Code to reach the same answer
$0.03
per ranking, all of it for the AI that does the judging

The problem

Ask an AI coding agent to "add exponential backoff to the retry logic" and it doesn't know where that logic lives. So it does what a new colleague would: searches for a word, opens a file, decides it's the wrong one, opens another. Every one of those steps is a round trip to a large language model, which is slow and costs money.

Without IntelliJev context

  1. Search the code for "retry"
  2. Open a file, wrong one
  3. Search for "backoff"
  4. Open another, closer
  5. List a folder
  6. Find the test
  7. … then start the actual work

With IntelliJev context

  1. The request arrives already carrying a ranked list: the file to edit, the test that checks it, an example to copy
  2. Read the top files
  3. Start the actual work

The idea: one AI decides, another writes

There are two kinds of AI in this. Jev decides. The LLM writes.

Jev, from TypeSafe, is a new kind of model that can't write a single sentence. It only answers questions, as probabilities: "how likely is it that this change needs this file?" Because that's all it does, it's fast and very cheap, cheap enough to ask the same question about every file in a project, every time.

The large language model (Claude, GPT and so on) is the one that writes code. It's powerful but slow and expensive, so you want it spending its effort on the right files, not on finding them. IntelliJev lets Jev do the looking, so the LLM only does the writing.

How it works, in three steps

From 1,705 files to the 10 that matter 1,705 filesevery Kotlin file, skimmed by keyword search and by Jev reading a short summary of each ~100 filesthe shortlist, read properly in full top 10compared
1

Skim everything

Two scouts go through every file at once. One matches words (the classic search engine trick). The other is Jev, reading a one-paragraph summary of each file and judging whether the change needs it. About 2 seconds.

2

Read the shortlist

The best 60 from each scout, about 100 files, get read in full by Jev, which catches things a summary hides, like a field buried inside a function. About 1 second.

3

Compare the finalists

Jev looks at the top 10 side by side and picks the one most likely to be edited, and labels the others: the test, an example to follow, an API it depends on. Under half a second.

What it looks like

IntelliJ with the Context Packer panel on the right, listing ranked files with role labels such as edit, test and dependency
An agent asked for "Support reasoning_content in Delta for OpenAI". The panel on the right fills itself: the file to edit at the top, then the tests and dependencies around it.
The Context Packer panel with an LLM answer at the bottom that names the exact method to change
Press Ask LLM and a language model answers from just those files, in one go: it names the method to change and says which files it would still want.

Does it actually work?

We didn't want a claim, we wanted a measurement. So we used real history: each test is a real change someone made to Koog, JetBrains' own AI-agent framework. We give IntelliJev's Jev context engine the change's one-line description, show it the code exactly as it was before the change, and check whether it finds the files the developer actually edited. We tuned it on one set of changes and then tested it once on 70 it had never seen.

+16 pts

Better than keyword search. Of the files each change touched, 69% show up in the Jev pipeline's top 10, against 53% for the classic search approach. The margin is large enough that it isn't luck.

Keyword search
53%
Jev + BM25
69%
2 repos

Not tuned to one codebase. On a second JetBrains project, Exposed, which it was never tuned on, it still beat keyword search clearly in its top 5 (54% against 43%).

30×

As good as asking an LLM, far faster. Having a language model re-rank the same shortlist gets the same top-10 result, but takes about 29 seconds per request instead of 1. The LLM is still a bit better at picking the top five.

−25%

Agents take fewer steps. Claude Code, given the ranked files before it starts, needed a quarter fewer steps and 38% fewer searches to reach the same answer, on 8 real tasks.

What it isn't, yet

Where it fits

IntelliJev is one installable plugin with a context-finding workspace and a reviewed-edit workspace. In the measured Jev mode, a fast decision model helps select files before a coding model proposes changes. The developer inspects the diff and decides whether to apply the edit. Local Laya and keyword modes are also available for context finding; the Jev results on this page do not describe their performance.