How to Find AI Researchers and ML Engineers at Frontier Labs (2026 Guide)

To find AI researchers at frontier labs, start from their papers and code, because their job titles say almost nothing.

Published

Written by

Chris Pisarski

Reviewed by

Manmohit Grewal

Read time

16

minutes

From one 2025 OpenAI paper: 23 named authors, 21 resolved to one person each, 16 still at OpenAI, 12 with the title Member of Technical Staff.

Short answer: To find AI researchers at frontier labs, start from their papers and code, because their job titles say almost nothing. Pull author lists from recent lab papers and contributor lists from lab repositories, resolve each name to one person with a current employer, and accept a match only when two signals agree. Then group people by team and watch for moves.

Our team tested the approach on a public 2025 OpenAI paper with 23 named authors and resolved 21 to one person each. Of the 16 still at OpenAI, 12 hold the same title: "Member of Technical Staff."

Most guides on how to find AI researchers cover the academic pipeline of PhD students and professors. This one covers people already working at labs such as OpenAI and Google DeepMind, and covers outreach only as far as the legal basics.

The process in five steps

  1. Start from the work: Pull paper author lists from arXiv and repo contributors and org members from GitHub.

  2. Resolve each name: Search people by the paper's title, then by name plus the lab's domain for anyone missed.

  3. Verify: Keep a match only when two independent signals agree, such as employer plus paper.

  4. Map teams: Read headlines, role descriptions and recent paper titles. Ignore the job title.

  5. Watch for moves: Watch your shortlist for job changes and the whole lab for people who leave.

Before anyone is contacted, a recruiter or researcher who knows the field approves every name.

What our test found

Test

Result

Authors of one 2025 OpenAI paper resolved to one person

21 of 23

Authors still at OpenAI titled "Member of Technical Staff"

12 of 16

OpenAI GitHub org members linked to a person at 0.99 confidence or higher

8 of 10

People who left OpenAI, from a free discovery-watch preview

56

Biggest risk

Same-name people and wrong code-account links

