AI People Search with Jev: Screen Candidates Against Your ICP Before Paying for Email Lookups

AI people search means an agent turns a plain-language brief, such as “marketing leads at Series A software companies in North America”, into a list of named people with titles and companies. The list is never clean: search returns adjacent roles, companies outside your size band, regions you do not sell to, and people whose profile is out of date. If every row goes straight to a work-email finder, you pay for lookups on people you will never contact, and wrong-fit contacts flow into your outreach tool. A cheaper order is filter, then enrich. The agent searches; Jev answers a few short, typed questions about each candidate against your ideal customer profile (ICP); only candidates that pass go to a lead enrichment tool such as Treg for the email lookup and verification. Jev does not browse, search or find emails. It is a text-only judgment layer: it reads the fields you send and returns probabilities, so the paid step only sees rows you already want. This is the “jev people search” pattern written out end to end, and it fits next to lead scoring for inbound leads and agent routing for multi-step agents.

Split the ICP into three questions instead of one long prompt. A Noul question makes the keep-or-drop decision (does this person fit?). A Score with 2 to 10 ordered levels rates how close the person is to the budget owner. A Choice with 2 to 12 options names the main reason a candidate fails, and always includes an unclear option so thin profiles have an honest place to go. The reason is worth the extra question: if most rejects come back as wrong_company_size, fix the search brief instead of paying to reject the same rows every day. Put only the fields the decision needs into state: title, company, size band, industry, region and a one-line profile summary. Leave out emails, phone numbers, notes and anything sensitive, and never ask about age, gender, ethnicity or other protected traits. The state must stay within 8,000 characters, a request can ask 1 to 8 questions, and question IDs start with a lowercase letter and use only lowercase letters, digits and underscores. The block below is a copy-paste ICP example: one candidate as state, the three questions, an illustrative response, and four test candidates with the outcome you should expect. The public Jev Playground at jevmodel.app/jev-playground lets you try the built-in examples without an account (3 runs per UTC day); to run these three questions as written, sign in, open Console → Playground, paste the state and add the questions, or send the same body to the API.

// Copy-paste ICP screen. POST https://jevmodel.app/api/v1/systemone
// Header: Authorization: Bearer <JEVMODEL_API_KEY>  (key from a verified-email account)
{
  "state": {
    "title": "Head of Growth Marketing",
    "company": "Example Analytics Inc.",
    "company_size": "120 employees",
    "industry": "B2B SaaS, product analytics",
    "region": "Toronto, Canada",
    "summary": "Runs paid acquisition and lifecycle email; reports to the CEO."
  },
  "questions": {
    "icp_fit": {
      "type": "noul",
      "instructions": "Does this person match our ICP: someone who owns or directly influences the marketing budget at a B2B software company with 50-500 employees in the US or Canada?",
      "criteria": {
        "true": "Owns or directly influences marketing spend at a B2B software company of 50-500 people in the US or Canada.",
        "false": "Wrong role, company type, size or region, or not enough information to tell."
      }
    },
    "buying_power": {
      "type": "score",
      "instructions": "Rate how close this person is to the marketing budget decision.",
      "criteria": [
        "Individual contributor with no budget",
        "Manages one marketing channel",
        "Leads a marketing function",
        "VP, CMO or founder who signs marketing spend"
      ]
    },
    "reject_reason": {
      "type": "choice",
      "instructions": "What is the main reason this person does or does not fit the ICP above?",
      "criteria": {
        "fit": "Matches role, company type, size and region.",
        "wrong_role": "Not in marketing or has no say over marketing spend.",
        "wrong_company_size": "Company is outside 50-500 employees.",
        "wrong_industry": "Company is not a B2B software business.",
        "wrong_region": "Based outside the US and Canada.",
        "unclear": "The profile does not give enough information to decide."
      }
    }
  }
}

// Illustrative response shape (example values, not measurements):
// { "code": 0, "data": { "answers": {
//   "icp_fit":       { "noul": 0.9 },
//   "buying_power":  { "score": ... },   // check the returned scale on real responses
//   "reject_reason": { "choice": "fit", "probabilities": { "fit": 0.86, ... } } } } }

// Four test candidates (one request each) and the outcome to expect:
// 1. Head of Growth Marketing, 120-person B2B SaaS, Toronto    -> keep (fit)
// 2. Marketing intern, 120-person B2B SaaS, Austin             -> drop (wrong_role)
// 3. CMO, 8,000-person retail bank, New York                   -> drop (wrong_company_size / wrong_industry)
// 4. VP Marketing, 200-person B2B software company, Berlin     -> drop (wrong_region)

Send one request per candidate with the same three questions, then apply thresholds in your own code. The script below reads candidates.json (an array of candidate objects shaped like the state above) and icp-questions.json (the questions object from Step 1), calls the API, keeps rows where icp_fit is at least 0.8 and the reason is fit, and sends unclear or borderline rows to a review file instead of guessing. The 0.8 threshold is a placeholder: pick yours from a labeled sample, as the evaluation guide explains. Each call is an ordinary API request billed in tokens, so the screen costs the same per row whether a person passes or not; verified accounts start with 100,000 free tokens, and failed runs are refunded. The API has no idempotency key, so record which rows already have answers before you retry after a network error. If you prefer not to write code, Console → Batch runs the same questions over a CSV or JSONL list: up to 50 rows per batch before any purchase and up to 1,000 rows after one.

