Jev Limitations: What It Can't Do (Read Before You Build)

Launch weeks produce two kinds of disappointment: people who never tried the thing, and people who tried it for the wrong job and concluded it's broken. This page exists to prevent the second kind. We catalog what works; credibility requires cataloging what doesn't, with the same receipts-first sobriety. Here is everything we'd want a friend to know before building on Jev, organized from hard walls to soft edges.

The hard walls (by design, not by bug)

No generation, at all. Jev does not write, summarize, rewrite, translate, chat, or explain. Every capability is some form of picking from a constrained set. If any part of your feature requires composed text, that part belongs to a chat model, full stop; the Jev vs GPT breakdown maps the split.

No open-ended reasoning. Multi-step deduction, novel problem solving, "figure out what's going on here": wrong tool. Decision models rule on framed questions; the framing intelligence is yours (or a frontier model's, in a cascade).

No conversation state. Each verdict stands alone. Anything requiring memory across turns is architecture you build around it, not behavior you get from it. And one sizing wall from the ecosystem's reports: choice sets cap around 255 options per question, so giant taxonomies decompose into staged questions rather than one mega-choice.

The soft edges (real, manageable, ignorable at your peril)

Verdicts are only as good as questions. The single biggest source of "Jev is inaccurate" reports we can trace is vague questions getting vague answers. "Is this good?" flips coins for any model; the fix is craft, and the craft is learnable. Budget real time for it; it's most of the work.

Nondeterminism. The same input can occasionally draw a different verdict across runs, which matters enormously in some places (reproducible datasets, compliance) and not at all in others (routing a ticket). Mitigations: sharper questions, confidence thresholds, caching verdicts, and keeping semantic judgments out of anything that must replay identically, per the warnings in the database-queries piece.

Hard cases exist, and it will meet them confidently. Sarcasm, deep context, adversarial text crafted to mislead classifiers. The design answer is never "trust the small model harder"; it's the escalation tier, which is how the fraud build reported 96/100 instead of 85. If you deploy without a low-confidence path, you built the limitation yourself.

Inherited model biases. Fluency bias, position bias, instruction bleed: the judge-pattern failure modes apply here because Jev is the judge pattern productized. Test for them deliberately; the probes are listed in the question guide.

The launch-week caveats (temporary, but real today)

No official public benchmarks. Every number on this site is builder-reported with receipts; consistent, credible, not lab-audited. Anyone quoting precise Jev benchmarks in September 2026 is improvising.

Pricing, limits, and terms can move. Launch-period infrastructure changes fast; docs.typesafe.ai outranks any third-party snapshot, including ours, and long-term contracts on week-one terms deserve your lawyer's eyebrow.

Ecosystem youth. Integrations are gists and enthusiasm right now. Charming, productive, and not yet boring, and boring is what production eventually wants.

The meta-limitation

The most expensive failure mode isn't any item above; it's treating a decision model like a discount chat model. Teams that internalize the constraint (frame everything as closed questions, cascade the hard slice, verify before trusting per the getting-started ritual) report the numbers that fill this directory. Teams that don't, write the disappointed threads. Same model.

Frequently asked questions

What can't Jev do?

Generate text, hold conversations, or perform open-ended reasoning; it exclusively answers constrained questions. Within that lane, its practical limits are question quality, occasional nondeterminism, and hard cases that belong to an escalation tier.

Does Jev hallucinate?

Not in the essay-inventing sense, since it can't compose prose, but it can return confidently wrong verdicts, especially on vague questions or adversarial input. Closed answers shrink the hallucination surface; they don't repeal it.

Is Jev accurate enough for production?

As the fast tier of a cascade with confidence gating: reported results say yes, repeatedly. As a lone oracle on high-stakes calls with no escalation: no week-one model earns that, and the architecture exists so none has to.

Will these limitations change?

The hard walls are the product thesis and likely permanent; the launch-week caveats (benchmarks, ecosystem, pricing stability) are the ones time fixes. We update this page as the catalog teaches us otherwise; that's the whole point of keeping receipts.