Jev · a decision tool for software teams · Jev AI Model

Jev AI Model · Test the Jev model and build with its API

Jev handles classification, routing, scoring, and safety checks—give it state and get a result your code can use.

Clear output shapeMultiple questions at onceProbabilities included
One request, three decisions
jev-latest
Input state

Three deploys have failed and production is returning 500s. Should this be escalated to a person?

0.94

Intent

0.91

Confidence

typed

Output

Not a chat transcript—a usable result70–500ms

Online playground

Playground

Enter a real scenario, define typed questions, and inspect a typed decision with probabilities.

The playground is free with unlimited runs.

1. State

Give Jev the context shared by every question.

1/15

All questions share this context and are answered independently.

2. Questions

Define up to eight typed questions for the same state.

5 / 8

3. Run decision

Run the decision request.

Results

Click “Generate decisions” to see typed output with probabilities.

4. API request

Preview or copy the JSON shape to call the same endpoint from your app.

Results are returned in a structured format so you can connect them to your application logic.

Where it connects

The decisions were already hiding in your code

Jev handles the decision itself. Your product still decides which model to call, when to queue, and when to ask a person.

01

Route before you call

Assess task difficulty first, send simple requests to a faster model, and escalate only when needed.

02

Stop risky actions first

Check intent before a tool executes. Ask for confirmation around deletion, payment, or other sensitive actions.

03

Let signals sort the queue

Classify intent, urgency, and human-review needs together so tickets take the right path.

04

Keep facts in long sessions

Decide which tool results still matter and preserve source details when context is compressed.

From input to action

The connection is simple. Your business logic stays yours.

Jev does not ask you to rewrite your system. Separate state, questions, and the next action; the model only handles the decision in the middle.

01

Give it state

Use a ticket, message, form fields, or the structured context your agent already sees.

state = ticket.text
02

Ask the question

Describe the decision with choice, score, or noul. Ask multiple questions in one request.

questions = { intent, urgent }
03

Let code act

Use the result and its probability to queue, route, block, or request review. Your system keeps control.

if result.urgent: escalate()

Where it fits

Not chat. A decision inside your system.

The hardest product work is often not generating a paragraph. It is making small decisions many times a second without losing control.

A defined answer space

Define possible answers up front and pass the result into functions, workflows, and databases.

Many answers from one state

Classify, score, and answer yes-or-no questions together instead of chaining separate calls.

Know when it is unsure

Use probability or confidence to decide whether the system should continue automatically or ask a person.

Put the decision in code

Use it inside if, route, guardrail, and queue logic without another chat surface.

A clear integration path

A consistent request shape, explicit schemas, and manageable API keys take you from test to production.

Examples that lead somewhere

Start with question types and state inputs, then follow an SDK or REST example into your system.

Designed for developers

From first request to production

Understand Jev in the playground, create an API key, and connect a validated decision workflow to your product.

Explore API docs
REST-ready
Typed schema
Manageable API keys

What a request looks like

Drop the decision into an existing service

POST /v1/systemone
from typesafe_sdk import Choice, Noul

response = client.system_one(
    state=ticket,
    questions={
        "intent": Choice(criteria={...}),
        "needs_human": Noul(
            instructions="Does this need a person?"
        ),
    },
)

# response.answers["intent"].choice

Agent integration

Give your agent a typed decision layer

Install the Jev Agent Skill, configure one API key, and let your coding agent use typed decisions for routing, guardrails, verification, and completion checks.

Read the agent guide

Install the Skill

Add the public Jev Agent Skill to Codex, Claude Code, Cursor, or another compatible agent.

Configure once

Set a Jev AI Model API key and choose English or Simplified Chinese for the onboarding and examples.

Ask for a judgment

Give the agent a bounded question; Jev returns a choice, score, or yes probability that code can use.

Start with the Jev Agent Skill

English by default · Chinese supported

npx skills add jev-ai/jev-agent-skill

export JEV_API_KEY="sk_your_key_here"
export JEV_LANGUAGE="en-US"

The agent still keeps control

Jev judges the decision. Your agent, application permissions, deterministic rules, and human approvals still control the final action.

Documentation

Start with one decision

The docs follow the path developers actually take: understand the model, define questions, send state, and wire probabilities into code.

Open full docs

Quickstart

Create an account, prepare your first state and questions, and inspect the typed decision in the response.

Define questions

Use choice, score, and noul for classification, continuous scoring, and yes-or-no decisions. Ask multiple questions in one request.

Integrate

Create an API key, follow the SDK or REST example, and use probabilities and confidence to drive your application logic.

Know the boundaries

Jev currently accepts text, JSON objects, and arrays of text. Images, audio, and video are not supported yet; validate accuracy separately for non-English inputs.

Pricing

Jev AI Model turns unstructured state into typed decisions with probabilities for classification, routing, scoring, and safety checks. Choose monthly, yearly, or one-time access for your usage.

One-time plans do not auto-renew or require a long-term subscription; the $10, $100, and $1,000 tiers include credits that remain available after purchase.

Starter

$10

Validate one real workflow, from the playground to your first API call

  • 100,000 credits, no expiry
  • 1 workspace
  • 3 concurrent requests
  • Standard speed
  • Choice, score, and noul questions
  • Typed decision output
  • Probability and confidence results
  • Online playground
  • API key management
  • Email support
Recommended

Pro

$100

Connect classification, routing, and safety decisions to a production product

  • 1,000,000 credits, no expiry
  • Unlimited workspaces
  • 10 concurrent requests
  • Fast lane
  • Choice, score, and noul questions
  • Typed decision output
  • Parallel questions per request
  • API access
  • Usage and request history
  • Priority support

Enterprise

$1,000

For multiple workspaces, team collaboration, and custom production integrations, with 10% extra credits

  • 11,000,000 credits (10% extra included)
  • Everything in Pro
  • Unlimited concurrency
  • Dedicated fast lane
  • Team workspaces and collaboration
  • Custom integration support
  • Security and permission guidance
  • Dedicated support
  • Priority production processing
  • Product roadmap feedback

Questions, answered

A few quick answers before you start with Jev AI Model.

Bring your next AI idea to life.

Validate one decision first, then connect it to your workflow.