How to use a Jev LLM classifier on Qwen3 with Simple Jev

TypeSafe AI shipped Jev in September 2026: a model that takes context and returns typed decisions with confidence scores instead of text, priced at $0.042 per million input tokens with free output, and claiming answers in 70 to 500 milliseconds. The weights are closed. Simple Jev is our open-source implementation of the same interface, served on Featherless, with the Qwen3.8-27B and Qwen3.6-35B-A3B classifiers as the ones to start with. You send shared context and a set of questions, the server reads the model’s next-token scores for the allowed answer labels, and your code gets back JSON with a choice, a confidence and a probability distribution. There is no classifier head to train and no JSON to parse.

The fastest way to see it work is one curl against the public demo API, which needs no login and no API key. The same request body then goes to https://api.featherless.ai/v1/classifier with your key when you want production limits. Nothing changes between the two except the URL and a header.

Your first request, no API key

The demo lists its available models at /v1/models; the two Qwen classifiers are the ones to use, and this guide runs on featherless-ai/Qwen3.8-27B-classifier. Start there, then send one question about one line of context. Every example below was run against the live demo on 2026-09-22, and the responses shown are what came back, with the decimals shortened.

curl https://simple-jev-demo-api.featherless.ai/v1/models

curl https://simple-jev-demo-api.featherless.ai/v1/classifier \
  -H 'Content-Type: application/json' \
  --data-binary @- <<'JSON'
{
  "model": "featherless-ai/Qwen3.8-27B-classifier",
  "state": "Mia owns a red bicycle.",
  "questions": {
    "color": {
      "type": "choice",
      "instructions": "What color is Mia's bicycle?",
      "criteria": {"red": null, "blue": null}
    }
  }
}
JSON

The answer comes back under answers, keyed by the question ID you chose, with the token count the request used:

{
  "model": "featherless-ai/Qwen3.8-27B-classifier",
  "answers": {
    "color": {
      "type": "choice",
      "choice": "red",
      "confidence": 0.99992,
      "probabilities": {"red": 0.99992, "blue": 0.00008}
    }
  },
  "usage": {"input_tokens": 203, "output_tokens": 1}
}

That took about 1.6 seconds end to end from a browser. The demo is capped at a 2k-token context and four requests a second, and it takes text only. The context budget includes the classifier instructions, your questions and criteria, and the model’s chat formatting, so short inputs and a focused question set work best. If you would rather not open a terminal, the playground runs the same call behind an editor, and its support triage, review analysis and moderation scenarios are ready-made multi-question requests you can edit.

Route, score and judge in one request

Every question has a type, an instructions string and type-specific criteria, and several questions can share one context. A support ticket is the natural example, and it uses all three types:

curl https://simple-jev-demo-api.featherless.ai/v1/classifier \
  -H 'Content-Type: application/json' \
  --data-binary @- <<'JSON'
{
  "model": "featherless-ai/Qwen3.8-27B-classifier",
  "state": {
    "ticket": "I was charged twice for my subscription this month. Please refund the duplicate charge today.",
    "plan": "Pro"
  },
  "questions": {
    "route": {
      "type": "choice",
      "instructions": "Which team should handle this message?",
      "criteria": {
        "billing": "Payments and refunds",
        "technical": "Bugs and outages",
        "account": null
      }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is this request?",
      "criteria": ["Routine", "Important", "Critical"]
    },
    "refund": {
      "type": "noul",
      "instructions": "Does the customer explicitly request a refund?",
      "criteria": {
        "true": "The customer asks for money back.",
        "false": "There is no explicit refund request."
      }
    }
  }
}
JSON

Qwen3.8-27B answered all three in one round trip of about 2.5 seconds:

{
  "model": "featherless-ai/Qwen3.8-27B-classifier",
  "answers": {
    "route": {
      "type": "choice",
      "choice": "billing",
      "confidence": 0.9999,
      "probabilities": {"billing": 0.9999, "technical": 0.00003, "account": 0.0001}
    },
    "urgency": {
      "type": "score",
      "score": 1.43,
      "confidence": 0.56,
      "probabilities": {"0": 0.008, "1": 0.557, "2": 0.434},
      "legend": {"0": "Routine", "1": "Important", "2": "Critical"}
    },
    "refund": {"type": "noul", "noul": 0.98}
  },
  "usage": {"input_tokens": 434, "output_tokens": 3}
}

