Skip to content
CODE INTELLIGENCE ENGINE

The engine that gives our agents the whole repository

Our code-intelligence engine gives our agents the shape of a whole repository before they touch it, and hands them the context a change needs within a budget they can afford.

  • IndustryDeveloper tooling
  • EngagementInternal engine, built for our own agents
  • StatusIn use on our own work, still being extended
  • Code intelligence
  • Code search
  • Agent infrastructure
  • Developer tooling

Built for our own agents first

This is our own tool: the part of our toolchain that decides what an agent gets to see before it touches anything. It gives an agent the project context to inspect relevant definitions and references before changing code.

The constraint that shaped everything is the reasoning budget. An answer too large to read is worse than a smaller answer that fits, so every answer is sized to what the agent can use. The point is to reserve the budget for the work.

THE CHALLENGE

The problem was ours

Agents working on large codebases need relevant project context before making changes.

An open file is not a codebase

An agent asked to change a function could see the function and the file around it. What called it, what it called in turn, and which parts of the project would notice the change all sat outside the frame. The change was reasoned about in isolation, and reviewed the same way.

Reading a whole project to find one thing

Without a map, finding the right place means opening files and discarding them. Every discarded file has already been paid for out of the same budget the actual work needs, and on a large repository that cost arrives before any useful thinking starts.

Finding the right code in a large repository

Relevant code is hard to locate when an agent does not know its name or where it lives, and every wrong guess is paid for out of the budget the work needs.

THE SOLUTION

What the platform does

Agents receive the project context a change needs, sized to what they can use.

The shape of a project before a file is opened

An agent starts with what is declared where, so a change is reasoned about in the context of the project it lands in.

  • Declarations are indexed across the languages we work in
  • An agent can see the shape of a file it has not read
  • A project map stays readable however large the repository is

Found by name or by description

An agent can search by an identifier or by a description of the code it needs and inspect what comes back.

  • Search by the exact identifier
  • Search by a description of what the code does
  • Results presented for the agent to assess

What a change will touch

Alongside definitions, the engine knows where names are used and which files depend on which. That turns a lookup into a question about consequences.

  • What depends on this is answered beside where this is defined
  • What a file pulls in, and what pulls the file in
  • What changed lately comes back with the answer

Bounded answers, and no customer code leaves the machine

Two rules shaped the delivery side. An answer has to fit the space the caller has for it, and none of the code should have to leave the machine to be understood.

  • A broad query cannot flood the agent's context
  • The index lives on the developer's own machine and no code is uploaded anywhere
  • The project context is refreshed as work changes
THE IMPACT

What changed in our work

Agents can inspect relevant project context before reviewing or changing code.

Whole repository

What a review starts from

A review or a refactor begins with the shape of the project: what the change touches, what uses it, and what pulls it in. The open file stopped being the boundary of what could be reasoned about.

Budget on the work

Where the reasoning goes

Answers sized to fit mean less of the available context is spent opening files that turn out not to matter. The gain is in what never has to be read.

Stays on the machine

Why we can point it at client code

The index is kept on the developer's own machine and no code is uploaded anywhere.

Last reviewed:

Do your tools see the whole codebase, or only the open file?

Tell us how your team works with a large repository today and where the context runs out. We will tell you what is worth automating and what is not.

Discuss your project