The future of sourcing is not a database

Most AI sourcing products are built around the same promise:

Give us the job description. We will give you the candidates.

That sounds useful. It demos well. It is also the wrong abstraction.

A good recruiter does not start with candidates. A good recruiter starts with a theory of the market.

Where is this talent likely to have been created? Which companies produce it? Which titles describe the work badly? Which adjacent backgrounds might be better than the obvious ones? Which constraints are real, and which ones are just the first draft of a messy hiring conversation?

That is not matching.

That is search.

The next generation of AI sourcing will not be won by the company with the largest static database or the nicest "top 20 candidates" screen. It will be won by the company that builds the best search partner: a system that maps the market, explores different theories, verifies evidence, learns from recruiter judgement, and helps decide what to do with each person it finds.

The mistake is thinking AI sourcing is a retrieval problem. It is a problem of deciding where to search, what to trust, and what to do next.

That is the bet we are making at Nova.

The chat interface matters. The candidate cards matter. But the product only becomes reliable when there is a serious search system underneath: one that can reason about the role, search in several directions, preserve evidence, and change course when the recruiter teaches it something new.

Some of this exists in the product today. Some of it is the architecture we are building toward. The important point is the direction: the agent cannot just return plausible profiles. It has to make the search itself better.

Start with the market, not the list

The first job of an AI sourcing agent is not pulling profiles. It is building a market map.

For a complex role, the agent has to understand the shape of the talent before it starts ranking people:

• what companies create this kind of talent;
• which job titles are literal matches, and which ones hide the same work under different names;
• which adjacent backgrounds could be better than the obvious pool;
• which requirements are hard constraints, and which ones are useful signals;
• which false positives are likely to waste recruiter time;
• what evidence would make someone worth a serious look.

This matters because the first search shapes the entire pool.

If the agent searches the exact title too literally, it misses people doing the work under different names. If it searches too semantically, it finds people with the right language and the wrong experience. If it ignores company context, it cannot tell the difference between someone who held a title and someone who did the work at the right kind of company, stage, and scale.

Recruiters know this intuitively.

A Forward Deployed Engineer might be called that at one company. Somewhere else, the same person may be an applied AI engineer, a solutions engineer, a technical founder, a customer-facing machine learning engineer, or a product-minded platform engineer.

The title matters. But the title is not the work.

A sourcing agent has to learn the terrain before it asks the market for names.

A good recruiter does not run one search

Most sourcing software behaves as if the role can be turned into one query.

That is rarely how real recruiting works.

A strong recruiter thinks in lanes.

For the same role, one lane might search for literal title matches. Another might look for people doing adjacent work under different titles. Another might search alumni from companies known to produce the right kind of talent. Another might rediscover people already known to the team but missed because they were wrong for an older role, too early, too senior, too expensive, or simply buried inside old notes.

Those lanes are not interchangeable. Each tests a different theory about the market. Each produces a different kind of noise. Each teaches the recruiter something different about the role.

This is what good AI search has to do behind the scenes.

The recruiter still experiences something simple:

Find London-based applied AI builders for a forward-deployed engineering role. Bias toward people who have shipped with enterprise customers, not just research profiles.

Underneath that simple request, the product cannot pretend there is only one search.

It breaks the role into hypotheses, explores those hypotheses separately, inspects what comes back, learns which paths are noisy, and doubles down where the signal is strong.

One path may reveal that the obvious title is too rare. Another may show that a source-company cluster is full of strong people. Another may show that a promising adjacent background is too far from the hiring manager's intent. Another may rediscover candidates the company already knows.

The important part is not any one retrieval technique. The important part is that the product does not pretend one technique is enough.

Great search is layered.

A profile is only the starting point

The first generation of AI sourcing was built around the candidate profile.

That is understandable. Profiles are easy to display. They fit neatly into cards. They can be embedded, ranked, scored, exported, enriched, and sold.

But a profile on its own is a thin object.

It might say someone was a Head of Product. It may not show whether they owned enterprise customers, regulated workflows, or the actual product surface the role needs.

It might list a fintech company. It may not tell you whether that company was payments, lending, infrastructure, wealth, crypto, or insurance.

It might show a current job title. It may not tell you that the person's real work maps better to a different title family.

