Jev vs JEPA vs LLM

The one-line verdict

• Need text, code or a conversation? An LLM. It is the only one of the three that writes.
• Need your code to make a fast, typed decision with a probability attached? Jev (TypeSafe AI) is built for exactly that, though it is new, closed and in early access.
• Curious where AI research is heading beyond text? JEPA (Meta) is a research architecture for learning how the world works from images and video. You read its papers and use its released encoders; you do not chat with it.

The names look alike, but these are not three versions of one thing. Each answers a different question.

Three different questions

An LLM answers: what text comes next? It predicts one token at a time, conditioned on everything before it. That makes it a general-purpose writer: answers, code, summaries, chat.

A JEPA answers: what is the meaning of the part I can't see? Given part of an image or video, it predicts the hidden part's representation (its embedding), not its pixels. It never produces an image or a sentence; it learns a compact picture of how scenes are structured and how they change.

Jev answers: which of these options is right, and how sure am I? You give it a piece of state and a set of typed questions. It returns typed answers, such as a choice from your list with a probability for every option. It never writes free text.

Side by side

	LLM	JEPA	Jev
Made by	Many labs	Meta AI research (proposed by Yann LeCun)	TypeSafe AI
Output	Text, one token at a time	Embeddings (representations)	Typed answers with probabilities
Generative?	Yes	No	No ("gives up string generation")
Trained to	Predict the next token	Predict hidden parts in embedding space	Make calibrated decisions (TypeSafe calls it RLCD)
What you can use today	Many APIs and open models	Research code and checkpoints on GitHub	An API in early access, also on Cloudflare Workers AI
Open?	Varies	Code and weights published	Closed model, served by API
Good at	Writing, reasoning in text, code	Visual understanding, video prediction, robot planning research	Classify, route, score, yes/no checks inside software

LLMs: the writer

The transformer architecture behind LLMs was introduced in Attention Is All You Need (2017), and GPT-3 (2020) showed how far next-token prediction goes at scale: one model that can translate, answer and write code from a prompt.

Because an LLM's output is text, using it for a decision inside code takes extra work. You constrain the reply to a schema (see structured output), parse it, and handle replies that don't match. If you ask the model how confident it is, the number it writes is more generated text, not a measured probability. Some APIs expose token probabilities, which helps, but nothing guarantees those probabilities match how often the model is right on your task.

None of that is a flaw for writing tasks. It only matters when the output is a branch in your code rather than words for a person.

JEPA: the world-model research

Yann LeCun proposed the Joint-Embedding Predictive Architecture in his 2022 position paper, A Path Towards Autonomous Machine Intelligence. The argument: predicting every pixel or token forces a model to spend effort on details that can't be predicted (the exact texture of leaves, the next word in an open-ended sentence). Predicting in an abstract representation space lets it focus on what is predictable and meaningful.

The research line so far:

• I-JEPA (2023) learns from images. From a single context block, it predicts the representations of several target blocks in the same image, with no pixel reconstruction and no hand-crafted data augmentations. The paper reports training a ViT-Huge/14 on ImageNet with 16 A100 GPUs in under 72 hours.
• V-JEPA (2024) applies the same idea to video, trained on 2 million public videos using feature prediction alone: no text, no pretrained image encoder, no reconstruction. Its largest model reaches 81.9% on Kinetics-400 with a frozen backbone.
• V-JEPA 2 (2025) pretrains on over 1 million hours of internet video. Post-trained on less than 62 hours of unlabeled robot video, the action-conditioned version (V-JEPA 2-AC) was deployed zero-shot on Franka robot arms in two labs and picked and placed objects using image goals, with no data collected in those environments and no task-specific reward.
• LLM-JEPA (2025) brings a JEPA-style objective to language models for fine-tuning and pretraining, and reports outperforming standard training objectives across several datasets and model families. It is an early research result, not a product.

What a JEPA is not: a chatbot, or an API you send questions to. In practice, engineers use released JEPA encoders as feature extractors for vision tasks, or follow the research.

Jev: the decision-maker

TypeSafe AI calls Jev the first System One model, after the fast, intuitive "System 1" thinking described by Daniel Kahneman. TypeSafe's own summary: unstructured state in, typed probabilistic decisions out.

It supports three question types:

Type	Asks	Returns
Choice	Which option fits?	choice, probabilities for every option, confidence
Score	Where on this ordered scale?	score, probabilities, confidence
Noul	Is this statement true?	noul: the probability of "yes", from 0 to 1

