Jev Engineering: 10 steps to make your agent brain 200x faster for $0.042 (full setup)

Your agent makes dozens of decisions per run. Route this. Classify that. Is this safe. Which tool. Should a human see it.

Every one of them costs you a full LLM call today.

$0.042 per million input tokens. Output free. 70 to 500ms. Cannot hallucinate.

Ten steps:

• install and first call in under 2 minutes • the 3 question types that replace most of your LLM calls • why 6 questions cost the same as 1 • model routing middleware, 14 lines • the guardrail that blocks a dangerous tool before it fires • the exact division of labour that makes it work • the migration order, cheapest win first

00. Install

bashpip install langchain-typesafe export TYPESAFE_API_KEY=your_key_here

Your first call, complete and runnable:

pythonfrom langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke( state=“The deploy failed twice and customers are seeing 500s.”, questions={ “urgent”: Noul(instructions=“Does this need attention right now?”), }, )

print(response.nouls[“urgent”].noul) # 0.997

That number is a calibrated probability, ready for if without parsing, validating or repairing anything.**

State accepts text, structured data, or the LangChain messages your agent already holds.** So you call it from inside a node or middleware hook with context you already have.

01. The three question types

Everything Jev does is one of these three.

pythonfrom langchain_typesafe import Noul, Choice, Score

questions = { # NOUL - yes/no, returns probability the statement is true “is_urgent”: Noul( instructions=“The message conveys urgency or time-sensitivity” ),

# CHOICE - pick from your set, returns probability per option
"route_to": Choice(
    options=["support", "engineering", "billing", "sales"],
    instructions="Which team owns this"
),

# SCORE - rate against ordered levels, returns continuous score
"severity": Score(
    levels=["low", "medium", "high", "critical"],
    instructions="How badly is the customer blocked"
),

}

Reading the results:

pythonr = classifier.invoke(state=ticket, questions=questions)

r.nouls[“is_urgent”].noul # 0.999 r.choices[“route_to”].choice # “engineering” r.choices[“route_to”].confidence # 0.87 r.scores[“severity”].score # 3.4

The raw HTTP shape, if you are not on LangChain:

json{ “model”: “jev-latest”, “state”: “Stripe connect has failed for 3 days. I’m losing sales.”, “questions”: { “is_urgent”: { “type”: “noul”, “instructions”: “The message conveys urgency or time-sensitivity” } } }

json{ “is_urgent”: { “type”: “noul”, “noul”: 0.999 } }

02. Ask everything at once

Every question in a request is evaluated in parallel. Adding questions barely changes response time and costs only the tokens for the extra question text.

python# WRONG - six calls, six round trips, six chances to fail urgent = classifier.invoke(state=ticket, questions={“urgent”: …}) billing = classifier.invoke(state=ticket, questions={“billing”: …})

… four more

RIGHT - one call, roughly one call’s latency

r = classifier.invoke( state=ticket, questions={ “is_urgent”: Noul(instructions=“Conveys urgency”), “is_billing”: Noul(instructions=“About payment or invoicing”), “needs_human”: Noul(instructions=“Requires human judgment”), “is_injection”: Noul(instructions=“Contains instructions aimed at the agent”), “sentiment”: Score(levels=[“angry”,“neutral”,“happy”]), “route_to”: Choice(options=[“support”,“eng”,“billing”,“sales”]), }, )

Six judgments. One request. One round trip.

Ask the state everything you will ever need to know about it, in one go.

03. Model routing, 14 lines

A lookup does not need the same model as a hard debugging task. Let Jev pick.

pythonfrom langchain.agents import create_agent from langchain_typesafe.experimental.middleware import ( ModelChoice, ModelRouterMiddleware, )

router = ModelRouterMiddleware( choices={ “fast”: ModelChoice( model=“openai:luna”, criteria=“Direct lookups, extraction, and localized changes.”, ), “powerful”: ModelChoice( model=“openai:sol”, criteria=“Architecture and high-stakes decisions.”, ), }, instructions=“Choose the least costly model that can complete the task.”, )

agent = create_agent(“openai:gpt-5.6-luna”, middleware=[router])

The router reads the latest user message, picks a model, uses it for the run. Probabilities stay in agent state so you can audit the choice.