It might show that someone was rejected from a previous process. It may not tell you that they were rejected because the role was too junior, the location was wrong, or the hiring manager changed direction.

In recruiting, the profile is only the beginning.

The useful unit is the candidate in context:

• the role interpretation;
• the market lane that found them;
• the evidence supporting the match;
• the caveats or missing facts;
• the prior relationship history, where it exists;
• the recruiter feedback already learned;
• the next action a human can actually take.

That is why "matching" is too small a word for this product.

The output is not:

7.1 out of 10.

It is closer to:

Promising, but verify before sending.

The candidate has relevant product leadership and adjacent payments/risk experience. The useful caveat is that current remit and London workability need confirmation. The next step is to verify those facts or ask whether the adjacent fraud/risk background counts for the payments requirement.

That is a completely different product surface. One gives the recruiter a number. The other gives the recruiter judgement they can inspect.

Scores hide the decision

A single match score is seductive because it makes everything feel simple.

Candidate A: 92%. Candidate B: 89%. Candidate C: 86%.

But recruiter judgement rarely works that way.

A candidate can be strong on domain and weak on seniority. Strong on title and weak on evidence. Strong on company pedigree and weak on actual delivery. Strong for the role but unlikely to move. Weak on the literal job description but exactly right for what the hiring manager actually meant.

The problem with a score is not that it contains no signal. The problem is that it collapses the wrong things.

It hides whether a requirement was directly visible or merely inferred. It hides whether a missing point is fatal, negotiable, or worth asking the hiring manager about. It hides whether a person belongs in the recruiter inbox now, needs a quick verification step, should be saved for a later pass, or should change how the team understands the role.

That distinction matters.

If a messy job description says "must have payments experience", a strong candidate from a fraud, risk, or fintech infrastructure company might be exactly the kind of person a recruiter needs to discuss with the hiring manager.

A blunt threshold can hide that person before the human ever sees the tradeoff.

Great recruiting software does not flatten those moments. It surfaces them.

The agent needs evidence without drowning in it

This is where the product gets hard.

It is easy to build a demo where one language model reads a job description, runs a search, looks at a few profiles, and writes a plausible answer.

The real product is harder because the work is context-dense. Search queries can be large. Search results can contain hundreds of people. Profiles are long, sparse, inconsistent, and sometimes stale. The useful clues are distributed across titles, companies, dates, locations, career transitions, notes, missing fields, and contradictions.

If the recruiter-facing assistant tries to carry all of that detail inside its own conversation, it becomes slower, more expensive, and less reliable. It also gets distracted from its real job: understanding the recruiter, asking good questions, explaining the search, and helping decide what to do next.

The product has to preserve rich evidence without dumping all of it into the conversation.

The agent can inspect a batch of results without pasting every profile into the chat. It can remember what a lane learned without replaying the whole lane. It can keep the full evidence available for later inspection, while the recruiter sees the compact, useful version.

That sounds small, but it changes everything.

This is one of the central differences between a shallow AI feature and a real agentic product.

The shallow version tries to make one answer carry the whole search. The product remembers what the search learned.

Feedback becomes strategy

Most products treat recruiter feedback as a UI feature.

Thumbs up. Thumbs down. Archive. Maybe.

That is useful, but it is not enough.

In the product we are building toward, recruiter feedback changes the search.

If a recruiter says, "This person is good, but too academic," the next search should bias away from research-only profiles and toward people who have shipped in production.

If the recruiter says, "This background is right, but they are too senior," the agent can suggest a new path focused on people one step earlier in their career, or open it when the recruiter has made that intent explicit.

If the recruiter says, "This is close, but I need more customer-facing experience," the next search can look for deployment, implementation, solutions, field engineering, customer delivery, and founder-led delivery signals.

If the recruiter rejects five candidates from the same company type, that company type can become a noisy pattern.

If the recruiter shortlists three people from an unexpected cluster, that cluster can become a new path.

That is the difference between feedback collection and feedback intelligence.

The recruiter does not have to rewrite the search from scratch. They explain judgement in natural language, and the system has enough memory of the search to turn that judgement into a better next move.

The product feels like collaboration

