Jev AI

Jev AI · Hosted API access

Jev API for classification, routing and scoring

Send text and typed questions to Jev AI and get structured decisions back as JSON. Copy the setup prompt into your coding agent, create a key, then verify the connection.

Create API keyView API pricing

API calls use the Token account first. Model multipliers apply; insufficient tokens switch the whole call to the model’s credit charge. Output tokens are free.

Jev AI is an independent service. Use a Jev AI key with the TypeSafe-compatible /api/v1/systemone endpoint.

Evaluating alternatives? Compare Jev with OpenJev, Djev, Laya and Semif.

1

Start here

Copy a prompt for your coding agent

Paste this into the agent working on your app. It covers updating an existing official TypeSafe SDK client, setting the Jev AI base URL and key, and checking the connection before inference.

Integrate Jev AI into this project. Inspect the existing code and read https://jev-ai.pro/docs first, especially #official-sdk for setup and #errors for failure handling.

Connection details: base URL https://jev-ai.pro/api; decision endpoint POST https://jev-ai.pro/api/v1/systemone; header "Authorization: Bearer $JEV_AI_API_KEY" with a key created at https://jev-ai.pro/jev-api; default model jev-latest.

If using TypeSafe's official SDK (@typesafe-ai/sdk), reuse the existing client and explicitly set baseURL to https://jev-ai.pro/api with a Jev AI key. Changing only the key is not enough. TypeSafe publishes the SDK; Jev AI provides the compatible endpoint.

Keep JEV_AI_API_KEY server-side; never put it in browser code, logs, commits or chat. Tell me where to configure it locally and in deployment.

Follow the docs for request/response formats, retries and model limits. Start with jev-latest, verify the actual destination, and check GET https://jev-ai.pro/api/v1/models without inference. Then show me how to make one small decision call using my balance.

Next, create a Jev AI key below and add it where your agent tells you. The prompt asks the agent to keep the key on the server.

2

Your Jev API keys

Create a key for this integration. Store it in your app's server environment as JEV_AI_API_KEY; never paste it into your agent chat. First key? Read the step-by-step Jev API key guide.

Sign in to create a key. Welcome and check-in credits pay for web requests and API fallback. Purchased tokens pay for API input usage.

3

Your first API call

  1. Sign in and create a key above.
  2. Run this minimal example in a Bash or Zsh terminal. Enter your key at the hidden prompt. The request uses your balance under the billing rules below.
  3. Look for an answers object, then check your connection here.

Working with a coding agent or the TypeSafe SDK? Copy the setup prompt and let it configure the base URL and key for you.

Compare API plans
{
printf 'Paste your API key, then press Enter (input is hidden): '
read -rs JEV_AI_API_KEY
printf '\n'
export JEV_AI_API_KEY
curl --fail-with-body https://jev-ai.pro/api/v1/systemone \
  -H "Authorization: Bearer $JEV_AI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"state":"My payment failed. Please help.","questions":{"urgent":{"type":"noul","instructions":"Does this message need urgent support?"}}}'
unset JEV_AI_API_KEY
}

API calls use tokens first, then the model’s credit charge if tokens are insufficient. Output tokens are free. Creating a key and checking status do not run the model.

Endpoint

POST https://jev-ai.pro/api/v1/systemone
Authorization: Bearer <JEV_AI_API_KEY>
Content-Type: application/json

Request

curl https://jev-ai.pro/api/v1/systemone \
  -H "Authorization: Bearer $JEV_AI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Help! My payouts have been failing for 3 days.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "Does this convey urgency?" },
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": { "billing": "Payments and refunds", "technical": "Bugs and outages", "sales": "Pricing" }
      },
      "frustration": {
        "type": "score",
        "instructions": "How frustrated is the customer?",
        "criteria": ["Calm", "Frustrated", "Very angry"]
      }
    }
  }'

Response

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 0.95 },
    "department": {
      "type": "choice", "choice": "billing", "confidence": 0.98,
      "probabilities": { "billing": 0.99, "technical": 0.01, "sales": 0.0 }
    },
    "frustration": {
      "type": "score", "score": 1.04, "confidence": 0.94,
      "legend": { "0": "Calm", "1": "Frustrated", "2": "Very angry" },
      "probabilities": { "0": 0.0, "1": 0.96, "2": 0.04 }
    }
  },
  "usage": { "input_tokens": 379, "output_tokens": 70 }
}

Every answer comes back under the question id you chose. Choice and score answers include probabilities and a confidence between 0 and 1; a noul answer is the probability of yes.

TypeSafe Official SDK

@typesafe-ai/sdk is published by TypeSafe. Jev AI is an independent service that provides a compatible hosted API endpoint; this SDK is not published by Jev AI.

Already using the official TypeSafe SDK? Set both the Jev AI key and the base URL. Changing only the key leaves requests going to the SDK's default TypeSafe service. Jev AI keys and balances are separate from TypeSafe's.

For JavaScript / TypeScript, set baseURL: 'https://jev-ai.pro/api'. The SDK adds /v1/systemone, so do not include /v1 or the full request path in the base URL. The final request must reach https://jev-ai.pro/api/v1/systemone.

// Official TypeSafe SDK, published by TypeSafe — @typesafe-ai/sdk 0.6.0
// Server-side JavaScript / TypeScript using the Jev AI compatible endpoint
import { TypeSafeClient, choice } from '@typesafe-ai/sdk'

const apiKey = process.env.JEV_AI_API_KEY
if (!apiKey) throw new Error('Set JEV_AI_API_KEY on your server')

const client = new TypeSafeClient({
  apiKey,
  baseURL: 'https://jev-ai.pro/api', // Required, including for existing SDK users
  retry: { maxRetries: 0 }, // Avoid replaying a request with an uncertain outcome
})

// The SDK appends /v1/systemone to baseURL.
const response = await client.systemOne({
  model: 'jev-latest',
  state: { document: 'I was charged twice. Please fix this ASAP.' },
  questions: {
    category: choice('What is this ticket about?', { billing: null, technical: null, other: null }),
  },
})
console.log(response.answers.category.choice)

The example disables automatic retries to avoid replaying a request whose outcome is uncertain. Before making a decision call that uses your balance, follow the TypeSafe SDK connection checklist.

Tested with @typesafe-ai/sdk 0.6.0. GET /api/v1/models lists the model names and GET /api/v1/credits returns creditsRemaining and paidInputTokensRemaining. Legacy credit fields remain available for compatibility.

Call a saved judge

The editor defaults to Official format: full state, model and questions, portable between Jev AI and TypeSafe by changing the endpoint and key. Choose Saved judge ID for the Jev AI-only shortcut below; TypeSafe does not resolve these IDs.

Create and manage your judges, then open one and choose API code for a ready-to-copy example. Use an API key from the same account.

POST /api/v1/systemone
{
  "judgeId": "YOUR_SAVED_JUDGE_ID",
  "revision": 1,
  "state": "New text to evaluate"
}

Send judgeId instead of questions. Each call uses the saved rules with your new state; the response and token billing are the same as a normal API call.

revision is optional. Include it to reject calls with HTTP 409 after the rules change; omit it to always use the latest saved version. Response headers X-Jev-Judge-Id and X-Jev-Judge-Revision identify the rules used. Deleted or inaccessible judges return HTTP 404.

Live web context

Jev does not browse. POST /api/v1/web-context searches the web for your yes/no question, puts the results into Jev state as evidence and returns Jev's answer with and without that evidence. Try it in the browser first.

POST https://jev-ai.pro/api/v1/web-context
Authorization: Bearer <JEV_AI_API_KEY>
Content-Type: application/json

{
  "question": "Has OpenAI released GPT-6?",
  "query": "OpenAI releases GPT-6 announcement",
  "criteria": {
    "yes": "OpenAI has publicly released a model named GPT-6",
    "no": "No model named GPT-6 has been released"
  },
  "num_results": 6,
  "attribution": false
}
{
  "decision": "yes",
  "confidence": 0.88,
  "with_web": { "answer": { "type": "choice", "choice": "yes", "probabilities": { "yes": 0.88, "no": 0.12 }, "confidence": 0.88 }, "usage": { ... } },
  "without_web": { "answer": { "type": "choice", "choice": "no", ... }, "usage": { ... } },
  "sources": [{ "title": "...", "url": "https://...", "publishedDate": "2026-09-10T00:00:00.000Z", "highlights": ["..."] }],
  "source_weights": null,
  "usage": { "input_tokens": 2140, "output_tokens": 12, "jev_calls": 2, "web_search": true },
  "latency": { "search_ms": 560, "jev_ms": 410 }
}