choice takes two to 50 named candidates, each with an optional description, and returns the highest-probability candidate as choice, its probability as confidence, and the distribution over all candidates. Here billing won with 99.99%. Descriptions are worth writing: “Payments and refunds” tells the model what billing means far better than the label alone.

score takes two to 50 ordered rubric levels and returns the expected zero-based index, which is why urgency came back as 1.43 rather than a whole number. The model put 56% on Important and 43% on Critical, and 0 × 0.008 + 1 × 0.557 + 2 × 0.434 works out to 1.43, a little past Important on the way to Critical. A three-level rubric returns a value between 0 and 2, which surprises anyone expecting 0 to 1 or 0 to 100. confidence here is the largest single level probability rather than an interval, and 0.56 is the model telling you this was a close call.

noul judges a yes/no proposition and returns one value between 0.01 and 0.99; the refund question came back at 0.98. It is not a softmax between “true” and “false” tokens; in v1 the model scores nine rating bins and the server maps their expected value into that range. Pick your action threshold on representative data rather than assuming 0.5. The request reference has every field, and the choice, score and noul sections show the response shape for each.

Bring the whole conversation, or an image

state can be a string, an object or an array, and structured JSON is serialised as data rather than executed, which is why the ticket above could carry a plan field. For a conversation, replace state with messages. The server renders the turns through the model’s own chat template and asks your questions about the whole exchange rather than the last line:

curl https://simple-jev-demo-api.featherless.ai/v1/classifier \
  -H 'Content-Type: application/json' \
  --data-binary @- <<'JSON'
{
  "model": "featherless-ai/Qwen3.8-27B-classifier",
  "messages": [
    {"role": "user", "content": "I was charged twice."},
    {"role": "assistant", "content": "Would you like the duplicate charge refunded?"},
    {"role": "user", "content": "Yes, please."}
  ],
  "questions": {
    "refund": {"type": "noul", "instructions": "Does the customer want a refund?"}
  }
}
JSON

The last message on its own is “Yes, please.”, which says nothing about refunds. Read as a conversation, the answer came back at "noul": 0.988 on 356 input tokens.

Images work on the production endpoint with both Qwen classifiers, which is what the vision demo uses to sort a food catalogue four images at a time; the public demo is text only. The chat-context docs cover roles and limits, and the demos page has the rest: a driving simulator choosing steering and speed in real time, a 2048 player and a bookmark sorter, all running against the same API.

What the model is doing

This is zero-shot classification, which means you never train anything: the options arrive with the request and the model picks from them on the spot. The trick is in how it picks. A chatbot answers by writing one token at a time, and at every step it holds a score for every token it could write next. Simple Jev turns your question into a multiple-choice question, labels the options A, B and C, and stops the model at the exact spot where the answer letter would go. Instead of letting it write, the server reads the scores for A, B and C at that spot and ignores every other token.

Those scores become percentages that add up to 100 across your options. A score of 3 for A and 1 for B comes out at about 88% and 12%, and that is the confidence and probabilities in the response. The urgency answer above is the same thing with three options: 0.8% Routine, 55.7% Important, 43.4% Critical. Nothing gets written, so there is nothing to pay for on the output side: output is billed at $0, and the one output token per question in usage is a marker rather than generated text.

Two things follow. First, the percentages are only about the options you offered. Add a fourth option and every number moves, and 88% means “A beat B clearly”, not “A is right 88% of the time”. Second, when you ask several questions about the same context, the model reads the context once and answers each question from that one reading. Four questions about a 1,000-token context, each adding 50 tokens of its own, cost about 1,200 tokens of processing instead of 4,200. The how it works page shows the exact prompt with a slider for the scores, and the v1 prompt specification pins down every rule so a result means the same thing on every implementation.

Which Qwen classifier to run it on

Two Qwen classifiers are live on Featherless in beta, and both are on the public demo. Prices are per million input tokens from the Featherless pricing docs on 2026-09-21, context is from each model’s page on 2026-09-22, and output is billed at $0 on both.

The Qwen classifiers have been the most reliable in our testing, and every example in this guide ran on Qwen3.8-27B. The two differ mainly in shape. Qwen3.8-27B is a 27B-parameter model at $0.30 per million input tokens. Qwen3.6-35B-A3B is a mixture-of-experts model with about 3B parameters active per token at $0.28, and its $0.032 cached-input rate is the lowest on the platform’s classifier list. Use 27B when the decisions are hard or the rubrics are fine-grained, and try 35B-A3B when volume is high and the prompt prefix repeats.

