IntentLens: Why Is the Code Like This?

Ask why your code is the way it is. IntentLens turns git history, PRs and comments into a Neo4j decision graph, and Nemotron 3 Ultra on Nebius answers with cited evidence, or refuses to guess.

Comment

Inspiration

When a senior engineer leaves, the reasoning behind the code leaves with them. Search gives you 150 commits that mention a setting, the wiki was last updated in 2019, and a plain LLM confidently invents a rationale that was never written down anywhere.

We wanted a tool that answers "why is the code like this?" only when it can prove the answer, and says "I don't know" when it can't.

What it does

IntentLens ingests git history, GitHub pull requests and source-code comments, builds a Neo4j knowledge graph linking every code entity to the engineering decision behind it, and answers natural-language questions with a cited evidence trail.

  • Answered: every sentence cites evidence (commit, PR or comment), and claims without valid citations are dropped.
  • Superseded: if a decision was later overridden, IntentLens shows the current decision, with the old one struck through in history.
  • Refused: if the graph has no governing decision, or confidence is below 0.35, it refuses. It then shows who last changed the code, the closest discussions, and a person to ask.
  • Multilingual: Hindi and Hinglish questions are normalised to English while code identifiers are preserved.

Demo graph (the replication and persistence subsystem of redis/redis): 570 decisions, 14,348 nodes, 27,249 relationships, including 18 SUPERSEDES and 40 REFINES edges.

How we built it

Nemotron 3 Ultra on Nebius Token Factory powers every LLM step:

  1. Two-pass decision mining. A normal pass and a conservative pass extract decisions from PRs, commits and comments. The agreement between the two passes feeds the confidence score, and every decision must include a verbatim quote that is verified against the source.
  2. Semantic supersession classification. Decision pairs are classified as reinforces, refines, contradicts or unrelated, which creates SUPERSEDES or REFINES edges.
  3. Grounded answer generation. The model returns JSON claims, each of which must cite an evidence reference from the retrieved pack.
  4. Hindi/Hinglish query normalisation.

Around the model:

  • Neo4j AuraDB holds the graph and a vector index. Retrieval is entity linking, then GOVERNS graph traversal, with a vector-similarity fallback.
  • FastAPI serves the backend, and a React + Vite frontend has an interactive graph explorer built on Neo4j NVL.
  • Parameterised Cypher only. The LLM never writes queries.
  • Confidence comes from graph facts, never from the model's self-rating:

$$\text{Confidence} = 0.30\,D + 0.25\,C + 0.20\,A + 0.15\,U + 0.10\,H$$

where D is directness, C is corroboration, A is agreement between the two mining passes, U is currency and H is graph distance.

Why Nemotron and Token Factory: judging whether one engineering decision overrides another needs real reasoning, and the pipeline depends on reliable structured JSON. Token Factory's OpenAI-compatible endpoint let us move the whole LLM layer behind one client with retries and JSON hardening. [Add one sentence on measured latency or throughput.]

What changed during the submission period

IntentLens existed before this hackathon as an earlier build using a different LLM provider. For this submission we:

  • Migrated the entire LLM layer to Nemotron 3 Ultra on Nebius Token Factory.
  • Built a unified LLM client with retries and JSON hardening that strips reasoning blocks.
  • Reimplemented multilingual normalisation on Nemotron.
  • Added a live model badge in the UI.
  • Ran new Nemotron mining and supersession runs (see eval/nemotron_run.md).
  • Added the license, deployment setup and rewritten documentation.

[Delete any line you did not actually finish.]

Challenges

  • Getting reliable JSON from a reasoning model: stripping reasoning blocks, extracting the first valid object, and retrying with a stricter prompt.
  • Preventing hallucinated citations. Verbatim quote verification and citation checks drop unsupported claims before they reach the user.
  • Making refusal a feature. Deciding when "no answer" is the correct output, and showing something useful when we refuse.
  • Detecting supersession across decisions made years apart on the same setting.

Accomplishments we're proud of

  • Honest refusals: updateSlavesWaitingBgsave has 37 commits but no mined decision, so IntentLens says so instead of guessing.
  • Superseded-decision tracking that never presents an overridden decision as current.
  • A baseline comparison against plain vector RAG, which can't cite, can't detect supersession and always guesses.

What we learned

Trustworthy AI for developer tools comes from the structure around the model: verified quotes, graph-derived confidence and the freedom to refuse. A strong reasoning model is most useful when it is constrained that way.

What's next

  • Ingest more repositories and subsystems.
  • A GitHub App that explains the reasoning behind a changed line directly in pull request reviews.
  • Incremental updates as new PRs merge.
  • Ask-the-owner workflows when the system refuses.

Built With

  • cypher
  • docker
  • fastapi
  • github-graphql-api
  • graphrag
  • javascript
  • nebius-token-factory
  • neo4j
  • neo4j-auradb
  • nvidia-nemotron
  • openai-sdk
  • pydantic
  • pydriller
  • python
  • react
  • render
  • sentence-transformers
  • vercel
  • vite
Share this project:

Updates

Submission history