The best version of this product does not hide everything behind automation.

It shows its work.

In that version of the product, a recruiter can see:

• how the agent interpreted the role;
• which markets it explored;
• which lanes produced signal;
• which lanes were noisy;
• which candidates are worth time;
• which evidence is strong;
• which caveats matter;
• how recruiter feedback changed the next search.

That is how trust is built.

Not by claiming the AI has found the perfect candidates. By making the search process visible, steerable, and evidence-backed.

The recruiter can interrupt:

Go deeper on this lane.

Ignore that company type.

Find more like these two.

Search our existing candidate memory before going further outbound.

Widen beyond the exact title if the company stage is right.

The agent responds like a strong search partner:

Understood. I will keep the core requirement, loosen the title constraint, avoid that company pattern, and search for people with the evidence we now know matters.

That is the product experience people are missing.

The search has to remember

The winners in AI sourcing will not just have more profiles. They will have better memory.

Candidate memory: what this person has done, what evidence exists, and what has changed since we last saw them.

Company memory: what kind of company this was, what stage it reached, what talent it tends to produce, and which parts of that context matter for the role.

Relationship memory: whether we have spoken to this person, what happened, why they were rejected, what the notes said, and what might be different now.

Search learning: which lanes worked, which titles were noisy, which source companies produced good candidates, which patterns the recruiter rejected, and which feedback changed the hiring model.

Most tools have some version of candidate memory. Some have company context. Fewer have relationship memory. Very few make what the search learned a first-class product surface.

But that is where the compounding advantage begins. Within a hiring effort, each pass through the market makes the next pass smarter.

Why this is hard to build

The simple demo is easy:

Paste a job description. Return candidates. Show a score.

The real product is harder:

• keep messy and decaying talent data structured enough to search and trust;
• combine keyword precision, semantic understanding, structured filters, and evidence-aware ranking;
• split a role into several search hypotheses;
• inspect results and adapt the next move;
• preserve evidence without overwhelming the recruiter-facing assistant;
• evaluate candidates with enough nuance to expose tradeoffs;
• let recruiter feedback change the search;
• keep the experience fast enough to feel usable;
• make the whole thing inspectable.

That is not a wrapper around a language model. It is the recruiting search layer: memory, evidence, feedback, and action in one system.

Many teams have access to similar models. The difference is in the product layer: how the system plans the search, preserves evidence, learns from feedback, uses the right data at the right time, and makes thousands of small decisions reliable inside real recruiting work.

That work is less glamorous than the chat interface. It is also the actual moat.

The future is not "AI replaces the recruiter"

The best recruiters are not valuable because they can type Boolean faster.

They are valuable because they understand tradeoffs.

They know when a title lies. They know when a company is a useful signal. They know when a rejection reason still matters. They know when the hiring manager is saying one thing and meaning another. They know when a candidate is technically relevant but commercially unrealistic. They know when the market is telling them the brief is wrong.

AI does not erase that judgement. It amplifies it.

The recruiter brings intent, taste, context, and decision-making. The agent brings memory, iteration, market coverage, evidence discipline, and tireless search execution.

That is the partnership.

The future of AI sourcing is not:

Here are the top candidates.

It is:

Here is how I understood the role.

Here are the markets I explored.

Here are the lanes that worked.

Here are the candidates worth your time.

Here is what I learned from your feedback.

Here is where I am going next.

That is what a strong sourcing agent should feel like. Not a database. Not a matcher. A search partner.

What this means for Nova

Nova is not building another sourcing database. We are building a recruiting agent backed by a real search layer: one that coordinates evidence, judgement, memory, and feedback until the right candidates emerge.

The same system has to support both ways recruiters work. Sometimes you want a controlled search and review flow, because precision and inspection matter. Sometimes you want to hand over the problem and let the agent keep searching once it understands enough context.

That search layer also reaches beyond outbound sourcing. It can rediscover people already in the ATS, carry relationship history, coordinate the next action, and remember what each search taught the team.

That is the compounding advantage: not generic AI, but judgement that gets more specific to the role, desk, client, and team with every pass through the market.

The hard part is not generating candidates. The hard part is building a system that recruiters can trust.

Andreas Asprou
Co-founder & CTO, Nova