No accuracy benchmark for either is published yet, so the ranking that matters is the one you get by running 50 to 100 of your own labelled examples through both and comparing. The 32K context on each model page is the ceiling for context plus questions in production, against 2k on the demo. Best open-source LLMs in 2026 covers how to build that labelled set and read the results.

Move the same request to production

Production is the same body sent to https://api.featherless.ai/v1/classifier with Content-Type: application/json and an Authorization: Bearer YOUR_API_KEY header. Simple Jev models are in beta on the Developer plan, which is $50 of credits a month, billed per token with unused credits rolling over. Register, create a key on the API keys page, and the Python below classifies the conversation from earlier with nothing but the standard library:

import json
import os
import urllib.request

payload = {
    "model": "featherless-ai/Qwen3.8-27B-classifier",
    "messages": [
        {"role": "user", "content": "I was charged twice."},
        {"role": "assistant", "content": "Would you like the duplicate charge refunded?"},
        {"role": "user", "content": "Yes, please."},
    ],
    "questions": {
        "refund": {"type": "noul", "instructions": "Does the customer want a refund?"}
    },
}
request = urllib.request.Request(
    "https://api.featherless.ai/v1/classifier",
    data=json.dumps(payload).encode("utf-8"),
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {os.environ['FEATHERLESS_API_KEY']}",
    },
)
with urllib.request.urlopen(request, timeout=45) as response:
    result = json.load(response)
print(result["answers"]["refund"]["noul"])

Completion settings such as temperature, max_tokens and stream do nothing here and are ignored. Unknown fields inside a question are rejected with a 4xx error that names the problem, and a 429 carries Retry-After when the limiter has one; the errors section lists the shapes. The demo runs on shared beta capacity: one of our test requests got a 429 reading Insufficient capacity available, and the same request went through two seconds later, so retry with a short pause before assuming anything is wrong.

The three-question ticket above used 434 input tokens, so call a typical ticket 500. A support queue that classifies 100,000 tickets a day at that size sends 1.5 billion tokens a month: $420 on Qwen3.6-35B-A3B and $450 on Qwen3.8-27B. Cached-input rates apply when a request repeats a long prefix the platform has recently served, and a fixed question set puts the same system instruction and briefing at the front of every call, so both rows may come down in practice; at Qwen3.6’s $0.032 cached rate the saving would be large if it applies. Tokenomics 101 covers measuring your own cache-hit rate before you count on that. Prices may change after the beta.

Simple Jev FAQ

Do I need an API key to try Simple Jev? No. The public demo at simple-jev-demo-api.featherless.ai takes requests with no login, key or Authorization header, within a 2k-token context and four requests a second. Production on api.featherless.ai needs a Featherless key.

Which models can Simple Jev run on? featherless-ai/Qwen3.8-27B-classifier and featherless-ai/Qwen3.6-35B-A3B-classifier, both on the public demo and in production, both with image support in production. Self-hosted, any Transformers model with a chat template whose answer labels tokenise to one token each.

Can an LLM be used as a classifier? Yes, and it needs no training to start. Give the model the candidate labels in the prompt, stop it at the answer position, and read the logits for those labels. Simple Jev packages that as an HTTP endpoint with three answer types.

Is Simple Jev the same as Jev? No. Jev is TypeSafe AI’s closed, purpose-trained model. Simple Jev reproduces the interface (context and questions in, typed decisions with confidence out) on top of existing open models. The repository states that it does not reproduce TypeSafe’s architecture or training, and does not claim equivalent accuracy, calibration or speed.

What does Simple Jev cost on Featherless? $0.28 per million input tokens on Qwen3.6-35B-A3B and $0.30 on Qwen3.8-27B, with output at $0, paid from the Developer plan’s $50 of monthly credits. These are beta prices; the pricing docs have the current row.

Is this zero-shot classification? Yes. Nothing is trained on your labels; the model scores them from the prompt. RFDT is for the cases where zero-shot is not accurate enough and you fine-tune on your own decisions.

TypeSafe built a decision model whose weights you cannot download. Simple Jev is the same interface on open models you can pick, served on Featherless with one curl to try and one header to go to production. Send the ticket request above to the demo on Qwen3.8-27B, move it to api.featherless.ai/v1/classifier on the Developer plan when it works.

Last updated: September 21, 2026. Simple Jev is in beta; prices and model availability change. Re-check the pricing docs before committing.