What you'll need

  • Claude Code (our team's route), or an Anthropic API key to build it into a product

  • A Crustdata account with research profiles and Person Identify turned on (both are enabled per account on request), plus an enterprise plan for developer-platform data

  • One paper, repository or GitHub org from the lab you care about

  • A few people you already know work there, to check your matches

Why are AI researchers at frontier labs hard to find?

They're already employed, their profiles say little about their work, and most teams we spoke with want the same small pool. A talent intelligence lead at a large tech company told us top researchers often have thin or stale profiles, and piecing them together from code collaborators, co-authors and patents is "extremely manual today." Even a recruiter with 12 years of hiring ML engineers asked r/recruiting where to start after moving to a research pipeline.

Why doesn't a researcher's job title tell you what they work on?

Because at OpenAI most technical staff share one title. In our test, 12 of the 16 paper authors still there were "Member of Technical Staff," as were all 8 people we linked from OpenAI's GitHub org. That title covered people working on Codex, GPU compilers, privacy research and robotics.

Why are their profiles thin or out of date?

People change jobs before they update their profiles, and the headline, role and research-profile email domain change at different times, so they can disagree. Check every match against recent papers and code, because current employer and latest work matter most. The same talent intelligence lead said of hand-built maps: "It seems like, as soon as we finish them, they're like, already out of date."

Can't I just ask Claude for a list of researchers at OpenAI?

No, because Claude answers from training data unless it's connected to a live source. That data stops at a cutoff date, listed for each model on Anthropic's models overview, and researchers keep changing jobs after it. Use Claude to read papers, compare evidence and write the shortlist, and pull current employers from a database you query at search time.

How does finding researchers with Claude and a people database work?

Claude compares evidence, a people database answers who each name is and where they work now, and your code keeps the record:

Part

Who does it

What it produces

Author lists, contributors, org members

Free public APIs (arXiv, GitHub)

Names and code accounts

Matching names to people

A people database (Crustdata)

One record per person, with a confidence score

Comparing evidence and grouping

Claude

A team guess and the reason for it

Keeping the list

Your code

Evidence, matches already checked, people to skip

Final check

A recruiter or researcher

Approved names only

How do recruiting teams already run this with Claude?

Mostly in one of two ways:

  • Wide pull, then a model as judge: A recruiting lead at an AI chip startup described keyword filters, then a semantic search layer, then a final LLM that scores each person against the brief and gives a reason.

  • Work first, then the person: A founder hiring a founding ML scientist used Claude and Claude Cowork to gather independent research before querying people data. They took about 25,000 authors from public paper databases, scored them by author position and topic down to about 500, traced each one through paper, author page, homepage and code account to an employer and date, ran a person search, rescored, and enriched only the top 50.

This guide follows the second pattern, which holds up when profiles are thin.

Step 1: Should I start from papers, code, talks or personal sites?

Start with the source that shows the most specific work: a first author on a recent paper or a top committer on a lab repo.

Source

What it tells you

Signal strength

Free way to get it

Paper author list

Who worked on a named result, and roughly when

Strong for named authors, weak for huge model cards

arXiv API

Author order

Who led and who advised, by convention

Medium, since labs vary

The paper itself

Repository contributors

Who commits code, ranked by commits

Strong for top committers, weak for one-off fixes

GitHub REST API

GitHub org members

Who chose to show they belong to the lab

Medium, since membership can be hidden

GitHub REST API

Google Scholar profile

Papers, interests, co-authors, a verified email domain

Medium, as the email domain can outlive the job

Check by hand

Conference workshops and OpenReview

Organizers and accepted authors in a niche

Medium

Workshop and venue pages

Talks and personal sites

Current topics and links to code accounts

Medium, but personal sites go stale

Web search

A head of AI research recruiting at a search firm gave us a concrete bar for depth: a core PyTorch maintainer "in the top 20 committers in the last 12 months."

How do I get the author list of a lab paper?

Call the arXiv API with the paper's ID. It's free and returns every author in order (arXiv API manual).

import re, urllib.request

paper_id = "2502.06807"  # Competitive Programming with Large Reasoning Models (OpenAI, 2025)

feed = urllib.request.urlopen(f"https://export.arxiv.org/api/query?id_list={paper_id}").read().decode()

authors = [a.strip() for a in re.findall(r"<name>(.*?)</name>", feed)]

authors = [a for a in authors if a not in ("OpenAI", ":", "o3 contributors")]

print(len(authors), authors[:5])  # 23 named authors in our run
import re, urllib.request

paper_id = "2502.06807"  # Competitive Programming with Large Reasoning Models (OpenAI, 2025)

feed = urllib.request.urlopen(f"https://export.arxiv.org/api/query?id_list={paper_id}").read().decode()

authors = [a.strip() for a in re.findall(r"<name>(.*?)</name>", feed)]

authors = [a for a in authors if a not in ("OpenAI", ":", "o3 contributors")]

print(len(authors), authors[:5])  # 23 named authors in our run
import re, urllib.request

paper_id = "2502.06807"  # Competitive Programming with Large Reasoning Models (OpenAI, 2025)

feed = urllib.request.urlopen(f"https://export.arxiv.org/api/query?id_list={paper_id}").read().decode()

authors = [a.strip() for a in re.findall(r"<name>(.*?)</name>", feed)]

authors = [a for a in authors if a not in ("OpenAI", ":", "o3 contributors")]

print(len(authors), authors[:5])  # 23 named authors in our run

Some lab papers credit a group as well as people. This one lists "OpenAI" and "o3 contributors" alongside 23 named authors, so the code drops those labels.

How do I find a lab's ML engineers from its code?

GitHub's API lists an org's public members and returns a repo's contributors sorted by commit count.

  • GET /orgs/openai/public_members returned 33 members. Only people who chose to show membership appear, so many staff won't.

  • GET /repos/google-deepmind/gemma/contributors returned a top 6 with 9, 9, 8, 8, 7 and 6 commits. One of them was a doctoral student at a university, so expect outsiders.

Does public code show everyone at a lab?

No, much lab work lives in private or company-owned repos. In a June 2026 r/recruiting thread on GitHub as a sourcing signal, several commenters make that point, one calls GitHub a bad signal outright, and others use it to prioritize and personalize rather than filter. Treat public code as one input alongside papers and research profiles.

How do I rank contributors by depth?

Rank by commits from GitHub's API (the Crustdata developer-platform fields we read carry no per-repo commit counts), then read author order on papers as a hint, since labs order authors differently. Weigh lab-wide model cards last: their author lists are too long to say much about anyone.

A commenter in the same thread who runs an ML and AI search team looks past commit counts to:

  • The ratio of original repos to forks

  • 3 or more repos with 50 or more stars from people outside the person's own network

  • Filing issues and reviewing pull requests on established projects

What about talks, podcasts and personal sites?

They can show current work, but check each date. Search the name with the lab and a topic, look for a current project and a code-account link, and save the URL as evidence.

Step 2: How do I resolve each name to one person?

Search by the paper's title first, then by name plus the lab for anyone missed. That resolved 21 of 23 named authors in our test.

Method

Authors found

Results returned

Notes

Search by paper title

15 of 23

18

Also returned 2 likely contributors and 1 same-name person

Name plus "worked at openai.com"

6 more

6

Each search returned exactly one person

Not found

2

0

No match, even on name alone

Can I search people by the title of a paper they wrote?

Yes, Crustdata's Person Search can filter on research_profiles.articles.title, the article titles on a person's research profile. Research profiles are enabled per account, and without the grant the API returns a 403 (Person Search reference).

Our team ran the Step 2 calls through the MCP server. The same request as REST:

curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "field": "research_profiles.articles.title",
      "type": "[.]",
      "value": "Competitive Programming with Large Reasoning Models"
    },
    "fields": [
      "crustdata_person_id",
      "basic_profile.name",
      "basic_profile.headline",
      "experience.employment_details.current",
      "research_profiles.verified_email_domain"
    ],
    "limit": 40
  }'
curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "field": "research_profiles.articles.title",
      "type": "[.]",
      "value": "Competitive Programming with Large Reasoning Models"
    },
    "fields": [
      "crustdata_person_id",
      "basic_profile.name",
      "basic_profile.headline",
      "experience.employment_details.current",
      "research_profiles.verified_email_domain"
    ],
    "limit": 40
  }'
curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "field": "research_profiles.articles.title",
      "type": "[.]",
      "value": "Competitive Programming with Large Reasoning Models"
    },
    "fields": [
      "crustdata_person_id",
      "basic_profile.name",
      "basic_profile.headline",
      "experience.employment_details.current",
      "research_profiles.verified_email_domain"
    ],
    "limit": 40
  }'

The search returned 18 people:

  • 15 were named authors, one under a longer form of their name.

  • 2 work at OpenAI but aren't named. They list the paper on their research profile and are likely in the "o3 contributors" group.

  • 1 was a different person with an author's name, a quantum-computing engineer whose research profile also lists the paper.

What does the paper-title search cost?

About 0.93 credits per result at list price: 0.03 base, 0.4 to filter on research profiles, 0.4 to return the verified email domain and 0.1 to return the current employer. Search bills each premium field group once to filter on it and again to return it, and empty results are free (pricing). Full rates are in the cost table below.

What if the paper search misses some authors?

Search each missing name with the lab anywhere in their work history. For the 8 authors the title search missed, this found 6 more, one match each. Name alone isn't enough: three of those names matched 674, 40 and 19 people until we added the lab.

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "basic_profile.name", "type": "=", "value": "AUTHOR NAME" },
      { "field": "experience.employment_details.company_website_domain", "type": "=", "value": "openai.com" }
    ]
  },
  "fields": ["crustdata_person_id", "basic_profile.name", "experience.employment_details.current", "social_handles.professional_network_identifier.profile_url"],
  "limit": 2
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "basic_profile.name", "type": "=", "value": "AUTHOR NAME" },
      { "field": "experience.employment_details.company_website_domain", "type": "=", "value": "openai.com" }
    ]
  },
  "fields": ["crustdata_person_id", "basic_profile.name", "experience.employment_details.current", "social_handles.professional_network_identifier.profile_url"],
  "limit": 2
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "basic_profile.name", "type": "=", "value": "AUTHOR NAME" },
      { "field": "experience.employment_details.company_website_domain", "type": "=", "value": "openai.com" }
    ]
  },
  "fields": ["crustdata_person_id", "basic_profile.name", "experience.employment_details.current", "social_handles.professional_network_identifier.profile_url"],
  "limit": 2
}

