Independent Jev field guide

Build AI agents with a faster decision layer.

Jev is not another chatbot. It is TypeSafe AI's model for fast, typed, probabilistic decisions inside software. JevForAgents shows where that idea fits in real agent loops—with sourced builds, reusable patterns, demos, and evidence labels you can trust.

4 sourced builds6 agent patterns5 evidence levels
JEV / DECISION TRACE ready
STATE

“The browser is on a release page. The task is to find the newest version and stop.”

TYPED OUTPUT
actionclick_release0.91
goal_metfalse0.08
stuckfalse0.03
Code owns the loop. Jev makes the bounded judgment.
Browser agentsAgent routingTool selectionEvaluationGuardrailsMCP & skills

Jev is a decision model. Give it the current state of a workflow and a set of allowed answers; it returns typed values, probabilities, and confidence your code can use directly.

What Jev changes for AI agents

Most AI agent architectures ask one generative model to do everything: understand the situation, decide what should happen next, invent a tool call, write text, and judge whether the task is complete. That flexibility is useful, but it can be excessive for the tiny decisions repeated throughout an agent loop. A browser agent may only need to choose one element from a list. A support agent may only need to route a ticket. A coding agent may only need to decide whether a command is risky enough to require approval.

Jev narrows the job. TypeSafe AI describes it as the first public System One model: unstructured state goes in, while typed probabilistic decisions come out. The possible answer shape is defined before inference. Instead of asking for a paragraph and then parsing it, software asks for a choice, a graded score, or a yes/no probability called a noul. The surrounding application still owns permissions, retries, budgets, side effects, and recovery.

What Jev does not replace

Jev is not a complete AI agent framework, a browser automation runtime, or a general text generator. It will not write the email, create the code patch, or invent a search query for you. Those tasks still belong to deterministic code, templates, or a language model. The practical opportunity is separation of concerns: use a generative model when the system must create, and use Jev when the system must choose among outcomes already known to the program.

Typed output also does not mean every decision is correct. It means the response conforms to the allowed structure, so software does not receive an invented enum or malformed tool call. Accuracy, calibration, latency, privacy, and failure behavior still need testing in the exact workflow where you plan to deploy Jev. That distinction is central to how this site evaluates Jev agent builds.

THE USEFUL MENTAL MODELJev is the fuzzy if statement inside an otherwise explicit agent system.
COMMUNITY DEMO · JOEY KUDISH

Jev chooses; Playwright acts; code decides when to stop.

This open-source demo searches GitHub, opens the repository's Releases page, and answers a question about the newest release. The right-hand trace exposes each Jev judgment rather than hiding the loop behind a polished result. View the source and full README ↗

Reported by author

The project author also reports a Wikipedia navigation example completed in about four seconds for $0.0016. JevForAgents has not independently reproduced that measurement.

From messy agent state to a branch your code understands

A Jev call can evaluate multiple questions about the same state. The output remains bounded, making it easier to compose decisions without pretending a probability is certainty.

C

Choice

Pick one label from a predefined set. Use it for agent routing, model routing, tool selection, browser actions, categories, or escalation paths.

route: "human_review"
S

Score

Place a state on an ordered scale. Use it to rank urgency, quality, risk, relevance, evidence strength, or task-completion quality.

risk: 3.2 / 4
N

Noul

Return a calibrated yes/no probability. Use thresholds to auto-allow clear cases, block clear failures, and send uncertainty to a human.

goal_met: 0.93
OBSERVEDECIDE WITH JEVAPPLY POLICYACTVERIFY
Screenshot of Diogo Almeida's LinkedIn launch post for Jev, including the launch video and author identityOpen original LinkedIn post ↗
DIOGO ALMEIDA · TYPESAFE FOUNDER · SEP 15, 2026

The launch argument is about automation, not conversation.

In TypeSafe's launch material, founder Diogo Almeida asks why models that are strong at chat have automated so little work. His answer is that software needs an interface it can depend on: bounded results, explicit probabilities, and decisions that fit into code. The company calls its training approach Reinforcement Learning for Calibrated Decisions, or RLCD.

That is the thesis—not independent proof. TypeSafe publishes pricing, latency ranges, workflow evaluations, and methodological caveats, while the underlying model and training data are not open. JevForAgents therefore treats the launch post as an official source, labels its performance figures as vendor claims, and looks for public code or repeatable tests before treating a use case as established.

Fast and cheap are claims to test, not decorative badges.

TypeSafe publishes a 70–500 ms end-to-end range and a launch price of $0.042 per million input tokens, with output described as free. Those figures come from the vendor. Real agent latency also includes state construction, network distance, tools, retries, and the rest of the loop.

70–500 msVendor-published response range$0.042 / MTokVendor-published input price at launch
TypeSafe AI chart comparing average workflow accuracy and cost across Jev and several model providers
Official TypeSafe workflow-evaluation graphic. It is useful context, but it is vendor-produced and should not be read as an independent benchmark. See methodology and caveats ↗
GOOD FIT

Use Jev when the branch is known.

  • The available actions or labels can be enumerated.
  • The same judgment happens often inside a loop.
  • Your code can use probability thresholds meaningfully.
  • Latency or token cost makes a frontier LLM excessive.
  • A human-review path exists for uncertain outcomes.
POOR FIT

Keep a generative model when the answer must be invented.

  • The output needs novel prose, code, or an explanation.
  • The action space cannot be defined safely in advance.
  • A correct answer depends on tools or context Jev cannot see.
  • You need reasoning artifacts for audit or human review.
  • You have not defined what uncertainty should do.
09 / FAQ

Jev for AI agents, without the shorthand

Is Jev an LLM or an AI agent framework?

Neither description is quite right. Jev is TypeSafe AI’s first public System One model. It reads a supplied state and returns typed decisions with probabilities. It does not replace your agent framework, browser runtime, tools, or generative model; it can sit inside those systems as a specialized decision layer.

What is Jev good for inside an AI agent?

Jev is most interesting when the available outcomes can be defined before the call: choose a tool, route a request, score a trace, verify a condition, detect a stuck browser loop, or gate a risky action. These are frequent, bounded judgments where speed, cost, and a predictable output shape matter.

Can Jev generate text, code, or tool arguments?

Jev is designed to return typed decisions rather than free-form strings. If an agent must write a search query, explanation, email, or code patch, it still needs deterministic code, a template, or a generative model for that part. A practical architecture separates deciding from writing and acting.

Are the cost and latency numbers on this page independently tested?

No. The 70–500 ms response range and $0.042 per million input tokens are launch claims published by TypeSafe AI. The browser example’s roughly four-second run and $0.0016 cost were reported by its author. JevForAgents labels those sources and does not present them as first-hand tests.

BUILD WITH RECEIPTS

Found a Jev agent worth studying?

Submit the source, author, stack, and evidence. We will keep reported metrics separate from first-hand tests.