How to Install Jev: Every Setup Path, From No-Code Playground to a Claude Code Skill

There are four legitimate ways to install Jev, depending on whether you’re testing an idea, calling an API from a script, building a real integration, or wiring an AI coding agent to build it for you. This guide sorts you into the right lane and gives exact, working commands for each path.

If you haven’t decided whether Jev is the right tool yet, read what Jev and TypeSafe’s System One model actually do first. Otherwise, keep reading.

Which of the four ways to start with Jev is right for you?

Pick based on what you’re doing right now, not what you’ll eventually build. Testing an idea calls for the Playground, scripting a one-off calls for curl, shipping a feature calls for an SDK, and letting a coding agent build the integration calls for the skill.

The table below maps each situation to the setup path that fits it, with the time it takes once you already have an API key.

Every path shares one prerequisite: a TypeSafe account and an API key. That’s the next step regardless of which lane you’re in.

How do you create a TypeSafe account and get an API key?

Go to console.typesafe.ai, sign up with an email or SSO provider, and open the API Keys page to generate a key. As of testing on 22 September 2026, account creation had no waitlist and no approval step: you get a working key in the same session you sign up.

Step 1: Sign up or log in
Go to console.typesafe.ai and create an account. There is no invite code, no waitlist form, and no “request access” holding page. You land straight on the console home screen.

Step 2: Find the API key tile
From the console home, click the “API key” tile, or go directly to the API Keys page in the left navigation. Either route lands you in the same place.

Step 3: Create a key
Click “Create key,” name it something you’ll recognize later (for example, “local-dev” or “staging”), and copy the value immediately. TypeSafe keys start with sk- and are shown only once.

Step 4: Store it as an environment variable
Don’t paste the key into code. Export it so the SDKs and curl calls below can read it automatically.

export TYPESAFE_API_KEY="sk-..."   # bash/zsh

$env:TYPESAFE_API_KEY="sk-..."     # PowerShell

If you’re deciding how much this will cost before going further, the Jev pricing and access guide covers billing in detail; this post won’t repeat it. Account creation itself is free and instant, and you’ll need that key for every path below.

How do you test Jev with no code, in the Playground?

Open the Playground from the console, paste a block of text as your “state,” add a question, and click run. You’ll see a typed answer in seconds, with zero setup beyond having an account.

The Playground is built for exactly this: deciding whether Jev’s output is useful before you write a single line of integration code. Paste the situation you want evaluated (a support ticket, a transcript excerpt, a policy description) into the state field, then add one or more questions against it, choosing a question type: Noul, Choice, or Score.

Each question type asks something structurally different. A Noul question checks whether a statement is true of the state and returns a probability. A Choice question picks the best-fitting option from a list you supply. A Score question rates the state numerically against a rubric you describe. Click run and the result shows up immediately, no code involved.

This is the fastest way to sanity-check whether Jev’s typed outputs fit your workflow before you invest engineering time. For the deeper mechanics of when to use each question type, see the Choice, Score, and Noul primitives guide; this post is about getting installed, not about primitive design.

One limitation worth knowing before you get attached to a Playground result: the model picker here only offers two options, neither of which is a pinned version. More on that below, because it affects whether Playground results are exactly reproducible later.

How do you call Jev directly over HTTPS?

Send a POST request to https://api.typesafe.ai/v1/systemone with a bearer token and a JSON body containing your state and questions. This works from any language that can make an HTTP request, which makes it the right choice when you don’t want to add an SDK dependency.

Here’s a working curl example using the same structure the Playground uses under the hood.

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Customer emailed twice this week about a failed refund.",
    "model": "jev-latest",
    "questions": {
      "urgency": {"type": "noul", "instructions": "This conveys urgency"}
    }
  }'

The request body has three parts that matter. “state” is the plain-text situation you want evaluated. “model” tells Jev which build to run, covered below. “questions” is a dictionary where each key names a question and each value specifies its type (noul, choice, or score) plus instructions describing what to check.

This path is a reasonable permanent choice for a serverless function, a CI job, or anywhere adding a Python or Node dependency isn’t worth it for a handful of calls. For anything with more surface area than one endpoint, an SDK saves you boilerplate.

How do you install the Python or JavaScript SDK?

Install typesafe-sdk with pip (or uv) for Python, or @typesafe-ai/sdk with npm for JavaScript and TypeScript. Both SDKs read your TYPESAFE_API_KEY from the environment automatically, so you never hardcode a key in application code.

For Python:

pip install typesafe-sdk
# or: uv add typesafe-sdk

Once installed, the client picks up your exported key with no extra configuration:

from typesafe_sdk import TypeSafeClient, Noul

