New capability

Anoman Decision Models

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.

Concept

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.

Use cases

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.

API

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.

Agents

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.

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"]

Clients

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.

# 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?" } }
  }'

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

Data handling & residency

US routing. Unlike the rest of the Anoman gateway (single-region Jakarta), 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.

API reference Back to docs