Jev playground

Why the state matters more than the question

Each scenario keeps one question fixed and gives you a few states to swap between. That is the whole exercise, and the useful surprise is that Jev is usually not hesitant. Running the release-note question over six drafts, every answer landed at 85–93% or 7–27%; none came back near a coin flip. So "wait for it to say 50%" is the wrong thing to watch for.

What to watch for instead is a confident answer you disagree with. In that scenario the interesting one is the release note that only changed the text of an error message: Jev puts it around 26%, and if your callers match on message strings, you would call it breaking. That disagreement is the signal. It means the question, as written, is not asking what you meant, and the fix is in the criteria rather than the threshold.

The ticket scenario shows the other half of the same lesson. It includes a none option. Delete that one line and re-run the thank-you note: with nowhere to put it, Jev files it as technical at 87%, confidently and wrongly. Put the option back and it goes to none at 100%, while a real ticket is scored the same either way. A Choice can only pick from what you offer it, so leaving out the escape hatch does not produce an uncertain answer — it produces a wrong, certain one.

On a Choice the winning option is also the least interesting number on the screen; the gap between first and second is what you would actually gate on. See choosing a threshold for turning that into a rule.

Can you call the Jev API from a browser?

This is the question we expected first, so here is the whole answer. TypeSafe's own API works fine — it just refuses to be called from a web page, and that is deliberate on their side.

Browsers enforce a rule called CORS: before a page may send a request carrying an Authorization header to another origin, it asks that origin for permission with an OPTIONS preflight, and refuses to send the real request unless the answer allows both the origin and every header. We ran that preflight againstapi.typesafe.ai from several origins on 2026-09-20:

$ curl -X OPTIONS https://api.typesafe.ai/v1/systemone \
    -H "Origin: https://mrjev.com" \
    -H "Access-Control-Request-Method: POST"

HTTP/2 400
vary: Origin
Disallowed CORS origin

Every origin we tried got the same answer, including TypeSafe's own: console.typesafe.ai,typesafe.ai, docs.typesafe.ai and localhost. So it is not an allowlist we happen to be missing from — no browser origin is accepted at all. The request itself is fine: the same call from a server, with no Origin header, gets a normal 403 authentication_error asking for a key.

That is a reasonable decision. Allowing browser origins would invite people to put an API key into client-side code, where anyone can read it. It does mean a browser-only playground cannot offer the direct API, and any playground that does offer it — including the ones you may have seen — is relaying your key through a server of its own.

Vercel AI Gateway: the request has to be written by hand

Vercel's AI Gateway is the opposite case, and it took us three tries to get right. It answers a preflight and reflects any origin, so the origin is not the problem. One header is: its own SDK sendsai-evaluation-model-specification-version: 4 on every evaluation call, and that header is missing from the gateway's access-control-allow-headers list, which does include the language-model, image-model and embedding-model versions of the same thing. Call it through the SDK from a browser and the request is blocked before it leaves.

Writing the request yourself avoids it, and we checked with a real key that the gateway does not need that header at all. These four are enough, and all four are on the allow-list:

authorization: Bearer …
content-type: application/json
ai-gateway-protocol-version: 0.0.1
ai-model-id: typesafe-ai/jev

With and without the missing header the gateway returned the same answer to the same question — 0.92 and 0.93 on two runs, which is ordinary run-to-run movement. So the blocker is the SDK's header set, not the gateway, and this page talks to it directly.

Two differences worth knowing if you build the same thing: the gateway takes the model in a header while OpenRouter takes it in the body, and it calls a Noul a boolean with the answer in probability rather than noul. It reports usage in camelCase and returns no cost, so the figure here falls back to list price. Confidence, where there is one, arrives in providerMetadata.typesafe.confidence.

What this Jev playground sends, and where

• To the provider you picked: the state and questions in the editor, with your key as a bearer header. Nothing else.
• To mrjev.com: nothing. The site is static assets on a CDN; there is no endpoint here to receive a request.
• Kept in your browser: one key per provider, in localStorage, until you press Forget. Neither is ever sent anywhere but its own provider.

We hold the tools we review to this standard in the roundup's data-flow table, so it would be odd not to state it for our own page.

Other Jev playgrounds

This one asks for a key because it has no server; that is the whole design, and it is a real cost to you. If you would rather click and go, these do that, and we would rather point at them than pretend otherwise:

• TypeSafe's own console playground — the official one, with walkthroughs for each of the three question types. Needs a TypeSafe account.
• jevplayground.com andaijev.net — free to try with no signup and no key, because they run the call on a server of their own and pay for it. Rate limits apply. Your state goes to them as well as to TypeSafe.
• tryjev — open source, bring your own key, and the only one of these that will take a TypeSafe key directly, again because it has a server.

The trade is the same every time: somebody's server, or your own key. There is no third option for the direct API, for the reason above.

Credit

The swap-the-state-and-watch idea comes from sugarforever/tryjev(MIT), a hosted Jev playground that adds the direct TypeSafe API by running a server of its own. If you want to use a TypeSafe key, that is where to go. The scenarios, the code and the wording here are ours.

Prices shown per run come from the provider's own usage.cost when it returns one, and otherwise from Jev's list price of $0.042 per million input tokens. The figures quoted above are our own, measured through OpenRouter against typesafe/jev-1.13 on 2026-09-20; repeated runs, and the same questions through Vercel's gateway, moved them by a point or two.