client = TypeSafeClient()   # reads TYPESAFE_API_KEY from env automatically
r = client.system_one(state="...", questions={"urgency": Noul(instructions="...")})

For JavaScript or TypeScript:

npm install @typesafe-ai/sdk

The JS SDK follows the same pattern: instantiate a client, call it with a state string and a questions object, and get back typed results instead of prose you have to parse yourself. That typed-output behavior is the whole premise of the product, covered in depth in the guide to Jev’s Choice, Score, and Noul question types.

This is the path most production integrations should take. It handles retries, request formatting, and response typing for you, and it’s the same client class you’ll use to pin a model version, covered next.

How do you install Jev as a Claude Code / coding-agent skill?

TypeSafe publishes an official, MIT-licensed agent skill at github.com/typesafe-ai/skills that teaches a coding agent the three question types and integration patterns, so you can describe what you want in plain English and let the agent write the integration. This is the genuine differentiator in this guide: almost nothing else written about Jev covers it, and it changes how you’d approach an integration if you already work inside Claude Code, Codex, or another skills.sh-compatible agent.

If you’re using Claude Code, install it through the plugin marketplace:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

Invoke it explicitly with:

/typesafe:typesafe-ai

Update it later with:

claude plugin marketplace update typesafe-ai && claude plugin update typesafe@typesafe-ai

If you’re using Codex or any other agent that supports the skills.sh convention, the install command is different but the source repo is the same:

npx skills add typesafe-ai/skills --skill typesafe-ai
# add -g for a global install instead of project-local
# update with: npx skills update

What does this buy you over reading the SDK docs yourself? The skill gives your agent working knowledge of Noul, Choice, and Score question design, common architectural patterns (routing, triage, confidence-gated automation), and evaluation best practices, so it doesn’t guess at how to structure a request. Once installed, you can hand your agent an instruction like “use TypeSafe to route incoming support tickets by department, with human review for uncertain decisions,” and it writes the client code, chooses the question types, and wires the confidence thresholds itself, instead of you looking up syntax and hand-writing the calls.

This matters most if you’re already doing agent-assisted development and would otherwise be pasting SDK documentation into a chat window to get the same result. The skill is the same information, packaged so the agent already has it.

Which model do you actually get: jev-latest, jev-preview, or a pinned version?

The console Playground’s model picker offers exactly two choices, jev-latest and jev-preview, and neither one is a fixed version. To pin a specific build for reproducible results, you have to do it in code, by passing a version string like jev-1.13.0 directly to the client.

This is worth being precise about because it’s a real gap between what the console shows and what the API actually supports, and it’s easy to miss if you only ever tested in the Playground. jev-latest points to the newest stable release. jev-preview points to whatever is next, which may be identical to jev-latest when no preview build is currently active. Both are aliases: what they resolve to can change without your code changing, which is fine for exploration and risky for anything you need to reproduce exactly six months from now.

If you’ve tuned a confidence threshold, a routing rule, or an evaluation rubric against one specific model build, pin it. You do this only in code, not in the console UI:

from typesafe_sdk import TypeSafeClient

client = TypeSafeClient(model="jev-1.13.0")

The same principle applies to the direct API call: set “model” in the JSON body to the exact version string instead of an alias. There is no equivalent toggle in the console today. If your workflow depends on stable, repeatable scoring, decide this early, because a Playground result you liked last week may come from a different underlying build than the one your production code is calling under jev-latest.

What do you do after you’re installed?

Once you have a key working, through the Playground, curl, an SDK, or an agent skill, the next real decision is which question type fits your first use case: a yes/no probability (Noul), a pick from a list (Choice), or a rating against a rubric (Score). That choice determines almost everything about how well your first integration performs.

Most teams get this wrong on the first try, not because the API is hard, but because they reach for a Score when a Choice would have been more precise, or the reverse. The guide to Jev’s Choice, Score, and Noul question types walks through when each one fits, with examples close to what L&D and training-ops teams actually build: routing, flagging, and scoring content or learner responses.

If your integration needs to talk to an existing LMS on the other end, two related guides are worth having open: the LMS API documentation guide for how training platforms expose their own APIs, and the LMS webhook integration guide for triggering a Jev call the moment something happens on the LMS side, rather than polling for it.

Conclusion

Every path here ends at the same API, so the real decision is how much code you want to write on the way there. Testing an idea, calling it directly, integrating it properly, and letting an agent build it are four doors into the same room.

Start with whichever lane matches what you’re doing today. If you’re not sure yet, open the Playground, paste in one real example from your own workflow, and see what comes back before installing anything.

Once you’ve picked a question type that fits, move on to the Choice, Score, and Noul primitives guide to design your first real request.