Only question is required. query defaults to the question and criteria to a generic yes/no rule. num_results takes 1 to 10 (default 6). Set attribution: true to get source_weights: how much the winning probability drops when each source is removed. It reruns Jev once per source, so it bills those input tokens too.

To bring your own evidence, send sources (up to 10 objects with title, url, publishedDate and highlights). No search runs and no search fee is charged.

Billing: actual input tokens across all Jev calls, plus 170,000 tokens for each web search. If tokens are insufficient, the request costs 2 credits (1 credit with your own sources). Failed requests are not charged.

Compare Jev with other decision models

Still choosing a model? Review API access, hosting options and benchmark context before you integrate.

  • JevBench results — the independent leaderboard these comparisons quote, and how to read it.
  • Jev vs Imajev-4B — compare hosted Jev with an open 4B model that also reads photos.
  • Jev vs decider-4b — compare hosted Jev with a fast open Qwen3.5-4B rebuild.
  • Jev vs JevK5 — compare hosted Jev with an open-weight Qwen3.5-4B alternative.
  • Jev vs Cygnet — compare hosted Jev with frozen Gemma 4 12B, now first on JevBench.
  • Jev vs Winnow — compare hosted Jev with a local model that also chats and reads images.
  • Jev vs OpenJev — compare hosted Jev access with the OpenJev projects and self-hosting options.
  • Jev vs Djev — compare decision-model capabilities and integration options.
  • Jev vs Laya — review model differences and benchmark context.
  • Jev vs Semif — review model differences and deployment options.
  • Jev vs LLM — how a decision model differs from a chat LLM and a BERT classifier.
  • Run Jev locally? — open-source status and the self-hosted alternatives in one table.

These guides compare decision models. Laya Beta can use this same endpoint when listed by GET /api/v1/models; other compared models are not offered by this endpoint.

Models, limits and billing

Explore Laya English and Multilingual · Laya API request and limits. Both use your Jev AI key and the endpoint above.

Mercury Decide, Inception’s decision model, also runs on this endpoint: set model to mercury-decide. It accepts up to 32,768 tokens per request and is billed like Jev. Mercury Decide API reference.

GPT-6 Luna, the model behind OpenAI’s Decisions API, runs here too: set model to gpt-6-luna. It reads text, JSON and up to 4 embedded images and is billed at its model rate. GPT-6 Luna API reference.

Set model to laya-english or laya-multilingual for Laya Beta. Omitting it keeps jev-latest. This also applies when using a saved judgeId.

Laya accepts 512 total tokens per question for English and 1,024 for Multilingual, including your state, instructions, labels and framing. Each label has a 48-token limit and the combined question and labels have an additional checkpoint-specific budget. Oversized input returns 422 without a charge; input is never silently truncated. Usage counts the input sequence for each question, including repeated state. Existing account billing applies, with zero output tokens.

Modelsjev-latest, jev-preview, jev-1.13.0, laya-english, laya-multilingual, mercury-decide, clef, clef-flash, gpt-6-luna (Jev aliases resolve to jev-1.13.0; Laya Beta, Mercury Decide and GPT-6 Luna require a configured connection. Check GET /api/v1/models for availability.)
Question typesnoul (yes/no), choice, score · up to 64 per request
InputA string, JSON object or array; Clef and GPT-6 Luna also take up to 4 embedded images · request body up to 256 KB · Jev model context 64k tokens; Mercury Decide 32,768 tokens; Laya limits above
Question limitsUp to 255 options per Choice and 10 levels per Score for Jev. Jev state plus the longest question must fit within 32k tokens. Laya uses the stricter limits above.
PriceAPI calls deduct input tokens × the selected model’s multiplier; output tokens are free. Insufficient tokens switch the whole call to that model’s credit charge. Web tools prefer credits, then token billing. See the model rates on the pricing page.
BalanceGET /api/v1/credits returns the credit and token balances separately. X-Jev-Billing is tokens, credits, credits-fallback or tokens-fallback. X-Jev-Credits-Charged and X-Jev-Paid-Input-Tokens-Used report this call’s cost. X-Jev-Tokens-Remaining reports available tokens. Requests are temporarily reserved before execution and settle against actual input usage. If neither account can cover the request, it fails with 402 and no charge.
Rate limit1,000 requests per minute per account; 429 with Retry-After when Jev is busy.
Errors401 bad key · 402 no credits · 422 invalid request · 429 slow down · 502/504 upstream failure (not billed)