Jev API Tutorial: Judge Any X (Twitter) Account with TypeSafe's Jev for $0.0001

TL;DR (key facts, measured 2026-09-21)

• Jev is TypeSafe AI's first public System One model. It returns typed judgments with probabilities, not generated text.
• Jev API endpoint: POST https://api.typesafe.ai/v1/systemone, model id jev-latest (served as jev-1.13.0).
• Jev API pricing: $42 per billion input tokens (TypeSafe's published rate). Our 7-question verdict used 1,813 tokens = $0.000076.
• Latency: 0.31 s for 7 judgments on ~20 posts.
• Data source: AIsa Twitter API, GET /apis/v1/twitter/user/last_tweets, $0.00522 per call.
• Demo: jev-court.vercel.app. Source: one dependency-free Python file.

Try it first: jev-court.vercel.app. Type a handle. A judge reads the account's recent posts and prints a verdict receipt: how much substance, how much clickbait, shilling, engagement bait and humblebrag. Then it stamps a persona on you.

I ran it on myself. The ruling: 71% likely a repeat offender: Humblebrag. Persona: Builder, confidence 1.00. Fair.

The judge is Jev, TypeSafe AI's new "System One" model. The evidence comes from the AIsa Twitter API. The whole thing is one Python file with no dependencies. This post is the build log, with real numbers.

What is Jev in AI? TypeSafe Jev explained

Jev is TypeSafe AI's System One model, released in September 2026: a decision model that takes application state plus typed questions and returns calibrated probabilities instead of text. It is not a chat model and not an LLM in the usual sense. Jev is a model that does not write text. You send it some state and a list of typed questions. It sends back typed answers with probabilities. No prose, no JSON-mode coaxing, no output parsing. TypeSafe calls this a System One model: fast judgment, not slow reasoning.

It has three question types:

That is the entire API surface. One endpoint: POST https://api.typesafe.ai/v1/systemone.

Jev vs LLM: why not just prompt a chat model?

You could ask a chat model "is this account clickbait? answer in JSON". Three things go wrong at scale:

1. You parse. Sometimes the JSON is wrapped in prose. Sometimes a field is missing.
2. You get a word, not a number. "Somewhat clickbaity" cannot be thresholded.
3. You pay for output tokens and wait for them.

Jev returns 0.73. Your code decides what 0.73 means. In our app that policy is one line: a charge at or above 0.5 becomes the headline verdict, otherwise "Insufficient evidence. Free to go."

The roast lines on the receipt are not generated either. They are nine hand-written strings keyed by persona. There is no text generation anywhere in this product.

Step 1: get the posts (one AIsa call)

Jev has no browser. It needs something to look at. AIsa is one API key for 950+ data APIs, X included.

curl "https://api.aisa.one/apis/v1/twitter/user/last_tweets?userName=jack" \
  -H "Authorization: Bearer $AISA_API_KEY"

You get about 20 recent posts with text, author and engagement counts. We drop retweets, trim each post to 400 characters, and keep the rest. Quoted price on our plan: $0.00522 per call.

Step 2: ask Jev seven questions in one request

All posts go in as state. All seven questions go in one request, so they run in parallel and cannot see each other's answers.

{
  "model": "jev-latest",
  "state": { "posts": ["...", "..."] },
  "questions": {
    "substance": {
      "type": "score",
      "instructions": "How much concrete, usable substance is in the posts in `posts`?",
      "criteria": [
        "Almost none: reactions, vibes, slogans with nothing a reader could use.",
        "Thin: mostly opinions or restated headlines, with an occasional specific.",
        "Solid: regularly gives numbers, methods, code, sources, or first-hand detail.",
        "Dense: most posts teach something a reader could act on or verify."
      ]
    },
    "clickbait": {
      "type": "noul",
      "instructions": "Is inflated, clickbait framing a recurring pattern in the posts in `posts`?",
      "criteria": { "true": "Frequent 'game changer', 'this changes everything' framing.",
                    "false": "Language is mostly plain and sized to the evidence." }
    },
    "archetype": {
      "type": "choice",
      "instructions": "Which single description best fits the account behind these posts?",
      "criteria": { "builder": "Ships things and posts working detail.",
                    "prophet": "Makes grand predictions about the future.",
                    "salesperson": "Everything leads back to something for sale." }
    }
  }
}

The full set adds shill, engagement_bait, humblebrag, ai_written, and six more personas. Two rules from TypeSafe's docs shaped how we wrote them:

• Rubric levels describe concrete situations, not adjectives. Each level has to stand on its own, so "most posts teach something a reader could verify" rather than "high".
• One narrow judgment per question. Clickbait and shilling are separate nouls because an account can be guilty of one and not the other. Code combines them later.

Step 3: print the receipt

The response is already the data model:

{ "answers": {
    "substance": { "type": "score", "score": 1.95 },
    "humblebrag": { "type": "noul", "noul": 0.71 },
    "archetype": { "type": "choice", "choice": "builder", "confidence": 1.0 } },
  "usage": { "input_tokens": 1813 } }

The front end turns probabilities into bars, the top charge into a headline, and the persona into a red stamp. The receipt format is a joke with a point: the last line item is what the trial cost.

What it costs, measured

One real lookup of a 17-post account:

At TypeSafe's published $42 per billion input tokens, judging 1,000 accounts costs about 8 cents of inference. The data is the larger line: about $5.22 for the same 1,000. Both round to nothing next to a chat model doing the same job with a paragraph of output each time.

Latency tells the same story. Jev is never the slow part. Fetching the evidence is. Cache verdicts per handle and repeat lookups are free and instant.

Where Jev was unsure, and why that is the feature

• We pointed the court at TypeSafe's own account. Persona: Corporate, confidence 0.38. It would not commit on its own maker.
• In an earlier experiment on mixed-language posts, confidence on Japanese text often sat between 0.3 and 0.7, while clear English posts came back at 0.96 to 1.00. Small sample, but it matches what others report: Jev is stronger in English today.

In both cases the model did not bluff. It returned a low number, and a low number is something code can route. "Zero hallucination" is marketing. "Tells you when it does not know" is what we actually observed.

What else this pattern builds

Same skeleton: AIsa fetches, Jev judges, code decides.

• Mention triage: classify every post about your product as question, complaint, lead or noise, and send low-confidence ones to a human.
• Lead spotting: a noul for buying intent over posts that mention your competitors.
• Feed filters: score substance across X, Reddit and YouTube, keep the top decile.
• Research screens: a noul per topic you track, across news and filings.

AIsa serves all of those sources behind the same key.

FAQ

What is Jev in AI? Jev is TypeSafe AI's first public System One model, released in September 2026. It answers typed questions (noul, choice, score) about state you provide and returns probabilities instead of generated text. It is unrelated to the YouTuber FaZe Jev and to the JEV (Japanese encephalitis) vaccine.

What is TypeSafe Jev used for? Decisions inside software: classification, routing, ranking, extraction checks and verification, where code needs a number it can threshold rather than a paragraph.

How do I get a Jev API key? Create an account at console.typesafe.ai and generate a key. Set it as TYPESAFE_API_KEY and call POST https://api.typesafe.ai/v1/systemone with a Bearer header.

Is Jev a replacement for GPT or Claude? No. It does not write, plan or explain. It replaces the classify-route-verify steps where a chat model is slow, costly and needs parsing. Use both.

How much does the Jev API cost? TypeSafe lists $42 per billion input tokens (about $0.042 per million). Our seven-question verdict used 1,813 input tokens, about $0.00008. Judging 1,000 accounts costs roughly 8 cents of Jev inference.

How do I give Jev live X (Twitter) data? Fetch it first. We use the AIsa Twitter API: GET https://api.aisa.one/apis/v1/twitter/user/last_tweets?userName=... with a Bearer key ($0.00522 per call), then pass the post text to Jev as state. The same AIsa key also covers X search, Reddit, YouTube, news and filings.

Is there a cheaper alternative to the official X API for AI agents? For read-only research, yes. AIsa's Twitter endpoints are pay-per-call with no monthly tier, so a prototype like this one costs cents rather than a subscription.

Does the court read private data or post on my behalf? No. It reads recent public posts only. There is no login and nothing is posted. It judges writing style, never identity or views.

Build your own

1. Get an AIsa key at aisa.one. One key covers X and 950+ other data APIs.
2. Get a Jev key at console.typesafe.ai.
3. Two HTTP calls, as above. Put the policy in your code, not in a prompt.

Then go find out what the judge thinks of you: jev-court.vercel.app.

Sources

• TypeSafe AI, System One and Jev docs, API reference
• AIsa, Twitter user last tweets endpoint
• Live demo and code: jev-court.vercel.app

---

Numbers are from live runs on 2026-09-21 with jev-1.13.0 and will vary. Jev cost covers input tokens at TypeSafe's published rate. Verdicts are model output about writing style, shown for fun, and are not statements of fact about any person.