AI Engineer Code 2025
Your Coding Agent Is 6 Months Out of Date — Jakub Hojsan, Exa
Loading slides…
Read the talk
Your Coding Agent Is 6 Months Out of Date
Jakub Hojsan explains how Exa supplies current evidence to coding agents, why a search tool needs rules for when to run, and how query-dependent highlights keep retrieved context small.
From a talk by Jakub Hojsan
At a glance
Ideas worth remembering
A dependency-related diff can require upstream evidence to explain its purpose. Parameter removal may be a migration requirement rather than a cleanup.
Search integration has two parts: provide the tool and define triggers for using it, such as a dependency or version bump.
Query-dependent highlights select different passages from the same source, keeping model context tied to the question rather than to a fixed page summary.
Queries, sources and supplied highlights give developers a retrieval trace they can inspect when an answer goes wrong.
The ending separates relevance from output structure: embeddings, filtering and reranking select documents, while caller-confirmed schemas organize the returned information.
A dependency migration can look like a cleanup
A pull request removes a parameter, and a coding agent reads the diff as a tidy cleanup. The actual reason is a dependency upgrade: the calling code must change because the upstream API changed. That difference matters in review. Recognizing a consistent edit does not explain whether it is required, or whether it completes the migration.
Jakub Hojsan, a Forward Deployed Engineer at Exa, introduces this problem through the gap between a model’s knowledge cutoff and its release. He describes a typical lag of around six months; that is the talk’s framing, rather than a fixed interval for every model. Repository changes made after the cutoff can therefore be unfamiliar even to a newly released model. A review that relies on remembered API behavior may miss the reason for a perfectly reasonable diff.
The human debugging path supplies the missing step. A developer sees a compilation error, searches for the error or asks whether the parameter was removed, and uses the answer to prepare a fix. For the agent, searching the upstream repository and changelog can turn the same deletion from an apparent cleanup into an explained migration: the dependency changed, the old parameter no longer fits, and the caller needs to follow the new interface.
Give the agent a reason to search
Exa’s search interface returns context-rich highlights for a model to consume. In the migration example, the useful input is the passage explaining the breaking change, rather than the entire GitHub page. Hojsan contrasts a page containing 100,000 characters with a relevant excerpt of about 500 characters. Those quantities describe the presented example, not a guaranteed compression ratio for every search.
But retrieval only helps if the agent invokes it. Hojsan describes an agent rejecting a request to use a newer model because its remembered knowledge says the model does not exist—even though a search tool is available. The failure occurs before retrieval: the agent treats its old knowledge as sufficient and never checks.
A code-review rule can make the trigger concrete: when a diff bumps a dependency or version, inspect the upstream source and ground the review in what it says. This gives the harness two responsibilities. It must provide the search capability, and it must instruct the agent when to use that capability. The version bump becomes a visible reason to verify current behavior, without requiring the model to recognize an unknown API change from memory.
Where does the missing evidence enter the review? The flow below follows the dependency example from the search trigger to the migration explanation. The important connection is between the version change and the upstream passage: a small excerpt can change the interpretation of the diff because it supplies its cause.
From dependency bump to grounded review
Read the diagram as text
- Dependency or version bump. A change in the diff triggers the review rule.
- Search upstream evidence. Inspect the repository and changelog for breaking changes.
- Return the relevant passage. Supply a short explanation of the change rather than the whole page.
- Explain the migration. Interpret the parameter removal in relation to the dependency upgrade.
- Dependency or version bump → Search upstream evidence: Rule invokes search.
- Search upstream evidence → Return the relevant passage: Select change-specific context.
- Return the relevant passage → Explain the migration: Ground the interpretation.
Make retrieval inspectable and independent of the model
Once search runs, the integration determines what a developer can inspect and how much context the model receives. Hojsan presents four reasons to use Exa as a separate search service:
- Transparency. Exa exposes the queries, sources and highlights passed into the model. Sending that trace to telemetry lets a developer inspect the retrieval step when an answer goes wrong. Hojsan contrasts this with native search experiences that return sources without exposing all the retrieved content.
- Small context. Highlights select the passage needed for the question, reducing how much page text enters the model.
- Cost at scale. Hojsan claims more favorable search pricing and quality than native providers for sufficiently large workloads. The talk supplies no comparative pricing or evaluation protocol, so this remains a vendor claim rather than a demonstrated cost advantage.
- Model independence. One search API and parameter set can serve models from different providers. Changing the model does not require changing to that provider’s search interface.
The trace is especially useful because retrieval and generation are separate places for an answer to fail. Knowing which query ran, which source returned and which lines reached the model gives the developer something concrete to investigate. Model independence addresses a different concern: keeping the retrieval interface stable while the application changes its choice of model.
The same page returns different lines for different questions
How does Exa make those highlights? Hojsan describes selecting lines at runtime through computation, without using an LLM to synthesize the page. He claims this adds zero extra latency to the search call; the recording does not establish the timing conditions behind that claim. The mechanism he does explain is query-dependent selection: the question determines which parts of the source become model context.
The demonstration keeps the website constant and changes the request. A query for Hojsan’s biography returns information about photography and riding motorcycles. A query for his phone number returns a different set of information from the same website. The observable change is in the selected content, rather than in the source being searched. A biography passage can be relevant to one question and useless to the next.
What changes when the query changes? The comparison below makes the shared source visible. Each request selects different lines at runtime, so the model receives context shaped for its task rather than a fixed summary of the page.
The coding application follows the same relationship. A large repository may contain a “bajillion lines of code,” but the review needs the part that explains the API change. Hojsan also gives a news example: a request for the latest NVIDIA news that mentions Jensen should retrieve content satisfying that question. The useful unit is the relevant passage, not simply the page that happens to contain it.
One website, two selections
Read the diagram as text
- Same website. The source used for both requests.
- Biography request. biography — Selects photography and motorcycle interests.
- Phone-number request. contact — Selects a different set of contact-related information.
- Same website → Biography request: Lines selected for biography.
- Same website → Phone-number request: Lines selected for phone number.
Exa Agent takes on search orchestration
The talk then moves from a search API inside a coding harness to Exa Agent, an offering for applications that need search without building their own orchestration. Hojsan names Cursor, Cognition, Warp and CodeRabbit as users of Exa’s web search. Exa Agent extends the offering beyond web pages to partner data, including Similarweb for web analytics, Particle for podcast intelligence and Crunchbase for private markets.
The conference example changes the task from finding a passage to finding people. A query looks for people who have mentioned the AI Engineer Conference at its location, and Hojsan recognizes familiar people among the results, describing many as speakers. Public mentions can supply candidates for such a list, but they do not by themselves establish attendance or make the list exhaustive.
A related example searches for Exa employees and contact information for outbound work. These examples explain the packaging decision: Exa Agent handles search orchestration for a broader research task, while the API lets an application control that work itself. For coding agents, Hojsan points to Exa’s MCP integration as the route to making search available in a compatible harness. The earlier requirement still applies: the agent needs instructions telling it when to search.
Ranking finds relevant documents; schemas shape the result
The first audience question asks how Exa organizes and reranks billions of documents. The answer describes a multistage search: convert the query into an embedding, combine semantic search with keyword filtering, apply reranking and drop irrelevant results. Hojsan does not specify the internal ordering of every filtering stage or the reranker design. The distinction is useful nonetheless: finding candidate documents and deciding which candidates deserve to survive are separate parts of retrieval.
Exa also curates its index. Hojsan describes it as containing tens of billions of documents while being smaller than Google’s, with an emphasis on document quality. That choice makes coverage and selection part of the product’s tradeoff: search operates over a deliberately curated collection, rather than assuming that the largest possible collection is always the most useful one.
The final question asks whether the caller can supply a schema—for example, to receive a phone-number field rather than free-form prose. Hojsan describes entering the desired fields in natural language, generating a schema and clicking Confirm. The result then follows that schema. Enabling additional properties allows fields beyond those explicitly requested.
Hojsan gives a limit of up to ten fields on Deep and tentatively recalls up to a hundred on Agents; the latter limit is uncertain in his answer. The practical capability is clearer than that tentative count: callers can describe the information they need and confirm an output structure before receiving results. Retrieval determines which evidence reaches the application; the schema determines how that information is arranged for the next step.
Full transcript
Loading transcript…