Workflow guide

Jev for Beginners: What It Does, Hands-On Tests, and Its Limits

Published: 2026-09-25

A summary of programmer Yupi's hands-on Jev review: the three question types, why Jev is fast, a 1,000-email test against DeepSeek V4.1 Flash, where a match-pairs game fell short, and the limits he lists. With a runnable request.

  1. Part 1

    A model that answers with a decision, not a paragraph

    Ask a chat model whether an email is urgent and it writes an analysis you then have to parse. Jev returns the answer as data, for example is_urgent with a noul of 0.95, which code can branch on directly. TypeSafe calls this a System One model, after Kahneman's fast, intuitive thinking. Yupi quotes TypeSafe's own comparison against models such as GPT-5.6: 70 to 500 ms instead of 3 to 329 s, $0.042 per million input tokens instead of $0.20 to $10, no charge for output, and a 0% structured-output error rate by construction. These are TypeSafe's published figures, not his measurements.

  2. Part 2

    Three question types

    A request carries a state (the context to judge) and questions. A Noul is a yes/no question that returns the probability of yes. A Choice picks one option from a set you define, up to 255 options, and returns the probability of every option plus confidence. A Score places the state on 2 to 10 ordered levels you describe and can land between them: with the levels calm, unhappy but polite, and very angry, a score of 1.04 sits between level 1 and level 2, leaning toward unhappy but polite. All three can be asked about the same state in one request. JEV Hub note: the request below mirrors the kind of email triage Yupi ran; his exact prompts were not published.

    {
      "model": "jev-latest",
      "state": {
        "from": "ops@customer.example",
        "subject": "Payouts failing since Monday",
        "body": "Our Stripe payouts have failed for three days and we are losing sales. Please look at this today."
      },
      "questions": {
        "priority": {
          "type": "score",
          "instructions": "How important is this email to handle?",
          "criteria": [
            "Can wait",
            "Normal",
            "High",
            "Critical"
          ]
        },
        "urgent": {
          "type": "noul",
          "instructions": "Does the sender need an answer today?"
        },
        "department": {
          "type": "choice",
          "instructions": "Which team should handle this email?",
          "criteria": {
            "billing": "Payments, invoices, refunds",
            "technical": "Bugs, outages, integrations",
            "sales": "Pricing, plans, new accounts",
            "other": null
          }
        }
      }
    }
  3. Part 3

    Why it is fast, and why the probabilities are usable

    Per Yupi's explanation of TypeSafe's design, a structured-output LLM still writes its answer token by token and then checks the format. Jev instead outputs a probability distribution over the options you defined, in parallel, so asking ten questions takes about as long as asking one, and there is no output text to pay for or to break. It is trained with RLCD, TypeSafe's calibrated-decision reinforcement learning, so that when it says 90% it is right about 90% of the time. That is what lets code act on thresholds, for example handle automatically above 0.8 and send to a person below 0.5.

  4. Part 4

    What his tests showed

    On a 4x4 sliding puzzle, Jev finished well ahead of DeepSeek V4.1 Flash while using fewer input tokens and less money. On 1,000 simulated emails, each classified for priority, urgency, and department, Jev took 15.6 s (about 64 emails per second, $0.0177 in total) and DeepSeek V4.1 Flash took 48.9 s (about 20 per second, $0.0207); Yupi describes Jev as nearly 2 times faster and slightly cheaper, and did not report accuracy. Through Codex with the TypeSafe skill, Jev tagged all 697 articles of his AI coding tutorial by topic, reader level, and difficulty in a few minutes. Every test together cost him less than 2 yuan.

  5. Part 5

    Where it fell short

    Playing a match-pairs game through Codex worked but disappointed him: at best one pair every 2 seconds, with frequent stalls, about 5 minutes for the board. Jev's decisions were fast; the slow part was perception. Jev reads text and JSON only, so the game worked because Codex could parse the page's DOM; a Canvas-rendered game would do worse if the DOM does not expose enough information, and community game demos convert the game state to structured data first. His conclusions: used directly inside an app (support triage, moderation, tagging) the experience is fast, cheap, and accurate; used indirectly through AI tools it still has a lot of room to improve. Jev cannot generate text, cannot do arithmetic reasoning, and is unreliable at comparing dates, and its accuracy depends on the quality of the structured input you give it.

  6. Part 6

    How to start

    Sign up with an email on TypeSafe's website, then either try the official Playground, create an API key in the TypeSafe console and call the API or the Python and JavaScript SDKs (pip install typesafe-sdk), or go through Vercel AI Gateway or Cloudflare Workers AI. To let a coding agent call Jev, install TypeSafe's skill. The official install prompt installs it for the current project only; Yupi's version installs it globally: in Claude Code run claude plugin marketplace add typesafe-ai/skills and then claude plugin install typesafe@typesafe-ai; in other agents run npx skills add typesafe-ai/skills --skill typesafe-ai -g. Set TYPESAFE_API_KEY and invoke /typesafe-ai or ask the agent to use Jev. JEV Hub note: paste the request above into the Jev Playground with your key to see real probabilities, or connect Claude Code, Cursor, or Codex through the Jev MCP server.

Related projects

  • @typesafe-ai/sdk — Official TypeScript/JavaScript client for POST https://api.typesafe.ai/v1/systemone.

← All guides · Jev Playground