JevEngineering

The decision layer your agents are missing

Stop paying a frontier model to make yes-or-no decisions. Ten steps that put Jev between your LLM and your code, so routing, scoring, approving and escalating cost fractions of a cent and come back with real probabilities.

Get the course Try the gate

state.json

{
  "files_touched": ["api/billing.py"],
  "outside_plan": [],
  "tests": "passed",
  "migrations": false
}

gate.py

with TypeSafeClient(model="jev-1.13.0") as client:
    r = client.system_one(
        state=snapshot(diff, plan, exit),
        questions={"verdict": Choice(...),
                   "blast_radius": Score(...),
                   "needs_human": Noul(...)})

response 212 ms

ship0.00

return0.00

escalate0.00

confidence 0.00reading

Three layers. Only one of them writes.

Most agent bills are frontier models answering questions that never needed a sentence. Which worker next. Is this safe to run. Is the goal met. Jev takes those, and only those.

generation.llm

Frontier LLM

Creates things. Research, prose, code, explanations. Expensive per call, and worth it here.

write
research
explain

decision.jev

Jev

Picks, scores and answers yes or no. Returns a distribution, not a paragraph. Cannot invent an option you did not define.

route
score
approve
escalate

execution.py

Your code

Calls the tool, holds the limits, owns every threshold. The part you review in a pull request.

thresholds
limits
tools

If the operation creates text, it stays with the LLM. If it picks an option, scores a value or answers yes or no, it goes to Jev.

A gate you can poke

This is the merge gate from the course, running in your browser with no API call. Move the numbers and watch which line of your code makes the decision. The model never gets a vote on whether something irreversible passes.

p(ship) The rest splits between return and escalate.

verdict confidence Not an accuracy percentage. Treating it as one ships bad gates.

blast_radius 0 one file, 1 several files, 2 data or schema.

needs_human 0.5 means it does not know.

gate.py

v      = r.choices["verdict"]radius = r.scores["blast_radius"].scorehuman  = r.nouls["needs_human"].p if radius >= 1.5 or human >= 0.70:    decision = "escalate"   # hard rule wins firstelif v.choice == "ship" and v.confidence >= 0.88:    decision = "ship"       # the confident pathelse:    decision = "return"     # the cheap failure

ship

return

escalate

return

Same forks. Different bill.

Every fork in your agent is a call. Slide to your volume and compare what the decisions cost on a frontier model against what they cost on Jev.

decisions per month

10,000

frontier model, three cents a call$300

Jev, 1,000 input tokens a call$0.42

Jev comes to 0.14 percent of the frontier bill for the same decisions.

Arithmetic, not a benchmark: 1,000 input tokens per decision at $0.042 per million, output free. TypeSafe's own evals claim 200x faster and 400x cheaper; those are vendor numbers from the favourable end, so treat them as a ceiling and measure on your own work.

Blank terminal to production gate

Ten steps that build one working gate, from finding the decisions in your agent to running them in production with thresholds you can defend. Every chapter ends with code that runs, not a snippet with three dots in the middle.

Shipped in the first 72 hours

Real builds from the week Jev came out. Look at the last row: nine speedups, and none of them were generation.

shipped.csv

who	what	cost and speed
Browser Use	Browser agent that finds flights, picking from the controls actually on the page	7 s, $0.0039
Hassan	Classified 1,018 AI research papers	$0.08 total, 256 ms median
Riley Brown	Classified 500 emails	seconds, 3.5 cents
Alex Volkov	Claude plugin scoring tool-call relevance	~1M tokens to 86K, 1 s
@robj3d3	Feed filter, 8 questions per post over 3 days of posts	~2 s, $0.007
@irabukht	SEO and GEO audit pipeline at an agency	~$250 per audit, down about 90 percent

What it can do, and what it can't

The course is honest about the edges, because the edges are where gates break.

it_can.txt

Pick one of up to 255 options you define
Score a state on a scale you define, fractions included
Answer yes or no as a probability
Run a whole battery of questions in one call, one latency
Route a request to the cheapest model likely to finish it
Classify an agent's action before it runs

it_cannot.txt

Write text, code, or an explanation of itself
Chain one judgment onto another inside a single call
See anything you left out of the state
Prove a file was written or a message was sent
Do arithmetic, counting or date comparison reliably
Beat an if statement that already works

TypeSafe says Jev cannot hallucinate. It cannot break your schema. It can still choose the wrong valid option, with confidence. The course is about catching that before it merges.

Before you buy

api_access.md

Do I need Jev access?

Jev is still in early access, so join the TypeSafe waitlist the day you start. The first module is about finding decisions and designing state, which you can do before your key arrives.

requirements.md

What do I need to know?

Basic Python. The code targets Python 3.12 and up, and the examples plug into LangChain where it helps.

access.md

How do I get in after paying?

Access is opened for the email you paid with. You log in with that email and a 6-digit code. Access is lifetime.

payment.md

Card or crypto?

Both. Pay by card through Stripe, or in USDT on the networks listed at checkout.

Stop payingfor yesor no

Lifetime access to all ten steps: the merge gate, the parallel battery, live option menus, the harness, and the shadow-mode rollout that sets your thresholds.

Get the course