Matching on any role in their history also surfaces people who have moved on: 4 of the 21 people we resolved no longer work at OpenAI.

How do I match a GitHub account to a person?

Send the account URL to Crustdata's developer-platform enrich call and read the confidence score. It costs 1 credit per result and is available on enterprise plans (pricing).

curl --request POST \
  --url https://api.crustdata.com/dev_platform/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{ "profile_url": "https://github.com/HANDLE" }'
curl --request POST \
  --url https://api.crustdata.com/dev_platform/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{ "profile_url": "https://github.com/HANDLE" }'
curl --request POST \
  --url https://api.crustdata.com/dev_platform/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{ "profile_url": "https://github.com/HANDLE" }'

Of 10 OpenAI org members, 8 linked to a person at 0.99 confidence or higher. The other 2 were a lab work account with no public repos and a personal account with 201 repos and no linked person, so look for a person's personal account too.

How do I go from a Google Scholar profile to the person?

Pass the Scholar profile URL to Crustdata's Person Identify endpoint. It returns the matching person for 1 credit per match (unmatched URLs are free) and is enabled per account (Person Identify).

{ "research_profile_urls": ["https://scholar.google.com/citations?user=SCHOLAR_ID"] }
{ "research_profile_urls": ["https://scholar.google.com/citations?user=SCHOLAR_ID"] }
{ "research_profile_urls": ["https://scholar.google.com/citations?user=SCHOLAR_ID"] }

One author's Scholar URL returned the same person we'd resolved from the paper, at confidence 1.0.

How do I know two records are the same person?

Accept a match only when two independent signals agree, such as employer plus paper. A high confidence score counts as one signal at most. That rule caught two wrong matches in our test:

  • A same-name person from the title search. Their employer and field didn't fit the paper, so we dropped them.

  • A code-account link at 0.9999997 confidence. A Google DeepMind contributor's account says "Google," but the linked person works at an unrelated infrastructure company. Comparing the account's company field with the profile's employer caught it.

Loose matching needs the same care: (.) can match close misspellings on some fields, so search names with = (Person Search reference).

Open author databases face the same problem. OpenAlex builds author profiles by disambiguating the name strings on papers into people, and its docs note profiles can be overmerged (OpenAlex authors). In an r/PhD thread about a co-author map built on OpenAlex, a commenter found two same-name researchers merged into one profile, which the map's maker traced to two different ORCID iDs. Check the ORCID iD when a paper lists one. As the founder hiring an ML scientist told us: "Many of the names are common names."

Step 3: How do I tell who works on which team?

Read the role description, headline, research interests and recent paper titles. As the talent intelligence lead put it: "And finding who works on a specific product is way harder than who works there."

Which profile fields name the team?

The headline or role description named the team for half of the 14 OpenAI technical staff we pulled (all with a research profile verified at openai.com).

Field

How many of 14 it helped

What it showed

Headline or role description

7

Codex post-training, privacy research, model measurement, RL scaling, alignment research, robotics, reasoning and coding

Research interests on the research profile

13 listed some

Topic labels, from "Machine Learning" to "GPU Compilers"

Papers from 2024 or later

13 had at least one

Placed 7 of 14 in a group once system cards were set aside

Lab-wide system or model cards

9 listed one

Shows the lab and little else

How do I group researchers by team with Claude?

Give Claude each person's recent paper titles, headline and role description, and ask for a team guess with evidence. Reading the 14 people's 2024 to 2026 papers with system cards set aside, Claude placed 7:

Group

People placed

Reasoning and coding

2

GPU compilers and systems

2

Privacy

1

Red teaming

