---
title: "Jev vs Claude: Where a Decision Model Fits in a Claude Agent"
description: "Claude understands and writes; Jev answers one typed question and returns a probability. The four decision points worth moving out of a Claude agent, and the TypeScript to wire them up."
canonical: "https://system-one.dev/en/blog/jev-vs-claude"
language: "en"
---

# Jev vs Claude: Where a Decision Model Fits in a Claude Agent

**Jev vs Claude:** Claude is a generative model — it understands, reasons, writes replies and writes code. Jev is a decision model: it reads text or JSON and answers predefined questions (pick one, give a score, yes/no), returning probabilities and no text. So Jev does not replace Claude, and cannot be the main model of a coding agent.

**Where does Jev go in a Claude agent?** Move out the steps that need only one option or one probability: which tool to call, whether a call is allowed to run, whether the task is finished, whether to escalate to a stronger model. Call Jev from your agent code through the TypeScript SDK or the HTTP API. Claude keeps generating and reasoning; your code reads the returned probability and decides what happens next.

## The difference in one line

Claude takes messages in and returns text or tool calls. Jev takes state plus questions in and returns probabilities. State is whatever you want judged — text or JSON.


| Dimension | Claude | Jev (on system-one.dev) |
| --- | --- | --- |
| Output | Generated text, or a structured tool call<br><small>[Claude tool use docs](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview) · 2026-10-12</small> | One of your predefined options, levels or yes/no values, with probabilities; no generated text<br><small>[System One decision primitives](https://docs.system-one.dev/en/docs/primitives) · 2026-10-12</small> |
| Explains its reasoning | Writes a rationale | No; probabilities only |
| Inputs | See Claude's docs | Text and JSON; no images |
| Metering | Billed per token; see Claude pricing<br><small>[Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing) · 2026-10-12</small> | Credits per block and per question (below) |


For the full comparison and the JSON Schema mapping, see [Jev vs ChatGPT](https://system-one.dev/en/blog/jev-vs-chatgpt) and [Decision model vs structured output](https://system-one.dev/en/blog/decision-model-vs-structured-output).

## What Jev cannot do

- Write replies, emails or code.
- Explain its reasoning, or perform multi-step reasoning.
- Serve as the main model of a coding agent. A coding agent needs generated code and tool calls; Jev's shape is state and questions in, probabilities out.
- Read images.

All of that stays with Claude.

## Four decision points inside a Claude agent

### Picking a tool (Choice)

With many tools, Claude can pick wrong. List the candidate tools as Choice options plus a "none of these", let Jev pick one, and hand low confidence back to Claude or to the user. See [agent tool routing](https://system-one.dev/en/blog/agent-tool-routing).

### Gating a call (Noul)

After Claude produces a tool call, ask a yes/no question before it runs — for example "would this command delete production data?" — then allow, block or escalate by probability. See [agent guardrails](https://system-one.dev/en/blog/agent-guardrails).

### Is the task done? (Noul)

Claude saying "done" is not proof. Split "done" into a few yes/no questions and pair them with deterministic checks such as tests before stopping or continuing. See [agent stop conditions](https://system-one.dev/en/blog/agent-stop-condition).

### Should this escalate to a stronger model? (Score / Choice)

Score the request's difficulty, or pick a tier with Choice: easy requests go to a small model, hard ones to a stronger one. See [model routing](https://system-one.dev/en/blog/llm-model-routing).

## Wiring it up: a decision point in agent code

There are two integration paths — the TypeScript SDK `@system-one-ai/core`, or the HTTP API — both called from your own agent code.

The flow:

1. Claude produces a candidate action (a `tool_use` block).
2. Your code sends that action as state to Jev, with one or more questions.
3. Jev returns probabilities.
4. Your code applies thresholds: run, escalate to a stronger model, or ask a person.

> The code below is **illustrative** and has not been run. The Claude side follows the `tool_use` shape in the [Claude tool-use docs](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview); the Jev side follows `@system-one-ai/core` usage shown elsewhere on this site. The thresholds are placeholders — choose your own on labelled samples.

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

const gateQuestions = {
  destructive: booleanQuestion(
    'Would this tool call delete or overwrite production data?',
  ),
};

type ToolUse = { name: string; input: unknown };

// toolUse comes from the tool_use block in Claude's reply
export async function gateToolCall(client: EvaluationClient, toolUse: ToolUse) {
  const result = await client.evaluate({
    state: { tool: toolUse.name, input: toolUse.input },
    questions: gateQuestions,
  });
  const p = result.answers.destructive.probability;

  // Placeholder thresholds; re-select them on your own labelled samples
  if (p >= 0.8) return 'block';
  if (p >= 0.3) return 'ask_human';
  return 'run';
}
```

For how the `client` is created, see [What is a decision model?](https://system-one.dev/en/blog/what-is-a-decision-model). Select a model by its full model ID, read from `GET /v1/models` — don't copy IDs by hand.

## Does it work in other languages

Jev handles non-English input, but accuracy is lower than in English.

Test on your own samples. One comparison worth trying: write questions and options in English while keeping state in the original language, then run both variants over the same data. That is a testing suggestion, not a conclusion.

## Cost and trying it

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

- Jev rate: 1 credit per question per block.
- Blocks are counted over the whole request's bytes.
- Example: a 9KB request with 2 questions is 3 blocks → 3 × 2 × 1 = 6 credits.

New accounts start with 100 credits, and credits never expire. See [pricing](https://system-one.dev/en/pricing).

Claude bills per token; see [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing). The two meters differ, so per-unit prices are not directly comparable — cost both on your own typical request.

Want to try? [Run a sample (sign-in required)](https://system-one.dev/en/demo) — for example [code review risk](https://system-one.dev/en/demo/code-review-risk) or [NPC action choice](https://system-one.dev/en/demo/npc-action) (sample data).

## Related reading

- [Jev vs ChatGPT](https://system-one.dev/en/blog/jev-vs-chatgpt)
- [Decision model vs structured output](https://system-one.dev/en/blog/decision-model-vs-structured-output)
- [Jev model page](https://system-one.dev/en/models/jev)
- [system-one.dev pricing](https://system-one.dev/en/pricing)

Verified 2026-10-12


## Frequently asked questions

### What is the difference between Jev and Claude?

Claude generates text and tool calls; Jev answers predefined questions with an option, a score or a yes/no probability, and never generates text.

### Can Jev replace Claude, or serve as a Claude Code model?

Neither. Jev produces no text; it can only take over the decision steps inside an agent.

### Which steps in a Claude agent suit Jev?

Choosing a tool, gating a tool call, deciding whether the task is complete, and choosing whether to escalate to a stronger model.

### How do the two connect?

In your agent code, call Jev through the TypeScript SDK or the HTTP API, then branch on the returned probability.

### Does Jev support other languages?

It handles non-English input, but accuracy is lower than in English. Test on your own samples.

### How is it billed, and how do I try it?

Every 4KB is one block (a smaller request is still one block). Cost = blocks × questions × the model rate; Jev is 1 credit. New accounts get 100 credits. [Run a sample (sign-in required)](https://system-one.dev/en/demo).