// screen.mjs  (Node 18+: built-in fetch)
// Usage: JEVMODEL_API_KEY=... node screen.mjs
import { readFileSync, writeFileSync } from 'node:fs';

const candidates = JSON.parse(readFileSync('candidates.json', 'utf8'));
const questions = JSON.parse(readFileSync('icp-questions.json', 'utf8'));
const FIT_THRESHOLD = 0.8; // placeholder: set it from a labeled sample

const shortlist = [];
const review = [];

for (const person of candidates) {
  const res = await fetch('https://jevmodel.app/api/v1/systemone', {
    method: 'POST',
    headers: {
      Authorization: 'Bearer ' + process.env.JEVMODEL_API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ state: person, questions }),
  });
  const json = await res.json();
  if (json.code !== 0) {
    review.push({ person, error: json });
    continue;
  }
  const a = json.data.answers;
  const fit = a.icp_fit.noul; // probability that the candidate fits
  const reason = a.reject_reason.choice;
  if (fit >= FIT_THRESHOLD && reason === 'fit') {
    shortlist.push({ ...person, fit, buying_power: a.buying_power.score });
  } else if (reason === 'unclear' || (fit > 0.4 && fit < FIT_THRESHOLD)) {
    review.push({ person, fit, reason });
  }
  // everything else is a confident reject: no paid lookup
}

writeFileSync('shortlist.json', JSON.stringify(shortlist, null, 2));
writeFileSync('review.json', JSON.stringify(review, null, 2));
console.log('shortlist', shortlist.length, 'review', review.length, 'of', candidates.length);

Treg describes its people search as lead enrichment for agents: one token and one CLI in front of many data providers, paid per call. The agent either picks a provider from the catalog or calls a routed endpoint, where Treg picks the provider and names it. You call the hosted service at treg.to; this guide does not cover running Treg yourself. According to Treg’s README, an agent installs the CLI, logs in, searches the catalog for a capability, reads that capability’s schema, and calls it; work-email finding is a routed capability (treg.people.email.find), and verification is a separate, separately billed step. Treg says email finding starts at $0.0005 per call from a LinkedIn profile URL and that misses are not charged, which is why it is often searched as a LinkedIn email finder; check its price list before you budget, because prices vary by route. Treg also says new verified accounts get $1.00 of free credit once, when they create an eligible team. Feed it shortlist.json only. Rows in review.json wait for a person, and confident rejects never reach a paid lookup. Keep Jev’s answers next to each contact so you can later see whether high buying_power scores actually replied. Treg’s repository is published under Apache 2.0 with additional terms; Treg says calling the hosted treg.to API is permitted. JevModel is not affiliated with Treg.

# Treg CLI, as documented in Treg's README (hosted service at treg.to)
curl -fsSL https://treg.to/install.sh | sh
treg login
treg catalog search "find a work email"
treg catalog get treg.people.email.find   # read the input schema before calling
treg balance

# Pass only the rows in shortlist.json produced in Step 2.
# Rows in review.json go to a person; confident rejects are never looked up.
# Verification is a separate, separately billed step in Treg's docs.

People who search for Clay alternatives or an Apollo alternative usually want two things: a lower cost per contact and less time spent on contacts that never fit. The table compares three ways to build a list; it describes trade-offs, not a benchmark. On vendor price alone, the only public numbers here are Treg’s own: in a test Treg published, the same 100 leads (name plus company domain) went through five work-email tools and were checked against each company’s published address. Treg reports 92 correct emails for $0.53, Clay 84 for about $3.35, Apollo 77 for about $2.24, Deepline 80 for $2.74 and Hunter 84 for $2.21, or $0.58 per 100 correct emails for Treg against $3.77 for Clay, which is where its “85% cheaper than Clay” claim comes from. These are a vendor’s figures on its own test; Jev was not part of it, and your list will differ. Filtering first lowers cost with any enrichment vendor, because fewer rows reach the paid step.

Before you trust the screen, label 100 to 200 candidates from your own searches as fit or not fit, run the three questions, and check how many true fits fall below your threshold and how many wrong fits pass. Then track one number end to end: total spend (Jev tokens plus lookups plus verification) divided by contacts that are both in your ICP and have a verified email. Treg publishes a receipt for one run of this kind, dated 2026-09-23: it listed 50 Series-A software companies, let Jev keep the 27 that fit the ICP, named the marketing lead at each, then found and verified work emails, ending with 20 verified emails for $0.58 in total, or $0.029 per usable result, with every miss settled at $0.00. That is Treg’s published run, not a JevModel measurement. On search quality, Treg reports that on LessieAI’s People Search Bench, B2B prospecting tasks were answered correctly 43% of the time by Claude Code alone and 78.2% of the time with Treg. Your own labeled sample is the number that matters.

Use it when an agent builds lists at volume, the ICP can be written down in a few sentences, and the enrichment step costs money per row. Skip it for a handful of named accounts, where reading each profile yourself is faster. Keep the screen narrow: judge role, company, size, industry and region from professional facts, never from protected traits, and do not send personal emails or phone numbers to Jev, because it does not need them. Follow the privacy and outreach rules that apply where your contacts live. Jev is text-only and is not open source; JevModel always calls the Jev model through its own API, so there is no model field to set. The Growth section of jevmodel.app/use-cases has lead-qualification examples, and jevmodel.app/jev-api lists the request limits. JevModel is an independent site and is not affiliated with TypeSafe AI, which develops Jev, or with Treg.