Jev: The Judgment Layer for AI Agents – Architecture, Minecraft Demo, and Integration Patterns

Jev Opens to All Users with Free Tier

TypeSafe AI has removed the waitlist for Jev, granting new users a $5 credit (equivalent to 120 million tokens) with free output. Unlike general-purpose LLMs, Jev does not generate long-form text; instead, it returns structured judgments — options, scores, or probabilities — making it suitable for high-frequency decision loops in agent systems.

Why Jev Fits as an Agent "Judgment Layer"

Jev is priced at $0.042 per million input tokens with free output. Because it only emits structured decisions rather than lengthy explanations, its latency and cost are low enough to run inside tight agent loops. Typical micro-decisions — whether to continue a route, which tool to use, whether a state satisfies a threshold, or which context to retain — would be expensive and slow if handled by a large planner model on every iteration. Offloading these bounded judgments to Jev lets the planner focus on complex reasoning and long-horizon planning.

The key architectural insight is separating open-ended reasoning (planning) from closed-option judgment (action selection). Jev does not replace GPT, Claude, or Gemini; it complements them by handling the high-volume, low-latency decisions that would otherwise bottleneck the system.

Case Study: Jev + GPT-6 Astra Defeats Minecraft Ender Dragon in 8 Minutes 43 Seconds

An open-source implementation by Malde decomposes the AI dragon-slaying team into three layers:

Astra Handles High-Level Planning

Astra receives the current game phase, inventory, and pre-scouted waypoints. It updates goals and the next waypoint roughly every 15 seconds, or when the phase changes. It answers "what should we do overall?"

Jev Selects Actions

The execution code generates candidate actions (move, gather, combat) based on the current state. Jev picks the action that best advances the current goal. It does not re-explain the world; it only decides on the immediate step.

Deterministic Code Executes

Pathfinding, turning, block placement, and protocol operations are handled by conventional code. When Jev selects "timed bed attack," the code places the bed, aims, monitors the dragon's head position and cover conditions, and detonates when criteria are met. If the situation becomes dangerous, the code aborts and returns the new state to the judgment layer.

This separation explains the continuous gameplay: the planner does not refresh every frame, the judgment layer does not generate natural language for every step, and low-level operations run at native speed. The run logged 131 Jev decisions and only 35 Astra calls, illustrating that real-time agents rely on tiered models and deterministic code each doing what they do best.

Total cost: ~$0.97 for the full Ender Dragon kill.

Expanding Beyond Games: Voice Assistants, Browser Automation, and More

After Jev's public release, developers quickly applied it to voice assistants, browser automation, and form filling. A Mac voice assistant can open notes, search papers, open social sites, and create tabs from spoken commands. Browser automation projects use Jev to decide which field to fill, whether a page has loaded, or which control to click next — while the actual clicks, copies, and pastes are performed by execution code.

The Browser Use team's open-source jev-ultrafast demo shows:

Flight search (open page → search Zurich to London): 7.1 seconds, ~$0.0039.

Virtual try-on ("change to black dress"): ~620 ms per decision, ~$0.0011.

These numbers come from specific demos and do not generalize to all tasks, but they demonstrate a direction: when an agent's action space is bounded and feedback is immediate, a specialized fast judgment model can outperform a general-purpose LLM in high-frequency loops.

Context Compaction and Agent Evaluation Also Need Judgment Models

As agents run longer, context grows. Deciding which tool calls to drop, which results to keep, and which history to truncate often requires nuanced judgment beyond fixed rules. The open-source project fast-jev-compaction breaks context management into a series of keep/discard decisions made by Jev, with code performing the actual truncation while preserving original user/assistant messages.

Another role is Agent Judge. LangChain experiments fixed five weather-task agent outputs and had different evaluator models score each sample 100 times. Jev averaged ~0.44 seconds per call at ~$0.00035, producing stable continuous scores. Such scenarios suit Jev because the judgment space is clear: retain or drop, pass or fail, risk level, best candidate. It does not replace the planner's creative generation but turns workflow boundary judgments into independent, low-cost, repeatable components.

Practical Agent Architecture Using Jev

A production-ready combination can be designed as:

User Goal → Planner Creates Plan → Jev Judges State & Next Action → Deterministic Code Executes Tool Call → Return Result & Update State → Planner Refreshes Plan as Needed

Four boundaries must be respected:

Jev's input should be structured; do not stuff the entire conversation history into it.

Candidate actions must be generated and permission-filtered by code; do not let the model choose dangerous operations.

Execution code must validate Jev's output and reject actions that violate conditions.

Plan refresh and action loop must be decoupled so planner latency does not stall every low-level action.

With this design, Jev becomes a decision component inside the agent — not another chat box — and can sit at tool routing, context compaction, result evaluation, browser control, game actions, or multi-agent collaboration boundaries.

Frequently Asked Questions

Is Jev meant to replace GPT or Claude?

No. Jev excels at fast option/scoring/probability returns; general models excel at planning, explanation, and complex reasoning. Combining both is usually more effective than using either alone.

Why are Jev's speed and cost better suited for agents?

It only performs bounded judgments without generating long text, reducing latency and token consumption in high-frequency loops, leaving the general model for high-level tasks.

Can Jev directly execute code or click web pages?

Jev selects actions; actual code execution, web clicks, and game operations are performed by programs or tools. The execution layer must validate the model's judgment and retain permission and audit boundaries.

Can the 120 million token free quota be used long-term?

The quota is a limited-time new-user policy; exact validity, scope, and terms are subject to TypeSafe AI's current announcements.

How should a team start experimenting with a judgment-layer architecture?

Pick a task with a limited action space (e.g., tool routing, context compaction, result scoring), fix the candidate set and acceptance metrics, then compare Jev against a general model on latency, cost, stability, and error rate.