Hands-on with Jev: How to Swap Lowest Cost for Highest Quality (Including Exact Configurations)

Jev Configuration Guide: How to Get the Highest Quality at the Lowest Cost

Author: darkzodchi (@zodchiii, a technical author writing on Substack)

The core thesis here is sharp: Jev’s cost arithmetic is inverted. Where you’ll lose money isn’t the API bill—it’s the architecture.

I. Let’s Look at the Price Table First

• $0.042 / million input tokens, output tokens are free

• Rate limits: 250,000 tokens/second, 1,200 requests/minute (TypeSafe says these numbers may change at any time during scaling)

• Context: 64k tokens total per request, with 32k allocated for state plus your longest single question

• Input: Text only. Strings, JSON, text arrays. Images and audio are not supported.

Do the math and you’ll see the bill isn’t the problem:

10,000-token state × 1,000 decisions

Astra: 10M tokens × $10.00/M = $100.00

Jev: 10M tokens × $0.042/M = $0.42

This ratio illustrates the point: The API bill isn’t where you’ll lose money. You’ll lose it on architecture.

II. The Setting That Determines Your Bill: How Many Questions to Pack Per Call

This is the most valuable part of the entire article:

Every question in a single request evaluates against the same state in parallel. Adding questions has almost no impact on latency, and the state is only billed once, not once per question.

So the expensive mistake is: one question per call.

TypeSafe’s own cookbook benchmarked a 13-question brief both ways. Batching into a single call was 12.2x cheaper and 10.0x faster, with no change in answers.

Code you can use directly:

from typesafe_sdk import TypeSafeClient, Choice, Score, Noul

client = TypeSafeClient(model="jev-1.13.0")   # Lock the version number, don't use aliases

response = client.system_one(
    state=ticket_text,
    questions={
        "category": Choice(
            instructions="Determine the broad category of this support ticket",
            criteria={
                "bug_report": "Something is broken or producing errors",
                "billing": "Charges, invoices, refunds, subscriptions",
                "feature_request": "The user is requesting new functionality",
                "account": "Login, permissions, profile, security",
            },
        ),
        "bug_severity": Score(
            instructions="How severe is the reported issue",
            criteria=[
                "Cosmetic, no impact to functionality",
                "Broken or degraded feature, workaround exists",
                "Blocking issue, no workaround",
            ],
        ),
        "refund_requested": Noul(
            instructions="The user is explicitly asking for a refund or credit",
        ),
        "frustration": Score(
            instructions="How frustrated the user appears",
            criteria=["Calm", "Frustrated but civil", "Very angry"],
        ),
    },
)

Note the model line: the author emphasizes locking the version number (jev-1.13.0), not using aliases.

Then comes the key pattern:

Ask all questions you might ever need. If the ticket ends up being a feature request, bug_severity didn’t cost you anything—you just ignore it in your code.

This is the pattern: fan out all questions, then route in your code.

III. Confidence Is the Second Axis

Every Choice and Score answer comes with a confidence, a number between 0 and 1, derived from how concentrated the probability is. The flatter the distribution, the lower the confidence.

The answer tells you “what is.” Confidence tells you “whether to act on it.”

And it’s split into three tiers, with thresholds that shift based on risk level.

IV. Other Topics the Author Says He Covers

From the tweet, this article also includes:

• That 12.2x cheaper request pattern (expanded above)

• The nine things Jev’s own documentation says it cannot do

The second point deserves special attention—most people reading a model introduction only see what it can do, while the author specifically went to read what it cannot do. This is the part you should examine more closely when judging if a model is production-ready.

V. My Take

This piece and the previous one form a perfect pair: that one teaches you how to train your own; this one teaches you how to use an existing one correctly.

Moreover, the insight it provides applies far beyond Jev:

When you’re using something that bills state once and evaluates questions in parallel, “one question per call” is pure money wasted. This is a pitfall many people hit the first time they integrate this type of API, because everyone is accustomed to the LLM pattern of “one question per call.”

One boundary to note: The numbers in the article (12.2x, 10.0x) come from TypeSafe’s own cookbook—they are vendor self-tests. The direction is certainly correct (the state-only-once billing is dictated by the pricing model itself), but the exact multipliers need to be measured on your own request patterns.

Links

Tweet (1.17M views): https://x.com/zodchiii/status/2101243146596384854

Author’s Substack: https://zodchiii.substack.com/

#Jev #CostOptimization #AgentEngineering