How to Get Jev API Access Today: Console, Vercel AI Gateway, and Swytchcode

If you've tried to get a Jev API key in the last three weeks, you may have hit one of three different pages: a signup form, a waitlist, or a notice that signups are paused.

All three were real. TypeSafe launched Jev on September 15, opened signups to everyone on September 20 with $5 of credit attached, and paused new signups two days later because demand outran capacity. Existing accounts kept working the whole time. The company has said it's working toward reopening, and the door has moved more than once since.

So "how do I get access" has a more useful answer than yes or no. There are three routes. Only one of them depends on TypeSafe's signup page being open, and that one isn't the fastest anyway.

This post covers all three, what each actually costs, the limits you're working inside, and a copy-paste test for each so you can confirm your access works before you build anything on it.

The short answer

Routes 2 and 3 are not alternatives to each other. Swytchcode needs a key that came from somewhere, so in practice many people pair route 2 with route 3: get the key from Vercel's gateway, hand it to Swytchcode, and never touch it again.

Route 1: Direct from TypeSafe

This is the raw API. You get a key, you call an endpoint, nothing sits in the middle.

1. Go to console.typesafe.ai and sign up. If you see a waitlist or a "signups paused" notice, skip to route 2 and come back later.
2. Create a key at console.typesafe.ai/keys.
3. Install the SDK and set the key:

pip install typesafe-sdk
export TYPESAFE_API_KEY=your_key_here

The Python SDK reads TYPESAFE_API_KEY from the environment. There's a JavaScript SDK too, and if you'd rather not use either, the endpoint is POST https://api.typesafe.ai/v1/systemone with the key as a bearer token.

New accounts have come with $5 of credit, which is a lot more than it sounds. At Jev's pricing that's roughly 119 million input tokens, or somewhere around 400,000 typical classification calls. You are unlikely to spend it while you're still deciding whether Jev is useful to you.

The honest caveat on this route: it's the one route that can simply be closed when you go to use it. If you're planning a project around Jev and you don't have an account yet, don't assume you'll be able to make one this afternoon.

Route 2: Vercel AI Gateway

Jev landed on Vercel's AI Gateway on September 16, the day after launch, and it has never had a waitlist. You need a Vercel account and nothing from TypeSafe.

The model ID is typesafe-ai/jev. Vercel's model page lists two providers behind that ID, TypeSafe AI and DigitalOcean, both at a 32K context window and $0.04 per million input tokens.

Every Vercel team gets $5 of free credit each month, and Jev usage draws from it. For evaluating Jev, or for a side project that makes a few thousand decisions a month, you may never pay anything.

There are three ways to call it. The AI SDK is the shortest:

import { experimental_evaluate as evaluate } from 'ai';

const res = await evaluate({
  model: 'typesafe-ai/jev',
  state: 'Tests pass after the fix.',
  questions: {
    keepGoing: { type: 'boolean', instructions: 'Continue with another step?' },
  },
});

const p = res.answers.keepGoing.probability;

One thing to watch: Vercel's changelog documents this as experimental_evaluate, while the gateway's model page shows experimental_decide. It's an experimental export, so the name is still moving. Check what your installed version of the ai package actually exports before you spend an hour on a wrong import.

You can also point TypeSafe's own client at the gateway, or call the gateway's HTTP endpoint directly. Usage is billed through Vercel on all three. The changelog has examples for each.

TypeSafe's own speed and cost comparison. These are vendor numbers from workflows TypeSafe wrote, so test on your own data. Source: typesafe.ai

Route 3: Through Swytchcode

The first two routes get you a key. This one decides where the key lives, and what happens after Jev answers.

Jev only decides. It reads text and returns a typed answer with a probability. It never calls Gmail, posts to Slack or issues a refund. Something still has to do that part, hold the credentials for it, avoid sending the same call twice, and keep a record of what ran. That's the half most Jev write-ups skip, and it's where agent bugs actually live.

Jev is in the Swytchcode integration directory, so both halves run through the same place:

npx swytchcode
swy login
swy init --mode=sandbox

swy get jev
swy auth connect jev    # paste your Jev API key when asked

swytchcode init asks which editor you use and whether to run in production or sandbox mode. Start in sandbox.

What swy auth connect jev does differently is where the key ends up. It goes into Swytchcode's local credential store at ~/.swytchcode/credentials.db, outside your project folder, and gets attached when a call runs. There's no TYPESAFE_API_KEY in a .env file, nothing secret in the repo, and no key sitting in a variable your model can read back to you. The CLI authentication docs cover the storage details.

From code, a Jev call then looks like every other call:

import { exec } from "@swytchcode/runtime";

// Find yours with: swy list methods jev
const JEV_METHOD = "<jev-method-id>";

const { answers } = await exec(JEV_METHOD, {
  body: {
    model: "jev-latest",
    state: emailText,
    questions: { is_urgent: { type: "noul", instructions: "This needs a reply today" } },
  },
});