All questions in one request are evaluated in parallel and in isolation against the same state. This is a real request from Cloudflare's documentation:

const response = await env.AI.run(
  'typesafe/jev',
  {
    state: 'I cannot log in after changing my password, and the reset email never arrives.',
    questions: {
      department: {
        type: 'choice',
        instructions: 'Which team should handle this support request?',
        criteria: {
          account: 'Login, password, profile, or security issues',
          billing: 'Charges, invoices, refunds, or subscriptions',
          technical: 'Product bugs, outages, or integrations',
          other: 'Requests that do not fit the other departments',
        },
      },
    },
  },
)

And the response it documents:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "account",
      "confidence": 1,
      "probabilities": { "technical": 0, "billing": 0, "account": 1, "other": 0 }
    }
  },
  "usage": { "input_tokens": 380, "output_tokens": 45 }
}

Facts from the documentation: a choice supports up to 255 options; on Cloudflare the context window is 32,000 tokens and input costs $0.042 per million tokens, with output not charged. TypeSafe's docs advise keeping questions atomic: instead of "rate this startup pitch", ask separately about market size, feasibility and differentiation, then combine the scores in your own code.

The claims, and who made them

TypeSafe reports end-to-end responses of 70 to 500 ms, against 3 to 329 seconds for frontier LLMs on a benchmark it cites, and 40 to 200 times faster on "System One shaped" questions at similar intelligence. Treat these as vendor claims: the evaluations are TypeSafe's own, the launch post notes they were mostly run from laptops, and it says plainly that it can't prove the low price isn't subsidized. The architecture beyond "a new model architecture" and a parallel sampler is not published.

The launch post also says Jev "can't hallucinate" because every output must match a predefined schema. That is true about shape and misleading about truth, which is the next section.

Type-safe is not the same as correct

Two independent papers tested exactly that gap:

• Type-Safe Is Not Error-Free swapped which definition belongs to which option name, leaving everything else unchanged. Across 1,200 decision tasks, decisions often followed the option's name rather than its definition, with decision-flip rates up to 70.4 percentage points higher when options had yes/no-style names.
• JevOut added short, ordinary-looking background sentences to the input. Across four decision systems including Jev, those additions redirected 61.4% to 73.2% of initially correct decisions to a wrong option chosen in advance, often with high confidence.

So a valid answer from a list is not proof of a right answer. Practical defenses:

1. Make option names agree with their definitions (refund_requested, not a).
2. Treat user-supplied text in the state as untrusted, the same as with prompt injection.
3. Send low-confidence answers to a fallback: a larger model or a person.
4. Measure accuracy on your own labeled examples before trusting any confidence number.

A worked example: triaging one ticket

Ticket: "I was charged twice this month and I want my money back."

• With an LLM: ask for JSON matching a schema such as {"team": "billing" | "account" | ...}, validate it, retry on failure. Flexible, and it can also draft the reply to the customer.
• With Jev: one choice question for the team and one Noul question ("Does the customer request a refund?"). Your code reads choice and the probabilities, and branches.
• With JEPA: no direct fit. The released JEPA models are vision and video encoders, not text classifiers.

A sensible production shape combines them: let the fast decision model handle clear cases, and route anything below a confidence threshold to an LLM or a human.

answer = result["answers"]["department"]
if answer["confidence"] >= 0.9:
    route_to(answer["choice"])
else:
    escalate_for_review(ticket)

Pick the threshold from your own labeled data, not from a guess.

Five questions that decide it

1. Is the output text for a person, or a value for code? Text means an LLM. A typed value makes a decision model worth testing.
2. Do you need a probability for every option? That is Jev's design goal; with an LLM you have to approximate it.
3. Can you depend on a closed, early-access API? If not, an LLM with structured output, or an open model, keeps you portable.
4. Is the input vision or video, and is this research? That is JEPA territory.
5. Have you measured it on your data? Every number above comes from someone else's tasks.

Honest limits

• Jev is new: the evidence is TypeSafe's evaluations plus a small number of early independent studies, and pricing and behavior may change.
• JEPA results are strong research results, mostly in vision, video and robotics; a JEPA-style language model is still an open question.
• LLMs remain the most capable general tool, and the most expensive per decision.

Remember this

• LLM = writes text; JEPA = learns representations of the world; Jev = returns typed decisions with probabilities.
• Jev and JEPA share a few letters, not an architecture.
• A schema guarantees the answer's shape, never its correctness.
• Vendor speed and cost figures are a starting point; test on your own examples.