How to Use Jev API with APIMaster

What Jev does

Jev is a decision model from TypeSafe's System One family. It is useful when your application needs to classify, rank, verify, or route something and the answer should fit a schema you define in advance.

Instead of asking for free-form text, you describe the decisions in questions:

• Noul: a yes/no judgment with a probability
• Choice: one option selected from a list, with probabilities for the options
• Score: a rating against levels that you define

That makes Jev a good fit for moderation gates, intent classification, browser actions, routing, extraction, and agent checks. Keep arithmetic, dates, counting, and text generation in application code or a generative model. Jev decides; another component can write the response.

Call Jev through APIMaster

1. Create an APIMaster key

Create an account at APIMaster, add pay-as-you-go credit, and create a key in API Keys. Store the key as an environment variable:

export APIMASTER_API_KEY="your_api_key"

2. Send a first request

The APIMaster Jev route keeps Jev's native System One request shape. Do not send messages, prompt, or an OpenAI chat-completions payload.

curl -X POST "https://apimaster.ai/v1/systemone" \
  -H "Authorization: Bearer $APIMASTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "A user says: I was charged twice for the same order.",
    "questions": {
      "intent": {
        "type": "choice",
        "criteria": {
          "billing_issue": "Charges, refunds, invoices, or payments.",
          "technical_issue": "Bugs, outages, or integration problems.",
          "general_question": "All other general support questions."
        },
        "instructions": "Choose the user's primary support intent."
      },
      "needs_human": {
        "type": "noul",
        "instructions": "Should a human support agent review this case?"
      }
    }
  }'

The response contains an answer for each question, including the selected value and probability data. Use a threshold in your code before taking an irreversible action. For example, route to an automatic flow only when intent confidence is above the threshold your team has validated.

3. Use the response in Python

import os
import requests

response = requests.post(
    "https://apimaster.ai/systemone",
    headers={
        "Authorization": f"Bearer {os.environ['APIMASTER_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "jev-latest",
        "state": {"message": "The checkout page crashes after I upload a receipt."},
        "questions": {
            "category": {
                "type": "choice",
                "criteria": {
                    "bug": "A technical fault or product error.",
                    "billing": "A charge, refund, invoice, or payment issue.",
                    "account": "Account access, identity, or settings."
                },
                "instructions": "Classify the support request.",
            },
            "urgent": {
                "type": "noul",
                "instructions": "Does the request require urgent handling?",
            },
        },
    },
    timeout=30,
)
response.raise_for_status()
result = response.json()
print(result)

The same APIMaster key can be used for Jev and the generative models your application calls after the decision. That is useful for a two-step flow: let Jev classify or route first, then send only the selected cases to a text model.

A practical routing pattern

Jev is most useful as a control layer around a generative model. A typical request flow is:

1. Put the relevant user input or document fields into state.
2. Ask several small questions in one request instead of making one request per question.
3. Check the returned probabilities in application code.
4. Choose a queue, tool, model, or fallback based on your thresholds.
5. Call a generative model only when your application needs text, code, or a long-form answer.

For example, a support application can use Jev to identify intent, urgency, and whether an account lookup is needed in one call. It can then route the ticket to a human, fetch the right account data, or call a text model to draft the reply.

This division is different from asking an LLM to return JSON and hoping it follows the schema. Jev's output types are part of the request contract. It also means you should not use Jev for tasks that require writing the final response.

Jev versus a chat model

Need	Use Jev	Use a generative model
Choose one label from a known set	Yes	Usually unnecessary
Estimate whether a condition is true	Yes	Possible, but harder to constrain
Route a request to a tool or model	Yes	Possible, but more expensive
Summarize a document	No	Yes
Write a user-facing answer	No	Yes
Perform arithmetic or exact counting	Keep it in code	Keep it in code

For the model's architecture, limits, and published use cases, see Jev API: what it is and when to use it. For a direct comparison with LLM-based judging, see Jev vs LLMs.

Common integration mistakes

Sending a chat payload. https://apimaster.ai/v1/systemone expects state and questions, not messages and temperature.

Expecting text output. Jev returns typed decisions. Use a generative model for the final explanation or reply.

Making one request for every question. Put related questions in the same request so the model can evaluate them against one shared state.

Treating confidence as a guarantee. A probability is a signal for routing and review. Validate thresholds on your own examples before using them for production decisions.

Pointing Claude Code or Codex directly at Jev. Those tools expect Anthropic Messages or OpenAI Responses-compatible model behavior. Jev is better placed in a skill, hook, MCP tool, or router. See How to use Jev with Claude Code and Codex for working patterns.

FAQ

Is Jev available through APIMaster?

Yes. Use jev-latest with POST https://apimaster.ai/v1/systemone. The live marketplace card currently shows one active route at $0.042 per 1M input tokens, with no output charge.

Is the Jev endpoint OpenAI-compatible?

No. APIMaster exposes Jev's native System One contract for this model. Use state and typed questions; do not use /chat/completions.

Can Jev generate a summary or answer?

No. Jev returns typed decisions and probabilities. Pass the result to a generative model when your application needs text.

Can I use the same APIMaster key for other models?

Yes. One APIMaster key can call Jev and the other models enabled for your account. Check each marketplace card for the current model ID, route, and price.

Where should I start?

Start with the request above, collect representative examples, and validate your thresholds before adding Jev to an automatic action. Then read the full Jev API guide and the Claude Code/Codex integration guide.

Create an APIMaster account, add credit, create a key in API Keys, and call jev-latest through https://apimaster.ai/v1/systemone.