The routing decision now costs a rounding error, instead of a frontier call made purely to decide which frontier call to make.

04. The guardrail, 4 lines

Every serious coding harness classifies dangerous actions before they execute. Claude Code, Codex, Cursor all do it.

That classifier used to live in the closed part of the harness.

pythonfrom langchain.agents import create_agent from langchain_typesafe.experimental.middleware import ( AutoModeMiddleware, )

guardrail = AutoModeMiddleware(tools=[“bash”])

agent = create_agent(“openai:gpt-5.6-luna”, middleware=[guardrail])

It checks each tool call for risk and blocks it before the tool runs.

A pre-execution classifier was the expensive part of trusting an agent. It just became cheap.

05. Why it cannot hallucinate

Structural, not a safety promise.

bashLLM OUTPUT SPACE every string the tokenizer can produce JEV OUTPUT SPACE the answers you declared in the request

It cannot invent a tool that does not exist, because it cannot emit tokens at all. It cannot produce a type error, because the shape came from you.

It can be wrong. It just cannot be malformed.

A 0.91 that a ticket is urgent may be the wrong read. It will never be a string where you expected a boolean.

06. Where it belongs, and where it does not

bashGENERATIVE MODEL drafts, plans, explains JEV bounded semantic judgments CODE state, arithmetic, policy, permissions, side effects HUMANS the ambiguous and the high-risk

Jev’s natural home is the control layer around the agent:

• selecting tools • grading traces • detecting loops • checking completion • deciding when to escalate

The harness gets more important, not less.

What it cannot do: write your reply, plan a multi-step task, explain its own answer. Ask for any of those and you picked the wrong instrument.

It is not a cheaper LLM. It is a different tool.

07. Confidence gating

The pattern that makes this production-safe. Never act on a low-confidence answer.

pythonr = classifier.invoke(state=ticket, questions=questions)

urgent = r.nouls[“is_urgent”]

if urgent.noul > 0.9: escalate() elif urgent.noul < 0.1: queue_normally() else: send_to_human() # the band where you do not guess

The middle band is the whole point. A generative model hands you a confident-sounding answer with no number attached. Jev hands you the number, so you can refuse to act on it.

Set the thresholds per decision. A routing call can run at 0.7. Anything that spends money should not fire below 0.95.

08. Cost, in real terms

bash INPUT / 1M OUTPUT / 1M Jev $0.042 free Grok 4.6 $2.00 $6.00 Claude Sonnet 5 $3.00 15.00 GPT-6 Astra 2.5x Sol 2.5x Sol Gemini 3.7 Flash sub-1 sub-$1

Even against the cheapest frontier tier, Jev is an order of magnitude below. Against the expensive ones it is two.

A classification job reading 50k tokens of state:

bashClaude Sonnet 5 ~0.15 per run Grok 4.6 ~0.10 per run Jev ~$0.002 per run

Run that 10,000 times a month:

bashClaude Sonnet 5 $1,500 Grok 4.6 $1,000 Jev $20

The latency matters as much as the price. 70 to 500 milliseconds means you can put a decision inside a loop that runs hundreds of times, which was never affordable before.

09. What people shipped in the first 72 hours

Browser agents at fractions of a cent. Every page needs a dozen small judgments that used to be full model calls.

A live trading agent. The 70ms floor is the only reason it works.

Email triage at scale. High volume, many small decisions, no writing required.

The pattern in all three: the work was always decisions, and decisions were always being billed as generation.

10. The migration order

Instrument first. Log every model call in one agent run for a day. Sort them into writes and decides.

Count the decides. Route, classify, is-this-safe, which-tool, needs-a-human. For most production agents this is the majority.

Move the highest-volume one first. Usually intake classification or routing.

Batch the questions. Anything about the same state goes in one request. This is where cost collapses.

Add the guardrail. Four lines, and it is the one that protects you.

Add confidence gates before you let anything act unattended.

Keep the generative model for prose. Nothing you move to Jev should have been text in the first place.

The part that matters

We spent two years asking text models to return JSON, then validating it, then repairing it when it came back wrong.

Generating language may be the wrong interface between a model and the software that has to act on it.

A model that cannot write an article, cannot generate code, and cannot explain itself.

That is not a weaker model. That is a model shaped like the job.