And the action Jev's answer triggers is the same shape, against whichever app you connected:

await exec("gmail.user.modify.create", { params: { id }, body: { addLabelIds } });

Same runtime, same credential store, same policies, same audit log, for the decision and the action. If you want to see that end to end, our Gmail triage walkthrough builds a working agent with it, and the full Jev guide covers eight more use cases.

What you actually get

Access is one question. What you can do with it is another. These are the published numbers, and they're worth reading before you design around them.

A few consequences of those numbers.

The rate limits are generous but adjusted on the fly. TypeSafe has described them as being tuned dynamically during early access, so treat 80 requests per second as today's ceiling rather than a contract. Going over returns a 429, so handle it rather than assuming you'll never see one. Higher limits exist on enterprise plans with no published price.

Batch your questions. Billing is per request, not per question, and Jev answers every question in one pass anyway. Flavio Copes measured one call with 13 questions at $0.000497 against $0.006090 for the same 13 questions sent separately. That's roughly 12x cheaper for identical work. If there's a question you might need, ask it in the same call.

The two context numbers are different on purpose. You get 64k for everything combined, but no single question plus the state may exceed 32k. In practice this only bites if you're feeding Jev whole documents, and you usually shouldn't: for most jobs a few hundred tokens of the right text beats several thousand tokens of everything.

Output being free changes the arithmetic. A 300-token classification costs about $0.0000126. A million of them is roughly $12.60. The cost of thinking about whether to use Jev is higher than the cost of trying it.

Which route should you pick?

• Just want to try it today, and the console is shut? Vercel AI Gateway. No waitlist, $5 a month free, five minutes.
• Already building on Vercel? Gateway, for the same reason you use it for other models: one key, one bill.
• Want the raw API with nothing in between? TypeSafe console, when it's open.
• Jev's answer needs to cause something to happen in Gmail, Stripe, Slack or GitHub? Swytchcode, with a key from either of the above. The decision is the easy half.
• Need to run on your own hardware? None of these. Jev is closed and hosted, with no weights to download. Fastino's GLiDE and the open-weights GLiNER2.5-Decide are the places to look instead.

Check that your access actually works

Before building anything, confirm the key does what you think it does. Each route has a one-minute test.

TypeSafe direct:

curl -s https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "The customer says the integration has been failing for three days and they are losing sales.",
    "questions": { "is_urgent": { "type": "noul", "instructions": "The message conveys urgency" } }
  }'

A working key returns an answers.is_urgent.noul close to 1, plus a usage block with your input token count.

Vercel AI Gateway: run the evaluate snippet from route 2 with your gateway key set. If the import name throws, check your ai package version before anything else.

Swytchcode:

swy auth status     # jev should show as connected
swy doctor          # checks the whole project setup

Then run one real call with swy exec against the Jev method, and check it landed with swy audit network.

When access goes wrong

FAQ

Is there still a waitlist for Jev?

It depends on the day. TypeSafe opened signups to everyone on September 20, 2026 and paused new signups on September 22 because of demand, and the door has moved since. Check console.typesafe.ai for the current state. Vercel AI Gateway has never had a waitlist, so it's the reliable route when the console is closed.

Can I use Jev without a TypeSafe account?

Yes. Vercel AI Gateway serves typesafe-ai/jev with a Vercel account only, and bills through Vercel.

Is Jev free?

No, but it's cheap enough to feel free while you're testing. Input is $0.042 per million tokens and output costs nothing. New TypeSafe accounts have come with $5 of credit, and every Vercel team gets $5 of free credit monthly.

How much is a Jev API key?

The key itself is free. You pay for input tokens as you use them, with no published minimum or subscription on the standard plans.

What are Jev's rate limits?

80 requests per second and 100,000 tokens per second, tuned dynamically during early access, returning 429 when exceeded. Enterprise plans go higher.

How big can the state be?

64k tokens for state plus all questions, and 32k for state plus any single question. Shorter is usually better and always cheaper.

Do I need a Jev key if I use Swytchcode?

Yes. Swytchcode runs the call and stores the credential; it doesn't resell model access. Get a key from TypeSafe or Vercel, then swy auth connect jev once.

Where does Swytchcode put my key?

In its own local store at ~/.swytchcode/credentials.db, outside your project. Not in a .env file, not in your repo, and not anywhere your model can read it.

Can I self-host Jev?

No. It's a closed, hosted model with no published weights. For on-premises decision models, look at Fastino's GLiDE or the open-weights GLiNER2.5-Decide.

Wrapping up

The access story is messier than it should be, but only one of the three routes can actually be closed to you, and it isn't the fastest one. If you want to try Jev in the next ten minutes, use Vercel's gateway. If you want Jev's answers to turn into real API calls without putting keys in your code, add Swytchcode on top.

When you have a key, the Jev guide covers how the question types work and where Jev earns its place, and the Gmail triage build is a working agent you can copy. Or point your coding agent at our skills file and let it do the setup.