1

Instruction-following safety

1

Of the other 7, 3 had recent papers only from a previous employer, and 4 couldn't be placed: they had only system cards, no papers, or a research profile whose papers clearly belong to several different people. Co-author lists didn't help either. No pair of the 14 listed the other as a co-author on their research profile, not even two who wrote the same 2025 paper.

These groups come from one Claude session and are inferred, so treat each label as a guess to check. A starting prompt:

For each person in people.json, read headline, role description, research interests and paper titles from 2024 onward.
Ignore system cards and model cards.
Return JSON: [{"id": ..., "team_guess": "...", "evidence": ["..."]

For each person in people.json, read headline, role description, research interests and paper titles from 2024 onward.
Ignore system cards and model cards.
Return JSON: [{"id": ..., "team_guess": "...", "evidence": ["..."]

For each person in people.json, read headline, role description, research interests and paper titles from 2024 onward.
Ignore system cards and model cards.
Return JSON: [{"id": ..., "team_guess": "...", "evidence": ["..."]

Can a co-author map show who knows whom?

Sometimes, for researchers with long publication records. The free Mapademic map covers about 8.4 million OpenAlex authors with 15 or more works and finds the shortest co-author chain between two of them. Its page notes affiliations may not be current, so use it for intro paths, not employers.

Who should check the list before anyone is contacted?

A recruiter or researcher who knows the field should approve every name. In the words of the head of AI research recruiting: "The last mile has to be, you know, human review." Give the reviewer one row per person:

Column

What goes in it

Match evidence

The two signals that agree, with links

Team guess

The guess, its evidence and its confidence

Open question

Anything that disagrees, such as a headline that contradicts the role

Drop the record when the two signals don't agree, or when the only evidence is a lab-wide card.

Step 4: How do I know when a researcher leaves a lab?

Run two watches: one on your shortlist for job changes, and one on the whole lab for leavers, which catches people you never listed.

Investors want this too. A partner at a fund that backs AI PhDs told us: "I want to see every time this person publishes a paper or I want to see every time they release a new GitHub repo."

How do I watch a shortlist for job changes?

Create a Person Entity Watcher on your approved list and track experience.employment_details.current with the added type. The first run is a free baseline, and each changed person costs 5 credits at the default 30-day freshness (Person Entity Watcher).

{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "max_results_per_run": 100 },
  "notifications": [{ "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" }]
}
{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "max_results_per_run": 100 },
  "notifications": [{ "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" }]
}
{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "max_results_per_run": 100 },
  "notifications": [{ "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" }]
}

The watch takes profile URLs, so add social_handles.professional_network_identifier.profile_url (already in the Step 2 name check) to the paper-title search too.

How do I catch people who leave a lab?

Use a Person Discovery Watcher, which delivers people who newly match a search. We previewed one for free with three filters (Person Discovery Watcher):

  • a research profile with a verified email domain of openai.com (research profiles are enabled per account)

  • OpenAI in their past roles

  • a current employer other than OpenAI

The preview matched 56 people and quoted 0.5 credits per new person delivered, after a free baseline sample of up to 5.

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "research_profiles.verified_email_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.past.company_website_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.current.company_website_domain", "type": "!=", "value": "openai.com" }
    ]
  },
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": []
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "research_profiles.verified_email_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.past.company_website_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.current.company_website_domain", "type": "!=", "value": "openai.com" }
    ]
  },
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": []
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "research_profiles.verified_email_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.past.company_website_domain", "type": "=", "value": "openai.com" },
      { "field": "experience.employment_details.current.company_website_domain", "type": "!=", "value": "openai.com" }
    ]
  },
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": []
}

An empty notifications list makes it a pull-only watch you read from the run endpoints. For webhook and alert options, see the Crustdata Watcher API.

What do I do when a researcher's profile is thin or out of date?

Trust the work over the profile, and keep the evidence that ties the person to the lab. Rank the signals by strength:

Signal

Strength

Why

Named author on a recent lab paper

Strong

Ties a person to a result and a date

Top committer or maintainer on a lab repo

Strong

Commit counts show sustained work

