Jev vs ChatGPT: Which Work Goes to a Decision Model

The difference in one line: generated text vs typed answers

ChatGPT takes a prompt in and returns text. Even when you ask for JSON, it is generated token by token.

Jev takes state plus questions in and returns probabilities. You write the questions and options first; Jev answers only within them. There are three question types:

• Choice: pick one option, with a probability for each.
• Score: rate on an ordered scale.
• Noul: return the probability of "true".

System One here is an open-source TypeScript SDK (@system-one-ai/core) plus a hosted API. New to this kind of model? Start with what is a decision model?.

Comparison table: the same work, assigned to each

This table compares interface and mechanics only — not accuracy, speed or price.

Dimension	ChatGPT (OpenAI API + structured outputs)	Jev (on system-one.dev)
Output shape	Generated text; with structured outputs, text that matches a JSON SchemaSource: OpenAI structured outputs · Verified 2026-10-12	Typed answers plus probabilities; no generated textSource: Jev docs · Verified 2026-10-12
Answer space	Open; fields such as enum restrict the format	Only the options or levels you supplySource: System One decision primitives · Verified 2026-10-12
Uncertainty signal	Structured outputs return no per-option probability; you design one	Choice returns a probability per option; Noul returns P(true)Source: System One decision primitives · Verified 2026-10-12
Explains its reasoning	Yes; it can write a rationale	No; it does not explain its reasoningSource: System One docs · Verified 2026-10-12
Inputs	Text, images and more; see the OpenAI docsSource: OpenAI structured outputs · Verified 2026-10-12	Text and JSON; no imagesSource: Jev docs · Verified 2026-10-12
Metering	Billed per token; see OpenAI pricingSource: OpenAI API pricing · Verified 2026-10-12	Credits per question and per request byte block (below)Source: system-one.dev pricing · Verified 2026-10-12
Best tasks	Replies, summaries, arbitrary extraction, multi-step reasoning	Classification, routing, scoring, yes/no checks

The real comparison: ChatGPT plus JSON Schema

Most developers no longer classify through a chat UI; they use the OpenAI API with a JSON Schema or function calling. So that is the setup worth comparing against.

What structured output solves, and what it does not

The OpenAI documentation says structured outputs make the model always produce a response matching your JSON Schema — required fields are present and enum values are valid. That solves format.

What it does not solve:

• Uncertainty: you get one enum value but not how sure the model was. Any confidence signal is something you design yourself.
• Edge cases: the OpenAI documentation also states that a refusal or hitting the max-token limit can produce output that does not match the schema, and you handle that separately.Source: OpenAI structured outputs · 2026-10-12

Your existing schema, mapped to a Jev question

One task, two implementations: support-ticket routing

Task: read a support message, decide which team handles it, and whether a refund is requested.

Both snippets are illustrative and exist to compare shapes; neither has been run. The first is pseudocode; the second follows @system-one-ai/core usage shown elsewhere on this site. No real response numbers appear here.

Option 1: ChatGPT plus JSON Schema (pseudocode)

ts// Illustrative pseudocode, not tested
const schema = {
  type: 'object',
  properties: {
    team: { type: 'string', enum: ['billing', 'support', 'review'] },
    refundRequested: { type: 'boolean' },
  },
  required: ['team', 'refundRequested'],
  additionalProperties: false,
};
// 1. Send the message and schema with structured output enabled
// 2. Check for a refusal or max-token truncation
// 3. Parse the JSON into team and refundRequested
// 4. No per-option probability: a confidence signal is up to you

Option 2: Jev plus @system-one-ai/core (illustrative)

ts// Illustrative code, not tested
import { choice, booleanQuestion } from '@system-one-ai/core';
import type { EvaluationClient } from '@system-one-ai/core';

const ticketQuestions = {
  team: choice('Choose the team that should handle this message.', {
    billing: 'Payments, invoices, and refunds',
    support: 'Technical issues with the product',
    review: 'Needs a person; the request is incomplete or consequential',
  }),
  refundRequested: booleanQuestion('Does the message ask for a refund?'),
};

export async function routeTicket(client: EvaluationClient, message: string) {
  const result = await client.evaluate({ state: { message }, questions: ticketQuestions });
  return {
    team: result.answers.team.choice,
    teamConfidence: result.answers.team.confidence,
    refundProbability: result.answers.refundRequested.probability,
  };
}

For how the client is created, see createHostedClient() in what is a decision model?. Model IDs come from GET /v1/models; don't copy them by hand.

The difference: option 2 returns probabilities, so the code can branch on a threshold — send low-confidence tickets to a person, for example. Set that threshold on your own labelled samples.

When ChatGPT is still the right tool

Keep these with the large model:

• Writing replies, emails or code.
• Summarising long text and adjusting tone.
• Extracting arbitrary fields you cannot list in advance.
• Multi-step reasoning, or answers that need a written rationale.
• Input that includes images or other non-text content (Jev reads text and JSON only).

Combining them: the model writes, Jev gates

Jev triages first, the model handles the uncertain cases

Classify with Jev's Choice first. High confidence follows the matching path; low confidence goes to the large model. See model routing.

After generation, Jev checks yes/no

Once the reply is written, ask a Noul question such as "does this reply promise a refund?" High probability blocks it or sends it to a person. See agent guardrails. To score generated output instead, see an LLM-as-a-judge alternative.

Thresholds in both patterns come from your own labelled samples.

What about Claude?

The relationship is the same. Claude is also a generative model and also offers structured output: the Anthropic documentation says it constrains decoding so answers match the schema.Source: Claude structured outputs · 2026-10-12 The ChatGPT plus JSON Schema analysis above applies to Claude too. This page does not evaluate Claude separately.

Billing and trying it

Calls to Jev on system-one.dev are billed in credits:

Every 4KB is one block, and anything smaller still counts as one block. Cost = blocks × questions × the model rate.

• Jev rate: 1 credit per question per block.
• Bytes are the UTF-8 size of the whole request, not a character count. A non-Latin character can take several bytes.
• A partial block is charged as one block.
• Example: a 9,000-byte Jev request with 2 questions = 2 × 3 × 1 = 6 credits.

New accounts start with 100 credits, and credits never expire. Select a model by its full model ID, read from GET /v1/models. See pricing.

ChatGPT bills per token, a different meter, so per-unit prices are not directly comparable — cost both on your own typical request.

Want to try? Run a sample (sign-in required).

Related reading

• What is a decision model?
• Jev model page
• Jev vs Clef: choosing a hosted model

Verified 2026-10-12