A typed-decision model — powered by JEV / TypeSafe "System One" — that answers narrow yes/no, choice, and rating questions with calibrated probabilities. Not a chat model: no free text, no hallucinated output shapes.

What are Decision Models?

Decision Models are typed-decision judges, not chat models — they generate no free text at all.

You send the content to judge as state, plus a set of typed questions you want answered about it, and the model returns typed answers with calibrated probabilities for each one, in a single parallel pass. It cannot return anything outside the schema you asked for — there is no free-text field to hallucinate into.

noul — Yes/no judgment. A 0–1 probability answering a boolean-ish question (e.g. "is this urgent?"). No confidence field — the probability is the confidence.
choice — Pick one of N labels. Classifies into one of your labelled options and returns a probability distribution over all of them, so you can see how close the runner-up was.
score — Rate on an ordered scale. Places the content on an ordered scale you define (2–10 levels), with a probability distribution across levels — good for severity, sentiment, or quality ratings.

Versus a chat model: Decision Models are fast (typically sub-second), billed on input tokens only (output is free), and deterministic in output shape. A chat model is billed on input and output, generates prose, and can drift outside a requested format — Decision Models can't.

Every decision model, priced

jev-latest, jev-preview, and version-pinned releases like jev-1.13.0 are release channels for the same typed-decision API, all billed the same way — input tokens only, output is free.

This is a snapshot — for the live catalog and full comparison against chat models, see the AI Models Directory.

Typical use cases

Decision Models are strongest on narrow, decomposed, high-volume judgments — not open-ended generation. Common patterns:

Ticket and intent routing — classify an inbound message into a team or workflow branch.
Content and severity classification — flag risky, sensitive, or policy-relevant content.
Scoring an LLM's own output — rate a chat completion's quality, tone, or groundedness before showing it to a user.
Agent tool-call risk gating — decide whether a proposed tool call needs human approval.
PII and sensitivity classification — a pre-check before content reaches a downstream system.
A cheap pre-filter in front of an expensive chat model — only pay for the big model on the requests that need it.

Best practice: decompose one fuzzy judgment ("is this ticket okay to auto-close?") into several narrow typed questions, and confidence-gate the routing on the returned probabilities rather than trusting a single answer blindly.

The decisions endpoint — `POST /anoman/v1/decisions`

One endpoint. Request mirrors JEV's native shape {model, state, questions}, response mirrors JEV's native shape {answers, usage} wrapped in the standard Anoman envelope.

Request

curl https://api.anoman.io/anoman/v1/decisions \
  -H "Authorization: Bearer anm-sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Customer: My invoice charged me twice this month and I need this fixed today.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Is this ticket urgent and time-sensitive?"
      },
      "category": {
        "type": "choice",
        "instructions": "Which team should this ticket route to?",
        "criteria": {
          "billing": "Billing",
          "technical": "Technical issue",
          "account": "Account access"
        }
      },
      "tone": {
        "type": "score",
        "instructions": "Rate the customer's tone.",
        "criteria": ["Very negative", "Negative", "Neutral", "Positive", "Very positive"]
      }
    }
  }'

Response — 200 OK

{
  "data": {
    "model": "jev-1.13.0",
    "answers": {
      "is_urgent": { "type": "noul", "noul": 0.94 },
      "category": {
        "type": "choice",
        "choice": "billing",
        "confidence": 0.91,
        "probabilities": { "billing": 0.91, "technical": 0.06, "account": 0.03 }
      },
      "tone": {
        "type": "score",
        "score": 0.18,
        "confidence": 0.77,
        "probabilities": { "Very negative": 0.31, "Negative": 0.46, "Neutral": 0.17, "Positive": 0.05, "Very positive": 0.01 }
      }
    },
    "usage": { "input_tokens": 142, "output_tokens": 0 }
  },
  "error": null,
  "meta": { "request_id": "req_...", "timestamp": "2026-09-22T10:00:00Z", "region": "id" }
}

Error codes

HTTP	Error code	Meaning
401	`auth_invalid`	Missing or invalid API key.
402	`token_quota_exceeded / insufficient_balance`	Your account's funding for this call — signup credit, a pass token bucket, the Pro allowance pool, or top-up balance — is exhausted.
422	`invalid_request`	The request violates a schema limit: empty questions, too many questions, an out-of-range criteria list, or an oversized body.
429	`rate_limit_exceeded`	Your per-key rate limit or concurrent request cap was hit.
502	`provider_error`	JEV returned an error, or returned a 200 with a malformed answer shape Anoman couldn't parse.
503	`decisions_unavailable`	Decision Models are temporarily unavailable (feature flag off, provider timeout, or the cost breaker is open).

