Jev is a very good classifier wearing a frontier model's coat

Two years in stealth. Ex-OpenAI. Co-invented ChatGPT. That is the pitch for Jev, and the pitch is doing most of the lifting.

Strip the marketing off and look at what it actually does. Hand it a list of options, it picks one. Hand it criteria, it scores against them. Hand it a proposition, it rules true or false. That is the whole surface. A narrow-interface JSON classifier. Useful, genuinely. Not new. And it can pick wrong, score wrong, and judge wrong like anything else that outputs a guess.

The "no hallucinations" claim is a naming decision

The headline is no hallucinations. Read how that works and it works by redefining the word. Give a model a JSON schema or an enum and it gets physically masked out of the illegal tokens at decode time. It cannot emit a value outside the set, so of course it never invents one.

This already ships everywhere:

Approach	What enforces the shape
OpenAI Structured Outputs	schema-constrained decoding
Anthropic tool use	typed input schema on the tool
LangChain + Pydantic	parse and validate, retry on failure
Outlines	grammar-constrained decoding, token mask

Constrained decoding is not a frontier. It is a decoding step. Calling a masked output space a hallucination-free model is a naming decision dressed as a discovery.

Their own docs say it: this is a sidecar

Jev is not an agent. It is a sidecar. The big LLM still reads the messy human request; Jev handles routing, moderation, risk scoring, validation. They brand it System One plus, fast and instinctive against slow deliberate System Two.

Honest framing: a non-autoregressive bounded-judgment module that trades accuracy for speed and cost. Plainer than that: the if-else submodule of an agent system, given a personality and a launch video.

And the accuracy trade is real. On multiple-choice picks it reportedly lags just asking a current frontier model the same question directly. So the actual value is cheaper classification, routing, scoring, policy checks at volume. That is a cost pitch. A good one. It has been dressed as a frontier-model pitch, and those are not the same animal.

The rest reads thin under a light. Context window is 32k, which is small for anything that has to hold a real workflow in its head. The Doom demo got passed around, but it cheated: wall vision and enemy coordinates fed straight in, and it still played worse than algorithms a fraction of the size. When the flashy demo needs training wheels and still loses, that is the tell.

Two hours of stealth

Within about two hours of launch, a developer named Harsha Gundala shipped Qwen-2.5-1B-RLCD on Hugging Face doing the same class of work. No new training. Just a different way to spend one forward pass.

The recipe is not secret:

1. Prefill the context once into a KV cache.
2. Broadcast that cache across every schema field.
3. Slice the logits down to only the valid candidate tokens per field.
4. Softmax over that slice for calibrated per-field probabilities.
5. Assemble the JSON programmatically, so syntax is valid by construction, one hundred percent, every time.

Autoregressive, for one 28-field object:

[context] -> "{" -> "\n" -> "\"risk" -> "_level" -> "\":" -> "\"HIGH" -> ...
             ~150 to 500 sequential forward passes, one token at a time

Parallel constrained, same object:

[context] --prefill once--> KV cache
                             |-- risk_level      -> mask to {LOW, MED, HIGH}     -> HIGH  p=0.70
                             |-- requires_review -> mask to {true, false}        -> true  p=0.98
                             |-- action_tier     -> mask to {P0, P1, P2, P3}     -> P1    p=0.61
                             |-- ... 25 more, all in the same pass
                          assemble JSON in code, syntax valid by construction

Defining the shape is the whole interface:

schema = {
    "priority": {
        "type": "enum",
        "choices": ["P0_CRITICAL", "P1_HIGH", "P2_NORMAL", "P3_LOW"],
        "description": "Urgency tier based on customer business impact",
    },
    "requires_escalation": {
        "type": "boolean",
        "description": "Whether an on-call engineer must be notified",
    },
    "department": {
        "type": "enum",
        "choices": ["BILLING", "INFRASTRUCTURE", "SECURITY", "PRODUCT"],
        "description": "Target handling department",
    },
}

result = run_parallel_generation(context, StructuredSchema(schema))
print(result["elapsed_ms"], result["parsed_json"])

And every field comes back with its own calibrated confidence, which the token stream never gave you:

{
  "is_vulnerability":    { "value": true,                    "prob": 0.9933 },
  "severity_level":      { "value": "HIGH",                  "prob": 0.6992 },
  "secret_type":         { "value": "AWS_ROOT_KEY",          "prob": 0.9998 },
  "target_environment":  { "value": "PRODUCTION_CLUSTER",    "prob": 1.0000 },
  "false_positive_risk": { "value": "LOW",                   "prob": 0.5475 }
}

Reported numbers on an M4 Mac:

Task	Fields	Autoregressive	Parallel	Speedup
Fintech fraud routing	4	420 ms	75 ms	5.6x
Code security audit	4	380 ms	68 ms	5.6x
High-cardinality tariff	1 of 255	500 ms	89 ms	5.6x
Enterprise support triage	28	1,900 ms	270 ms	7.0x

Others have shipped their own versions since. One is sitting at openjev.com.

The part actually worth keeping

When every field's value comes from a bounded set, autoregression is pure overhead. One forward pass can already score every key in parallel. Token-by-token sampling is the only thing forcing the output to come out serially, one word at a time, for no reason. That insight is real, it is clean, and it is now open source. Take it.

Fair counterpoint, because it deserves one. Burning tokens to emit JSON, parse it, then write more code to handle the times it comes out malformed is genuinely wasteful. A lot of the industry quietly bills you for that waste. The speed and cost wins here are not marketing, they are real, and if you route or classify at scale you should go read the technique this week.

But real wins and a new species of model are different claims. This is the first, sold as the second. It is not a frontier model. It is not a new technical route for agents. It is a sharp, narrow tool with a very good origin story bolted onto the front.

The technique is worth a few hours of your time. The positioning is a costume. Being ex-OpenAI is not an architecture.

Some Jev showcases

1. Jev: A System One Model for Software Decisions

In the attached demo, a browser agent uses Jev to find a Zürich → London flight in 7.1 seconds by choosing each operation and target in real time.

LLMs generate the plan. Jev could become the decision engine running inside every software loop.

Orignal post on X

2. Hands-Free Coding Agent Management

This project creates a live voice agent to manage multiple tmux coding agents hands-free, allowing users to receive updates and send messages to their coding team through voice commands.

Orignal post on X

3. Mate's Table: 10,000 AI mates for discovery restaurants

A social network where restaurants open and 10,000 AI personas choose and eat. Post a restaurant intent, and the crowd reacts within seconds.

Mate's Table