OpenAI Decisions API vs JEV for Lead Scoring? (2026)

OpenAI and Typesafe now both sell decision models: you ask a closed question, and you get a fixed answer with a probability.

Lead scoring is the obvious job for them, but most comparisons stop at the price list and a few demo prompts. Nobody had tested them on real leads, so we did.

We sent 998 Sales Navigator leads to both models, three times each, and compared every answer with the fit level our ICP gives.

The right choice depends on how you use the score: to sort a list, to filter on a label, or to trigger an action.

We built the benchmark and an n8n version with real API calls, and you can run both on your own leads in a few minutes.

We will walk you through the test, the results and the setup.

Everything is in one public GitHub repo: the benchmark, the labels, the report and the n8n workflow. Paste the prompt into your AI agent, or pick the n8n tab to run it without code.

Agent kit Free · Public

GitHub n8n

Let your AI agent set it up

Paste this prompt into Claude Code, Codex or Cursor. Your agent clones the public repo, follows its instructions and asks before every change.

Prompt · GitHub Copy

Compare the OpenAI Decisions API and Typesafe JEV on my own leads.
Clone https://github.com/evaboot-labs/openai-decisions-vs-jev, read AGENTS.md and follow the compare-models skill. Ask me for my ideal customer profile and my lead list (an Evaboot export works), help me label a sample, and run a quick check before the full benchmark.

In the repo

• A benchmark script that sends each lead to both models three times and writes a full report
• ICP.md, the labelling rules and our 998 labels with their reasons
• AGENTS.md and a Claude skill, so your agent runs the test for you
• The n8n workflow, with a step-by-step setup guide

Open the repo on GitHub

Set it up in n8n

Paste this prompt into your AI agent and it walks you through the import, one step at a time. Or open the workflow JSON on GitHub and import it yourself.

Prompt · n8n Copy

Set up the OpenAI vs JEV lead scoring workflow in my n8n.
Clone https://github.com/evaboot-labs/openai-decisions-vs-jev and follow docs/n8n.md. Walk me through importing n8n/openai-vs-jev-lead-scoring.json, adding the Google Sheets, OpenAI and JEV credentials, and filling in my sheet URL and ICP, one step at a time.

In the repo

• The workflow JSON: your Google Sheet in, both scores out
• docs/n8n.md: credentials, settings and the first run, step by step
• The same ICP.md as the benchmark

Open the n8n JSON on GitHub Open the repo on GitHub

We used our own ICP and Evaboot exports, but the same test works for any profile and any lead list.

What Are the OpenAI Decisions API and JEV?

A decision model answers a fixed question about a text. It returns one of the answers you defined, a probability for each, and a confidence value, never a paragraph.

That makes it a better fit than a chat model for yes/no, choice and score tasks.

The answer is always valid, and you can sort, filter and set thresholds on it.

1. OpenAI Decisions API

The Decisions API is OpenAI's endpoint for closed questions, at POST /v1/decisions with the model gpt-6-luna. It supports three question types: predicate (yes/no), choice and score.

It is in public beta as of October 2026. OpenAI charges $0.10 per million input tokens and nothing for output.

Create your key on the API keys page of the OpenAI platform.

2. Typesafe JEV

JEV is the first "System One" model from Typesafe, specifically designed and built for tasks like lead scoring.

It runs at POST /v1/systemone with the model jev-latest. Its question types are choice, score and noul, a probability that a condition is true.

It is in early access: you need a key from the Typesafe console. Typesafe lists $42 per billion input tokens, which is $0.042 per million.

OpenAI Decisions API vs JEV at a Glance

Here is what each API offers, from the vendors' docs and from our own 5,988 calls.

The two are closer than the marketing suggests. Both return a score on your scale, a probability per level and a confidence value, in about a quarter of a second.

How to Call Each API for Lead Scoring

The request has the same three parts in both APIs: the text to judge, the question, and the levels. Only the field names change.

1. Write the Input: Your ICP Plus the Lead

The model reads your ideal customer profile and one lead in a single text.

We put the ICP first, then the lead's fields from the Evaboot export.

# Ideal customer profile

## Company must-haves

- Industry: B2B software (SaaS), IT services, or recruiting agencies.
- Size: 11 to 500 employees.
- Location: Europe or North America.
- Sells to other businesses, with an outbound sales team.

## Buyer must-haves

- Function: Sales, Business Development, Growth, or Revenue Operations.
- Seniority: Head of, Director, VP, C-level, or Founder.

## Positive signals (raise the fit, not required)

- Job title mentions outbound, prospecting, lead generation, or SDR team.
- Company is hiring SDRs or BDRs.
- Lead uses LinkedIn Sales Navigator.