This is an Anoman-native endpoint. It does not accept chat messages and is not reachable via /v1/chat/completions.

Integrating with AI agents

Call the decisions endpoint as a routing or guard step in an agent's control flow: send the content the agent is about to act on as state, ask a routing question, then branch on the returned choice and confidence before letting the agent proceed.

Python (httpx)

import httpx
 
async def route_ticket(ticket_text: str) -> str:
    async with httpx.AsyncClient(timeout=10) as client:
        resp = await client.post(
            "https://api.anoman.io/anoman/v1/decisions",
            headers={
                "Authorization": "Bearer anm-sk-...",
                "Content-Type": "application/json",
            },
            json={
                "model": "jev-latest",
                "state": ticket_text,
                "questions": {
                    "route": {
                        "type": "choice",
                        "instructions": "Which team should handle this ticket?",
                        "criteria": {
                            "billing": "Billing",
                            "eng": "Engineering",
                            "cs": "General support",
                        },
                    }
                },
            },
        )
        resp.raise_for_status()
        answer = resp.json()["data"]["answers"]["route"]
 
    # Confidence-gate the routing decision before acting on it.
    if answer["confidence"] < 0.6:
        return "escalate_to_human"
    return answer["choice"]

TypeScript (fetch)

async function routeTicket(ticketText: string): Promise<string> {
  const res = await fetch("https://api.anoman.io/anoman/v1/decisions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.ANOMAN_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "jev-latest",
      state: ticketText,
      questions: {
        route: {
          type: "choice",
          instructions: "Which team should handle this ticket?",
          criteria: { billing: "Billing", eng: "Engineering", cs: "General support" },
        },
      },
    }),
  });
  const { data } = await res.json();
  const answer = data.answers.route;
 
  // Confidence-gate the routing decision before acting on it.
  return answer.confidence < 0.6 ? "escalate_to_human" : answer.choice;
}

Integrating with common AI clients

Decisions is an Anoman-native endpoint, not an OpenAI-compatible chat endpoint — call it directly over HTTP with your language's standard client rather than an OpenAI or Anthropic chat SDK.

cURL

# Direct HTTP call — decisions is Anoman-native, not chat-shaped.
curl https://api.anoman.io/anoman/v1/decisions \
  -H "Authorization: Bearer anm-sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "...",
    "questions": { "is_spam": { "type": "noul", "instructions": "Is this spam?" } }
  }'

Python (httpx)

import httpx
 
resp = httpx.post(
    "https://api.anoman.io/anoman/v1/decisions",
    headers={"Authorization": "Bearer anm-sk-..."},
    json={
        "model": "jev-latest",
        "state": "...",
        "questions": {"is_spam": {"type": "noul", "instructions": "Is this spam?"}},
    },
)
print(resp.json()["data"]["answers"])

TypeScript (fetch)

const res = await fetch("https://api.anoman.io/anoman/v1/decisions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ANOMAN_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "jev-latest",
    state: "...",
    questions: { is_spam: { type: "noul", instructions: "Is this spam?" } },
  }),
});
const { data } = await res.json();

OpenAI and Anthropic chat SDKs do not apply here. There is no chat-completions shim for decisions — this mirrors how OpenRouter exposes JEV on its own separate decisions endpoint rather than through /chat/completions. Use a plain HTTP client (curl, httpx, fetch, or your language's equivalent) as shown above.

For wiring an agent's HTTP layer (auth headers, base URL, retries), see the AI agent integration guides — the same API key and Bearer-token pattern applies to the decisions endpoint.

Data handling & residency

US routing. Unlike our Jakarta-hosted gateway, Decision Models route your request to JEV's API in the United States. If your content must stay in-region, do not send it to this endpoint.

Only state is redacted. PII detected in state is masked before it leaves Anoman. Your questions/instructions are sent to JEV exactly as authored and are not scanned or redacted — do not put secrets or sensitive identifiers in your question text.

Decisions are probabilistic. Every answer is a calibrated probability, not a certainty. Review important decisions before acting on them, especially where the returned confidence is low.

Try Decision Models

Full request and response schemas, plus every Anoman endpoint, live in the API reference.

Anoman Decision Models