Research profile with the lab as verified email domain

Medium

The domain can outlive the job, so check the date of their latest paper

GitHub org membership

Medium

It's opt-in and often hidden

Repost of a launch announcement

Weak

Could be an employee, a fan or a partner

A talent lead at a venture fund described the people they're after as frontier-lab engineers who may not have a professional profile at all, but who "write papers or who knows what."

For non-research candidates, our guide on identifying great candidates from minimal data covers the wider method.

How do I connect it to Claude?

Three routes reach the same Crustdata data: Claude Code with the MCP server (our test route), the Claude API with tool use for a product build, and Claude Cowork for recruiters who don't code. Keep confidential target lists on your own machine or store, and send Crustdata only the names, URLs or filters each call needs.

Option A: Claude Code with the Crustdata MCP server

Add the server, then run /mcp in Claude Code and sign in (MCP server docs):

claude mcp add --transport
claude mcp add --transport
claude mcp add --transport

Then save the workflow as a skill at .claude/skills/find-ai-researchers/SKILL.md:




Option B: The Claude API with tool use

Expose each Crustdata call as a tool and let Claude decide when to call it:

import anthropic, requests

client = anthropic.Anthropic()

HEADERS = {"authorization": "Bearer YOUR_API_KEY", "x-api-version": "2025-11-01"}

tools = [{
    "name": "search_people",
    "description": "Search the people database with Crustdata Person Search filters.",
    "input_schema": {"type": "object",
                     "properties": {"filters": {"type": "object"}, "fields": {"type": "array"}, "limit": {"type": "integer"}},
                     "required": ["filters"]},
}]

def run_tool(args):
    body = {"filters": args["filters"], "limit": args.get("limit", 20)}
    if args.get("fields"):
        body["fields"] = args["fields"]
    return requests.post("https://api.crustdata.com/person/search", headers=HEADERS, json=body).text

messages = [{"role": "user", "content": "Resolve the authors in authors.json to people at openai.com."}]

while True:
    response = client.messages.create(model="claude-opus-5-5", max_tokens=8000, tools=tools, messages=messages)
    messages.append({"role": "assistant", "content": response.content})
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": b.id, "content": run_tool(b.input)}
        for b in response.content if b.type == "tool_use"]})
import anthropic, requests

client = anthropic.Anthropic()

HEADERS = {"authorization": "Bearer YOUR_API_KEY", "x-api-version": "2025-11-01"}

tools = [{
    "name": "search_people",
    "description": "Search the people database with Crustdata Person Search filters.",
    "input_schema": {"type": "object",
                     "properties": {"filters": {"type": "object"}, "fields": {"type": "array"}, "limit": {"type": "integer"}},
                     "required": ["filters"]},
}]

def run_tool(args):
    body = {"filters": args["filters"], "limit": args.get("limit", 20)}
    if args.get("fields"):
        body["fields"] = args["fields"]
    return requests.post("https://api.crustdata.com/person/search", headers=HEADERS, json=body).text

messages = [{"role": "user", "content": "Resolve the authors in authors.json to people at openai.com."}]

while True:
    response = client.messages.create(model="claude-opus-5-5", max_tokens=8000, tools=tools, messages=messages)
    messages.append({"role": "assistant", "content": response.content})
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": b.id, "content": run_tool(b.input)}
        for b in response.content if b.type == "tool_use"]})
import anthropic, requests

client = anthropic.Anthropic()

HEADERS = {"authorization": "Bearer YOUR_API_KEY", "x-api-version": "2025-11-01"}

tools = [{
    "name": "search_people",
    "description": "Search the people database with Crustdata Person Search filters.",
    "input_schema": {"type": "object",
                     "properties": {"filters": {"type": "object"}, "fields": {"type": "array"}, "limit": {"type": "integer"}},
                     "required": ["filters"]},
}]

def run_tool(args):
    body = {"filters": args["filters"], "limit": args.get("limit", 20)}
    if args.get("fields"):
        body["fields"] = args["fields"]
    return requests.post("https://api.crustdata.com/person/search", headers=HEADERS, json=body).text

