On this page
  1. What is Jev’s list price?
  2. How do you calculate cost per decision?
  3. What makes a Jev decision expensive?
  4. How does Jev compare with LLMs and local models?
  5. How do you control Jev spend?
  6. Where AI coding assistants get this wrong
  7. Checklist
  8. FAQ
    1. How much does Jev cost per request?
    2. Are Jev output tokens really free?
    3. Is Jev cheaper than an LLM?
    4. Is Laya cheaper than Jev?
    5. What happens if I hit a rate limit?
  9. Related topics
  10. Sources
concept

Jev Pricing: What a Decision Actually Costs

Jev costs $0.042 per million input tokens with free output. Here is the arithmetic per decision, what makes it expensive, and how it compares with alternatives.

Software Engineeringbeginner6 min readUpdated 2026-10-20

Quick answer

  • Jev is listed at $0.042 per million input tokens; output tokens are free.
  • Cost per decision is the state plus question tokens multiplied by the rate. A 400-token request costs about $0.0000168.
  • Long states, many questions, and retries are the three things that move the bill.
  • At 10,000 decisions of 400 tokens, the input cost is about $0.17. The human review and fallback path often cost more than the model call.
  • Compare total cost per resolved decision, not price per token; a local model has hardware and operations costs that a hosted price hides.

What is Jev’s list price?

TypeSafe lists Jev at $0.042 per million input tokens, with no charge for output tokens. You pay for input tokens; output tokens are free. That is a different pricing shape from an LLM, where output tokens are often the larger part of the bill. It also means the cost is entirely determined by what you send, not by how long the answer is.

The rate is small, but the number that matters is cost per decision. A short support ticket with three questions might be 300-500 tokens; a long contract with ten questions might be tens of thousands. The same per-token price produces very different bills depending on the state size and the number of questions. Model both before a high-volume launch.

How do you calculate cost per decision?

The formula is input tokens multiplied by the price per token. Input tokens include the state and the question text, including the option descriptions and instructions. If you send the same state with several questions, you pay for the state once per request, not once per question. That is why batching related questions into one call is usually cheaper than making one call per field.

Use your own average token count rather than a guess. Token counts vary by tokenizer and by language, and a long document can dominate the total. The small script below is enough to turn a measured average into a monthly estimate, and to see how sensitive the number is to state size.

PRICE_PER_MILLION_INPUT = 0.042

def cost_per_decision(state_tokens: int, question_tokens: int) -> float:
    return (state_tokens + question_tokens) / 1_000_000 * PRICE_PER_MILLION_INPUT

def monthly_cost(state_tokens: int, question_tokens: int, decisions: int) -> float:
    return cost_per_decision(state_tokens, question_tokens) * decisions

for state_tokens, question_tokens in [(250, 80), (800, 300), (4_000, 900)]:
    per_decision = cost_per_decision(state_tokens, question_tokens)
    print(f"{state_tokens + question_tokens:>5} input tokens: "
          f"${per_decision:.8f}/decision, ${monthly_cost(state_tokens, question_tokens, 10_000):.2f}/10k")

What makes a Jev decision expensive?

State size is the first driver. Sending the entire customer record when two fields answer the question multiplies the input for no accuracy gain. The second is question count: every option description and instruction is input, and a question with fifty labels is much more expensive than one with four. The third is retries. A failed request that is retried pays for the first attempt and the second, so a retry loop can double the bill without producing a decision.

The subtle driver is the fallback path. If 20% of decisions are below the confidence threshold and each one goes to a frontier LLM, the cheap decision model is only 80% of the story. Model the full path: decision call, fallback call, human review, and the engineering time to maintain it. That total is what you compare with the current system.

How does Jev compare with LLMs and local models?

Against an LLM, Jev is usually far cheaper per classification call because output tokens are free and its input rate is lower. But the LLM may replace several calls, handle the fallback, and generate the response, so the comparison is not per token. Against Laya, the license price is zero but the hardware, operations, and evaluation are not. Against Clef and OpenAI’s Decisions API, the list prices differ, and so do the modalities and hosting constraints.

The useful comparison is cost per resolved decision at your volume, including fallback and review. At low volume, a hosted API is often cheaper in total because the fixed cost of a local deployment is spread over few decisions. At high volume, the local model’s fixed cost is amortized and the per-decision cost approaches the hardware time. The crossover depends on your numbers, not on a generic claim.

How do you control Jev spend?

Measure the average input tokens before launch, not after the first invoice. Send only the fields the questions need, keep option descriptions short but distinguishable, and batch related questions into one call. Set a timeout and a retry cap so a failing request cannot loop, and use exponential backoff on 429 and 529 responses rather than retrying immediately.

Tag API keys by project and read the usage report monthly. Set a spend alert below the number you would be uncomfortable explaining. Track cost per decision and cost per resolved outcome, not just total spend; a rising total with rising volume is fine, while a rising cost per decision usually means the state or the question set has grown without a corresponding accuracy gain.

Where this bites vibecoders

The demo uses a three-line ticket and one question, so the bill looks like zero. Production sends the whole customer record, eight questions, and a retry loop, then adds an LLM fallback for every uncertain answer. The per-token price did not change; the workflow did. Measure tokens per decision and the fallback rate before you promise anyone that the decision layer is cheap.

Where AI coding assistants get this wrong

  • Multiplying the per-token price by request count without measuring input size.
  • Sending the full record when two fields would answer the question.
  • Writing option descriptions as long paragraphs that inflate every request.
  • Retrying a 4xx request instead of fixing the malformed question.
  • Ignoring the cost of the LLM or human fallback path.
  • Billing every project to one key and losing attribution.

Checklist

  • Measure average state and question tokens on real inputs.
  • Calculate cost per decision and cost per 10,000 decisions.
  • Trim the state to the fields the questions need.
  • Batch related questions into one call.
  • Set a timeout and a retry cap with exponential backoff.
  • Track the fallback and human-review rate.
  • Set a spend alert and review usage monthly.

FAQ

How much does Jev cost per request?

It depends on input size. At $0.042 per million input tokens, a 400-token request costs about $0.0000168, and a 5,000-token request costs about $0.00021. Measure the state and question tokens for your own inputs; the headline rate alone does not tell you the per-decision cost.

Are Jev output tokens really free?

TypeSafe prices output at zero; Jev returns typed answers rather than a generated reply. You still pay for input tokens, including the state, instructions, and option descriptions. There is no separate charge for the length of the answer.

Is Jev cheaper than an LLM?

For a classification-shaped call, usually yes, because output tokens are free and the input rate is low. For the whole workflow, it depends on fallbacks, retries, and whether the LLM also generates the response. Compare cost per resolved decision, not price per token.

Is Laya cheaper than Jev?

Laya has no per-call license fee, but it requires hardware, operations, and evaluation. At low volume, Jev is often cheaper in total. At high volume or under a data-residency constraint, Laya can be the better economic choice. Do the arithmetic with your own volume and infrastructure costs.

What happens if I hit a rate limit?

TypeSafe returns 429 for a rate limit and 529 when the service is overloaded. Retry with exponential backoff rather than immediately; the official SDKs handle this with their default retry policy. A retry is another billable input, so a tight retry loop is a cost problem as well as a reliability problem.

Sources

Share: