How to use Jev when an AI is building your website

Every AI-built site is full of small judgments: which page does this keyword belong to, is this draft too thin to publish, did ChatGPT cite us or a competitor. Jev exists for exactly those judgments, and it never writes a word.

Claims on this page were last checked against the platform's own documentation on .

Run the free check

Jev is a decision model from TypeSafe AI, released in early access on 15 September 2026. Instead of generating text it returns one typed answer per question: a choice from a list, a score on a scale you define, or a yes-or-no probability, each with a confidence value. In a website build it belongs at the judgment points: assigning keywords to pages, gating thin drafts, choosing internal links, checking whether an AI answer cited your brand, and scoring whether a passage answers its question directly. The writing stays with a language model. The deciding moves to Jev.

What Jev is, and what it will never do for your website

Jev is the first model from TypeSafe AI, a San Francisco company founded in 2024, and according to the company’s own announcement it opened in early access on 15 September 2026. The company calls it a System One model, by which it means a model that makes fast structured decisions and produces no text.

The distinction matters more than it first appears. A language model, asked whether a page is thin, will write you three paragraphs, and your code then has to parse those paragraphs and hope the format held. Jev, asked the same question, returns a number between 0 and 1 and nothing else. TypeSafe’s documentation puts it plainly: the model does not generate text, write code, or hold a conversation, and there is no setting that turns Cursor or Claude Code into a Jev-powered agent.

So the truth is that Jev answers the hundreds of small yes-or-no and which-one questions that an AI-native build produces along the way, in a form your code can act on directly without reading prose, and according to the vendor it does so in well under a second. The building itself, the service pages, the titles and the structured data remain the work of a language model and of you.

According to the documentation there are exactly three kinds of question. A Choice picks one option from a list you supply, up to 255 options, and returns the pick, a probability for every option, and a confidence. A Score rates something against an ordered set of levels you describe, between 2 and 10 of them, and returns a weighted position on that scale plus the same probabilities and confidence. A Noul evaluates a yes-or-no statement and returns a single probability that the answer is yes.

Getting access and making the first call

Access is by waitlist during early access. Once approved, you create a key at console.typesafe.ai/keys and put it in an environment variable named TYPESAFE_API_KEY, which is how both official client libraries find it. A key here is the password your code presents when it sends a question.

The rest is a short list, taken from TypeSafe’s quick start and SDK pages.

  • Python 3.10 or newer: install with pip install typesafe-sdk, then import TypeSafeClient, Choice, Score and Noul from typesafe_sdk and call client.system_one with a state and a map of questions.
  • Node 20 or newer: install with npm install @typesafe-ai/sdk, then import TypeSafeClient and the choice, score and noul helpers and call client.systemOne.
  • Without a library, send a POST request to https://api.typesafe.ai/v1/systemone with an Authorization: Bearer header, a JSON body carrying model, state and questions, and read the answers map in the response. The documented error codes are 401 for a bad key, 422 for a body that failed validation, 429 for rate limiting and 529 for overload, the last two to be retried with a growing delay.
  • Use the model name jev-latest to start, then pin an exact version such as jev-1.13 once you have tuned any thresholds, because the documentation notes that jev-latest moves on each release and answers can shift. Every response reports which version answered, so log it.
  • If Claude Code is doing the building, install TypeSafe’s own skill so the agent knows the question types and patterns: claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe@typesafe-ai. For other agents the documented command is npx skills add typesafe-ai/skills --skill typesafe-ai.

Where it fits in an AI-native build

Here is the pattern, and it is the same one whether the site has 12 pages or 1,200. Your code collects the raw material: keywords, drafts, page pairs, AI answers. A cheap rule or a similarity check trims the list to plausible candidates. Jev answers one bounded question per candidate. Your code applies a confidence threshold and sorts the results into act, review, or discard. A language model is called only where something has to be written. A person checks before anything is published.

What changes, compared with the way most AI builders work today, is that the language model stops being asked to judge. It is asked to write, which is what it is good at, and the judging goes to a model built for judging. TypeSafe’s documentation describes the architectural idea as code-controlled AI with narrow decisions, and its patterns page lists the four shapes those decisions take: sending many questions in one call and letting code pick which matter, using confidence as a second axis for routing, breaking a complex judgment into atomic scores that code weighs, and classifying intent to route a request.

The first of those, which the documentation calls speculative fan-out, is the one to learn first. Questions in one call are evaluated in parallel, so asking ten costs the input tokens for ten but takes the time of one. TypeSafe’s own cookbook on parallel questions reports that batching 13 questions into a single call was 12.2 times cheaper and 10.0 times faster than asking them one at a time. That figure is the vendor’s measurement on the vendor’s example, and we have not reproduced it, but the direction is built into how the request works.

One consequence worth stating: the state you send should carry only what the decision needs. The documentation is explicit that accuracy falls as the state fills with unrelated material, so a keyword-to-page question should receive the keyword and a short description of each candidate page, never the whole site.

Using Jev for SEO: the questions worth asking

These are the judgment points where a site built by AI most often goes wrong, and the question shape that fits each. Every one of them is a place where, today, either a person does it by hand or nobody does it at all.

  • Keyword to page assignment. State: the keyword plus a one-line summary of each candidate page. Question: a Choice across the page slugs, with an extra option for none of these. A low confidence on none of these is your content gap list.
  • Cannibalisation, meaning two of your pages competing for the same search. State: the titles, headings and first paragraph of a page pair. Question: a Noul, would these two pages satisfy the same search intent. Pairs above your threshold go to a merge or differentiate decision; the rest are left alone.
  • Internal links. State: a source paragraph and a candidate target page summary. Question: a Noul, would a reader of this paragraph be helped by a link to this page. Run it across the candidate pairs your similarity check produced, keep the high-probability ones, and let the language model write only the anchor sentence.
  • Thin-page gate before publishing. State: the draft. Question: a Score with levels you describe in words, for example says nothing a search result page does not, restates common knowledge, adds one specific fact or example, adds several with sources. Anything landing in the bottom two levels never reaches the build.
  • Title and description triage. State: the page’s question, its title and its description. Question: a Noul, does this title state the answer to the page’s question. Rewrite only what fails.

Using Jev for GEO: checking what the assistants said

Generative engine optimisation is the work of getting cited inside answers from ChatGPT, Perplexity, Gemini and Google’s AI Mode. The measurement problem is that the answers are prose, thousands of them, and reading them by hand does not scale. This is the clearest case for a decision model in the whole field.

Collect the answers with whatever tooling you use, then send each one to Jev as state, with the brand name and the competitor names in a named field, and ask a set of questions in one call. Is our brand recommended in this answer. Is it mentioned but only in passing. Which of these competitors is recommended, as a Choice with a none option. Does the answer cite a URL on our domain. Because the questions run in parallel, the whole set costs one round trip per answer.

The same idea works in reverse, for checking your own content before an assistant reads it. TypeSafe’s citation check cookbook uses a single Choice question, does this document section support, contradict, or say nothing about this claim, with automatic acceptance at a confidence of 0.8 and everything below sent to a person. On its own test of eight citations, four were verified at confidences between 0.93 and 0.99, one was found fabricated, one contradicted at 0.99, and two sat between 0.27 and 0.56 and went to review. Run that over every claim a language model wrote for your site and you have a fact-check step that costs a fraction of a cent per claim.

One more question belongs here, and it is the one we ask about every page we build. State: a passage. Question: a Score, could an assistant lift this passage and use it as an answer without editing, with levels from needs the rest of the page to make sense up to complete and self-contained. Passages that score low are rewritten before publication, because an assistant cites what it can lift.

Using Jev for AEO: does the page answer the question

Answer engine optimisation targets the classical features on a Google results page: the featured snippet, the People Also Ask box, the rich results. All of them reward a page that answers a specific question directly, near the top, in a form Google can extract. Whether a page does that is a judgment, and it is the kind of judgment Jev is built for.

Take the list of People Also Ask questions you gathered for a topic. For each one, a Choice across your page slugs tells you which page should own it, or that none does. Then, for each page and its owned question, a Score with levels such as never answers it, answers it after several paragraphs, answers it in the first paragraph but vaguely, and answers it in the first two sentences with a specific figure or name. Pages scoring in the top level are snippet candidates. The others get an opening paragraph rewritten, by a language model, to the specification the score revealed.

The question-and-answer blocks at the bottom of a page deserve the same treatment. For every pair, a Noul: does this answer resolve the question in its first sentence. Pairs that fail are the ones that will never appear in a People Also Ask box, and they are usually the ones an AI wrote in a hurry.

It must be said that none of this replaces knowing what the question is. Jev scores the fit between a question and an answer. Finding the questions, and having something true to say, remains the work described in the rest of this guide.

Reading the confidence number

Every Choice and Score answer carries a confidence from 0 to 1, and TypeSafe’s documentation describes it as the shape of the probability distribution collapsed into one number: concentrated on one outcome means confident, spread out means uncertain. For three options the documented formula is three times the largest probability, minus one, divided by two.

The guidance in the documentation is to gate different actions at different levels, according to what a wrong answer costs. Above 0.9 on a high-stakes action, act automatically. Below 0.5, do not act: route to a person, ask for clarification, or fall back to another method. The band between is where you flag for review or gather more information.

For a website build we would translate that as follows. Discarding a draft or merging two pages is expensive to get wrong, so hold it to a high bar and have a person confirm. Adding an internal link is cheap to reverse, so a lower bar is fine. And a flat distribution, where every option scored about the same, is usually telling you that your options or your level descriptions were badly written. The fix in that case is in your question.

What it gets wrong, in the vendor’s own words

TypeSafe publishes a page of known limitations for Jev 1.13, which is more candour than most model vendors offer, and every item on it touches something a site builder will try to do.

  • It reads literally. The documentation says it answers the question you wrote, not the one you meant, and that scoping words, negations and implied conditions are taken at face value. Write the condition out in full.
  • It does not count. Characters, occurrences of a term, items in a list: the error grows with the size of the thing counted. Count in code and pass the number in.
  • It reads dates as text. Which of two dates came first, how long between them, whether a date falls in a window: all documented as unreliable. Compute those in code too.
  • Unrelated material in the state lowers accuracy. Send only the paragraph the decision concerns, and for a page-level question only that page.
  • It does not treat the state as hostile. Text that contains instructions can sway an answer, so when you are scoring content scraped from elsewhere, including AI answers that quote other sites, be aware of that.
  • English is its primary training language. Other languages are accepted with lower accuracy, which matters for a bilingual site.
  • There is no guarantee that a question and its negation sum to one, or that two equivalent phrasings score the same. Pick one phrasing per decision and keep it fixed.

What it costs, and what to believe about the speed

The published price, from TypeSafe’s launch post, is 0.042 dollars per million input tokens with output free. A token here is the unit text is billed in, and a short draft plus a few questions is a few hundred of them. The same post states an end-to-end response time of 70 to 500 milliseconds and claims the model is 40 to 200 times faster than frontier language models on the tasks it was built for.

All of those figures are the vendor’s. We have seen no independent reproduction of the speed or accuracy claims as of the date this page was checked, and the launch post itself acknowledges that the workflows it measured sat at the higher end of real-world gains. Treat the price as published and the multipliers as marketing until you have measured them on your own site.

What we can say without measuring is arithmetic. At the published rate, a question set over a thousand drafts costs less than a dollar, which is a different order of magnitude from doing the same judgment with a frontier language model, and cheaper again than paying a person to do it. That is the reason to try it. Whether it earns a permanent place in your build is a question your own logs will answer within a week.

Part of a larger guide

This page is one part of Vibe coding SEO. The other parts:

Questions people ask

Can Jev build a website?
No. According to TypeSafe’s documentation, Jev does not generate text, write code, or hold a conversation, and it cannot replace the model behind Cursor, Claude Code or any other builder. It answers typed questions about material you send it: a choice from a list, a score on a scale you define, or a yes-or-no probability. The building and the writing stay with a language model; Jev handles the judgments along the way.
What is Jev used for in SEO?
The judgment points a site produces in bulk: assigning a keyword to the page that should own it, deciding whether two pages compete for the same search, choosing which internal links are worth adding, gating a draft that is too thin to publish, and sorting titles that answer their question from titles that are slogans. Each is one bounded question per item, answered with a probability your code can threshold.
How does Jev help with GEO and AI citations?
By reading AI answers at scale. Each collected answer from ChatGPT, Perplexity or Gemini becomes the state, and a batch of questions asks whether your brand is recommended, whether a competitor is, and whether your domain is cited, all in one call. The reverse also works: TypeSafe’s citation check recipe uses a Choice question to test whether a source supports each claim a language model wrote, accepting automatically at a confidence of 0.8 and sending the rest to a person.
How do I get access to Jev?
Through TypeSafe AI’s waitlist, which the company opened for early access on 15 September 2026. Once approved you create a key at console.typesafe.ai/keys, set it as TYPESAFE_API_KEY, and install either the Python library, typesafe-sdk, or the JavaScript one, @typesafe-ai/sdk. The raw endpoint is a POST to api.typesafe.ai/v1/systemone with the model name jev-latest.
What does Jev cost?
The published price in TypeSafe’s launch post is 0.042 dollars per million input tokens, with output free. Those are the vendor’s figures during early access and may change. At that rate a quality gate over a thousand drafts costs under a dollar, which is why the useful question is whether the judgments are good enough.
What are Jev’s limitations?
TypeSafe’s own limitations page for Jev 1.13 lists them: it reads instructions literally, including negations; it does not count reliably; it reads dates as text rather than ordered values; accuracy drops when the state contains unrelated material; it does not treat the state as hostile, so injected instructions can sway it; and English is its primary language. Count and compare dates in code, send only the material the decision needs, and write conditions out in full.
Should I trust the speed and accuracy claims?
Treat them as vendor claims until measured. The 70 to 500 millisecond response time and the 40 to 200 times speed multiplier come from TypeSafe’s launch post, which itself notes its measured workflows sat at the higher end of real-world gains. We have seen no independent reproduction as of the date this page was checked. The price is published and easy to verify on your own bill. The multipliers need your own measurement.

See what the assistants receive from your site today

The free Get Found Check reads your homepage the way a crawler does and grades it for Google and for AI answers in under a minute. Run it before you automate a single judgment, so you know which ones matter.

Run the free check Have Licheo do it for you