messages = [{"role": "user", "content": "Resolve the authors in authors.json to people at openai.com."}]

while True:
    response = client.messages.create(model="claude-opus-5-5", max_tokens=8000, tools=tools, messages=messages)
    messages.append({"role": "assistant", "content": response.content})
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": b.id, "content": run_tool(b.input)}
        for b in response.content if b.type == "tool_use"]})

Option C: Claude Cowork

The MCP server docs show how to add Crustdata to Claude as a custom connector at https://install.crustdata.com/mcp. If your Cowork setup accepts it, keep each lab's sources in its own project.

How much does it cost to run?

Each Crustdata call is billed per result or per match at the list rates below. Credits cost $0.30 to $0.01 per credit, lower depending on plan.

Call

List price (credits)

In our test

arXiv and GitHub APIs

Free

Author lists, org members, contributors

Person Search, base

0.03 per result, plus 0.1 to filter on work history and 0.1 to return it

Name checks: 6 results

Research profiles in Person Search

0.4 per result to filter on, 0.4 to return

Paper title: 18 results

Developer-platform enrich

1 per result, enterprise plans

16 accounts

Person Identify

1 per match, enabled per account

1 match

Discovery watch

0.5 per new person, free baseline

Preview only, free

Entity watch

5 per changed person at 30-day freshness

—

Prices are list prices from Crustdata pricing. Your account's own prices come from the free GET /account/endpoints call, and each response's X-Credits-Used header shows what it cost.

How can I cut the bill?

  • Return only the fields you'll read. Research-profile fields list at 0.4 credits to filter on and 0.4 to return.

  • Search name plus lab first for authors you already know, and save the paper-title search for long author lists.

  • Resolve GitHub accounts only for top committers.

  • Keep a list of people already checked, so you never pay to resolve the same person twice.

Is it legal to source researchers this way?

Where GDPR applies, it can be, if you have a lawful basis and tell people you hold their data. Under Article 14, when you collect personal data without asking the person, you must tell them within a reasonable period and at the latest within one month, or at your first message if you contact them sooner (GDPR Art. 14). The lawful basis to assess for sourcing is legitimate interests under Article 6(1)(f): the processing must be necessary for your interest, and it fails where the person's interests or rights override it (GDPR Art. 6).

Use public, work-related information, keep a human approving every name, and keep the evidence for each match. This is a summary, not legal advice.

Where do I start this week?

Pick one lab and one recent paper, and work through the loop by hand in Claude Code:

  1. Pull the author list from arXiv and the top contributors from one lab repo.

  2. Search by paper title, then by name plus the lab for the rest.

  3. Check every match against a second signal, and drop the ones that don't agree.

  4. Set a discovery watch for people who leave the lab.

When you reach out, mention the paper or repo that put the person on your list. Once the loop works on one paper, save it as a skill and run it on the next. Start with a free sandbox key or book a demo at crustdata.com.

FAQ

Where do AI researchers publish, and which sources are worth searching?

On arXiv, including the 2025 OpenAI paper in this guide, and on conference and OpenReview pages. For lab staff, recent named papers and repo commits beat profiles and model cards as evidence.

How do I find researchers at OpenAI or Google DeepMind who don't publish?

Start from the lab's code. GitHub's API lists org members and ranks repo contributors by commits, and a developer-platform match turns each account into a person. Confirm each match with a second signal.

How do I find ML engineers who aren't on job boards?

Look at who commits to the libraries and repos your team relies on. Commit history shows engineering work whether or not someone is looking for a job.

How do I know when a frontier-lab researcher changes jobs?

A Person Entity Watcher alerts you when someone on your list adds a new current role. A Person Discovery Watcher delivers people who newly match a "left the lab" filter, at 0.5 credits per new person (pricing).

What's the difference between an AI researcher and an ML engineer for sourcing?

Look for researchers in paper author lists and ML engineers in repository contributor lists. At OpenAI both can hold the title "Member of Technical Staff," so the work tells you which is which.

Crustdata is now live in Claude!

Find the best leads, candidates and companies with only a prompt.

Sign In