## Disqualifiers (always No fit)

- Students, interns, job seekers, or freelancers with no team.
- Competitors: lead-data or email-finder vendors.
- Company with more than 5,000 employees.
- Government, education, or non-profit organizations.

Write each criterion so a stranger could answer yes or no from a LinkedIn profile.

"Good culture fit" cannot be scored; "11 to 500 employees" can.

2. Ask OpenAI for a Score

OpenAI takes the text as input and a list of questions, each with a name and its levels. A level has a label and a description.

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "Ideal customer profile:\n<ICP.md>\n\nLead:\nJob title: ...\nCompany: ...",
    "questions": [{
      "type": "score",
      "name": "icp_fit",
      "instructions": "How well does this lead match the ideal customer profile?",
      "levels": [
        {"label": "No fit", "description": "Fails a disqualifier, or matches none of the must-haves."},
        {"label": "Weak fit", "description": "Matches one must-have. The other must-haves fail or are unknown."},
        {"label": "Partial fit", "description": "Matches most must-haves, but one fails or is unknown."},
        {"label": "Strong fit", "description": "Matches every must-have and no disqualifier."}
      ]
    }]
  }'

3. Ask JEV for a Score

JEV calls the text state, and the questions are an object keyed by a name you choose. The levels are plain strings under criteria.

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $JEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Ideal customer profile:\n<ICP.md>\n\nLead:\nJob title: ...\nCompany: ...",
    "questions": {
      "icp_fit": {
        "type": "score",
        "instructions": "How well does this lead match the ideal customer profile?",
        "criteria": [
          "No fit: Fails a disqualifier, or matches none of the must-haves.",
          "Weak fit: Matches one must-have. The other must-haves fail or are unknown.",
          "Partial fit: Matches most must-haves, but one fails or is unknown.",
          "Strong fit: Matches every must-have and no disqualifier."
        ]
      }
    }
  }'

4. Read the Answer

Both return a score between 0 and 3, a probability per level and a confidence value.

Here are the real answers for one lead.

// OpenAI: answers is an array
"answers": [{
  "name": "icp_fit", "score": 1.44, "confidence": 0.44,
  "probabilities": [
    {"value": 0, "label": "No fit", "probability": 0.18},
    {"value": 1, "label": "Weak fit", "probability": 0.2},
    {"value": 2, "label": "Partial fit", "probability": 0.62},
    {"value": 3, "label": "Strong fit", "probability": 0.0}
  ]
}]

// JEV: answers is an object, probabilities are keyed by level
"answers": {
  "icp_fit": {
    "score": 1.23, "confidence": 0.42,
    "probabilities": {"0": 0.18, "1": 0.42, "2": 0.4, "3": 0.0}
  }
}

The score is a weighted average, so 1.44 means "between Weak and Partial, closer to Weak". Round it to get a level, or keep it to sort your leads.

How We Tested Them on 998 Leads

A fair test needs the same input, the same question and a correct answer for every lead. Here is how we set it up.

1. Build a Mixed Lead List

We exported 998 leads from Sales Navigator with Evaboot, from 12 searches. Two cover our ICP in Europe and North America; the others each break one rule on purpose.

Those searches target large companies, other industries, other functions, junior sales roles, other regions and the public sector.

The test needs every fit level, so the models can be wrong in both directions.

2. Label Every Lead With the ICP Rules

We wrote the ICP as six checks: industry, size, location, outbound team, function and seniority. Six passes is Strong fit, five is Partial, one to four is Weak, and a disqualifier is No fit.

The rules gave 164 No fit, 254 Weak, 273 Partial and 307 Strong leads.

We audited the labels by segment and fixed the rules wherever they misread a lead.

3. Send the Same Request to Both Models

Both models got the exact same text and the same four levels. Only the request format differed, as shown above.

Neither model saw the labels. They only read the ICP and the lead.

4. Repeat Each Lead Three Times

We scored every lead three times with each model: 5,988 calls, 0 errors.

The script runs six requests at a time and writes one row per call.

git clone https://github.com/evaboot-labs/openai-decisions-vs-jev
cd openai-decisions-vs-jev
cp .env.example .env   # add OPENAI_API_KEY and JEV_API_KEY
python3 benchmark.py --limit 10 --runs 1   # quick check
python3 benchmark.py                       # full run, 3 runs per model

A quick check on 10 leads takes a few seconds:

The full run writes one row per call to results.csv, and the full report to report.md.

The Results: Accuracy, Ranking, Consistency, Speed and Cost

JEV matched our labels more often, OpenAI was more consistent, and both ranked the leads the same way. Here is each result in detail.

1. Accuracy Against Our Labels

JEV gave the same level as our label on 71% of leads, OpenAI on 46%. Within one level, the gap is smaller: 99% against 90%.

Both models were excellent at No fit: 98% for OpenAI, 95% for JEV. The gap is in the middle levels, where most real leads are.

2. Where Each Model Puts Each Lead

The confusion tables show why OpenAI scores lower. It is not random: it is consistently one level stricter than our rules.

OpenAI put 171 of 254 Weak fit leads in No fit, and 168 of 307 Strong fit leads in Partial fit.

Of its 535 mistakes, 501 are below our label.

JEV's mistakes are spread on both sides of the diagonal.

Its most common error was a Strong fit read as Partial fit, 94 times.

The biggest gap is on sales leaders in other industries, who match the role but not the market.

JEV gave the right level to 75% of them, and OpenAI to 12%: it put most of them in No fit.

3. Ranking

If you sort your leads by score, the two models are almost the same.

The rank correlation with our labels is 0.85 for OpenAI and 0.87 for JEV, and 0.94 between the two.

Of the top 100 leads by score, 95 were Strong fit for both models. For a "work the best leads first" list, either model does the job.

4. Consistency Between Runs

OpenAI gave exactly the same score every time, for all 998 leads. JEV moved 95 leads, 10%, by one level between runs.

JEV's changes are small, 0.03 points on average on a 0 to 3 scale. They only matter for leads that sit right on the line between two levels.

5. Speed

Both are fast enough to score a lead while it is being exported. The median call took 0.27 seconds on OpenAI and 0.26 seconds on JEV.

The slowest 5% of calls took over 0.33 seconds on OpenAI and 0.31 seconds on JEV. Neither returned a single error in 5,988 calls.

6. Cost

JEV is about 45% cheaper per lead, even though it counted more tokens for the same text: 819 against 598.

At these prices, cost is not the deciding factor. A Sales Navigator export of 1,000 leads costs far more than scoring it with either model.

How to Compare Them on Your Own Leads in n8n

Our numbers come from one ICP. Your profile will give different results, and the n8n template lets you check in a few minutes without writing code.

1. Put Your Leads in a Google Sheet

The sheet needs one row per lead with these columns: LinkedIn URL, Job title, Company, Company industry, Company employees, Company location and Company description.

An Evaboot export has all of them. Export your Sales Navigator search, then open the file in Google Sheets.

2. Import the Template and Add the Credentials

Copy the JSON from the box at the top of this guide and paste it into an empty n8n workflow. You get eight nodes, from reading the sheet to writing both scores back.

The OpenAI node uses n8n's built-in OpenAI credential. For JEV, create a Header Auth credential with the name Authorization and the value Bearer followed by your key.

3. Paste Your Sheet URL and Your ICP

Open Your settings and paste the sheet URL; it must end with gid=. Then replace the example ICP with yours.

Both models read the same ICP text, built once in the Build the input node.

4. Run It and Read the Sheet

Click Execute workflow. Each row gets five new columns: OpenAI score, OpenAI fit, JEV score, JEV fit and Same level.

Look at the rows where the models disagree. In our 12-lead run, both models gave a Strong fit to at least one lead at a competitor that our ICP lists as a disqualifier.

Which One Should You Use for Lead Scoring?

It depends on what you do with the score. Here is how we would choose from our results.

We use OpenAI in our own workflows for one reason: anyone can get a key. When JEV becomes available to the masses, it's the clearly the best option for lead scoring.

Our recurring exports into HubSpot, what we call IBAO (Intent Based Automated Outreach), must run for every reader who copies them.

If you use OpenAI and filter on the level, set your own score limits instead of rounding. Tuned limits raised OpenAI's exact level from 46% to 64%, and JEV's from 71% to 73%.

Those tuned numbers are optimistic, because the limits and the test used the same leads. Tune yours on a labelled sample, then check them on new leads.

For the full scoring workflow in HubSpot, see our guide to AI-powered ICP fit scoring.

Common Mistakes When Comparing Decision Models

Most comparisons we read tested a few prompts and called a winner. These are the mistakes that make a test say nothing.

1. Testing Without Labels

If you compare two models with each other, you only learn that they disagree. You need a correct answer for each lead, written before you look at the results.

2. Testing Only Good Leads

A list of Heads of Sales at software companies only tests one level. Add leads that fail one, three and all of your checks.

3. Running Each Lead Once

One run cannot show whether a model changes its answer. Three runs per lead showed that OpenAI never did and JEV did on 95 of 998 leads.

4. Reading the Level Name Without Checking the Scale

Two models can rank leads the same way but use different cut-offs, as ours did. Check where each model puts each label before you filter on a name.

Frequently asked questions