Decisions

Experimental. Decision model support is new and the questions response format is not yet stable. The request and response shapes documented here may change in a future release without a deprecation period.

Decision models evaluate content against questions instead of generating free-form text. Requesty supports Jev, built by Typesafe, Clef, built by Cloudflare, and the Perplexity decision model. A decision model evaluates a piece of content against a set of questions you define and returns a typed answer for each one, together with a probability distribution over the possible outcomes. That makes it a good fit for classification, moderation, sentiment analysis, grading and any other place where you want a calibrated score rather than prose. Call decision models through the Decisions endpoint, POST https://router.requesty.ai/v1/systemone. It is built for decisions: you send the content and your questions, and you get typed answers back as plain JSON. No messages to build, no answer string to parse.

Use the Decisions endpoint for new integrations. It is the only API that supports every decision model (openai/gpt-6-luna and azure/decision-1 only answer there), it accepts images on every model that can see them, and it returns refusals as a typed answer. Chat Completions, Messages and Responses still work for a few models, for tools that can only speak those APIs. See Other APIs.

Get your API key in the Requesty Console.

Want a decision model to pick which LLM answers each conversation? See Auto Routing.

Models

Model	Notes
`typesafe/jev-1.14.0`	Jev by Typesafe. Text only
`cloudflare/clef`	Cloudflare’s multimodal decision model. Also accepts images. `cloudflare/clef-flash` is the faster variant
`perplexity/pplx-decider-v1.1-27b`	Perplexity’s 27B decision model
`openai/gpt-6-luna`	OpenAI’s decision model. Also accepts images. Decisions endpoint only
`azure/decision-1`	Microsoft Decision-1 on Azure. Decisions endpoint only

GET /v1/models/decision returns the full, current list of models the Decisions endpoint serves.

How it works

A decision request has three fields:

model: a decision model id, with its provider prefix.
state: the content to evaluate, as a string.
questions: a map of question id to question definition.

The response has an answers object with one entry per question id. Every answer carries a type field matching the question type, or "refusal" when the model declines to answer that question, so check type before reading the value. Responses are not streamed.

Question types

Decision models support three question types. You can mix them freely in one request; each question is answered independently.

`noul`: yes / no

A noul question asks whether a statement about the content is true. The answer is a probability between 0.0 and 1.0.

{
  "positive": {
    "type": "noul",
    "instructions": "The review is positive."
  }
}

Answer:

{
  "positive": {
    "type": "noul",
    "noul": 0.98
  }
}

`choice`: pick one option

A choice question picks one of several labelled options. criteria maps each option key to a description of when it applies. The answer contains the winning key in choice, plus probabilities for every option and the overall confidence.

{
  "sentiment": {
    "type": "choice",
    "instructions": "What is the sentiment of the review?",
    "criteria": {
      "positive": "The reviewer liked the book.",
      "negative": "The reviewer disliked the book.",
      "neutral": "The reviewer has no strong opinion."
    }
  }
}

Answer:

{
  "sentiment": {
    "type": "choice",
    "choice": "positive",
    "confidence": 0.97,
    "probabilities": {
      "positive": 0.97,
      "negative": 0.01,
      "neutral": 0.02
    }
  }
}

`score`: position on an ordered scale

A score question places the content on an ordered scale. criteria is a list of labels from lowest to highest. The answer is the zero-based index of the chosen label in score, with probabilities keyed by index, a legend mapping indices back to labels, and the overall confidence.

{
  "rating": {
    "type": "score",
    "instructions": "How much did the reviewer enjoy the book?",
    "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"]
  }
}

Answer:

{
  "rating": {
    "type": "score",
    "score": 4,
    "confidence": 0.91,
    "legend": {
      "0": "Hated it",
      "1": "Disliked it",
      "2": "Neutral",
      "3": "Liked it",
      "4": "Loved it"
    },
    "probabilities": {
      "0": 0.0,
      "1": 0.0,
      "2": 0.01,
      "3": 0.08,
      "4": 0.91
    }
  }
}

Examples

The examples below ask all three question types about the same book review using typesafe/jev-1.14.0. Set model to any id from the Models table to use another decision model. Swap in your own content and questions.

Decisions endpoint (recommended)

Send state and questions to /v1/systemone and read answers from the response.

Python
TypeScript
cURL

import httpx

review = (
    "This book was an absolute delight, I could not put it down "
    "and finished it in one sitting."
)

questions = {
    "positive": {
        "type": "noul",
        "instructions": "The review is positive.",
    },
    "sentiment": {
        "type": "choice",
        "instructions": "What is the sentiment of the review?",
        "criteria": {
            "positive": "The reviewer liked the book.",
            "negative": "The reviewer disliked the book.",
            "neutral": "The reviewer has no strong opinion.",
        },
    },
    "rating": {
        "type": "score",
        "instructions": "How much did the reviewer enjoy the book?",
        "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
    },
}

response = httpx.post(
    "https://router.requesty.ai/v1/systemone",
    headers={"Authorization": "Bearer YOUR_REQUESTY_API_KEY"},
    json={
        "model": "typesafe/jev-1.14.0",
        "state": review,
        "questions": questions,
    },
)
response.raise_for_status()

answers = response.json()["answers"]
print(answers["sentiment"]["choice"])  # "positive"

const review =
  "This book was an absolute delight, I could not put it down and finished it in one sitting.";

const questions = {
  positive: {
    type: "noul",
    instructions: "The review is positive.",
  },
  sentiment: {
    type: "choice",
    instructions: "What is the sentiment of the review?",
    criteria: {
      positive: "The reviewer liked the book.",
      negative: "The reviewer disliked the book.",
      neutral: "The reviewer has no strong opinion.",
    },
  },
  rating: {
    type: "score",
    instructions: "How much did the reviewer enjoy the book?",
    criteria: ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
  },
};

const response = await fetch("https://router.requesty.ai/v1/systemone", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_REQUESTY_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "typesafe/jev-1.14.0",
    state: review,
    questions,
  }),
});

const { answers } = await response.json();
console.log(answers.sentiment.choice);  // "positive"

curl https://router.requesty.ai/v1/systemone \
  -H "Authorization: Bearer YOUR_REQUESTY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-1.14.0",
    "state": "This book was an absolute delight, I could not put it down and finished it in one sitting.",
    "questions": {
      "positive": {
        "type": "noul",
        "instructions": "The review is positive."
      },
      "sentiment": {
        "type": "choice",
        "instructions": "What is the sentiment of the review?",
        "criteria": {
          "positive": "The reviewer liked the book.",
          "negative": "The reviewer disliked the book.",
          "neutral": "The reviewer has no strong opinion."
        }
      },
      "rating": {
        "type": "score",
        "instructions": "How much did the reviewer enjoy the book?",
        "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"]
      }
    }
  }'

The answers come back as plain JSON, no string to parse:

{
  "answers": {
    "positive": { "type": "noul", "noul": 0.99 },
    "sentiment": {
      "type": "choice",
      "choice": "positive",
      "confidence": 1,
      "probabilities": { "positive": 1, "negative": 0, "neutral": 0 }
    },
    "rating": {
      "type": "score",
      "score": 4,
      "confidence": 1,
      "legend": {
        "0": "Hated it",
        "1": "Disliked it",
        "2": "Neutral",
        "3": "Liked it",
        "4": "Loved it"
      },
      "probabilities": { "0": 0, "1": 0, "2": 0, "3": 0, "4": 1 }
    }
  },
  "id": "rqsty-dcsn-...",
  "model": "jev-1.14.0",
  "provider": "typesafe",
  "usage": {
    "input_tokens": 426,
    "output_tokens": 68
  }
}

To send images to cloudflare/clef or openai/gpt-6-luna, add them in assets, as JSON or as a multipart upload. See Create System One Decision for the full reference.

Other APIs

If your tool can only call Chat Completions, Messages or Responses, you can still reach typesafe/jev-latest, cloudflare/clef and perplexity/pplx-decider-v1-27b through them. Prefer the Decisions endpoint whenever you can: these APIs were built for text generation, so the answers come back as a JSON string inside the assistant message that you have to parse, and openai/gpt-6-luna and azure/decision-1 are not available here. On these APIs, the content to evaluate goes in one or more user messages (several are joined with blank lines) and the questions go in the response format field as {"type": "questions", "questions": {...}}.

Only the following are supported when calling a decision model through these APIs:

user messages with text content. system, assistant and tool messages, files and tool definitions are rejected.
Images only on cloudflare/clef: up to 4 per request, sent as base64 data URLs. Remote image URLs are rejected. typesafe/jev-latest accepts text only.
Non-streaming requests. stream: true returns a 400.
A questions response format. json_object, json_schema and plain text are not supported by this model.

Chat Completions API

Pass the questions in response_format.

Python (OpenAI SDK)
TypeScript
cURL

import json
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_REQUESTY_API_KEY",
    base_url="https://router.requesty.ai/v1",
)

review = (
    "This book was an absolute delight, I could not put it down "
    "and finished it in one sitting."
)

questions = {
    "positive": {
        "type": "noul",
        "instructions": "The review is positive.",
    },
    "sentiment": {
        "type": "choice",
        "instructions": "What is the sentiment of the review?",
        "criteria": {
            "positive": "The reviewer liked the book.",
            "negative": "The reviewer disliked the book.",
            "neutral": "The reviewer has no strong opinion.",
        },
    },
    "rating": {
        "type": "score",
        "instructions": "How much did the reviewer enjoy the book?",
        "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
    },
}

completion = client.chat.completions.create(
    model="typesafe/jev-latest",
    messages=[{"role": "user", "content": review}],
    response_format={"type": "questions", "questions": questions},
)

answers = json.loads(completion.choices[0].message.content)
print(answers["positive"]["noul"])       # 0.98
print(answers["sentiment"]["choice"])    # "positive"
print(answers["rating"]["score"])        # 4

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_REQUESTY_API_KEY",
  baseURL: "https://router.requesty.ai/v1",
});

const review =
  "This book was an absolute delight, I could not put it down and finished it in one sitting.";

const questions = {
  positive: {
    type: "noul",
    instructions: "The review is positive.",
  },
  sentiment: {
    type: "choice",
    instructions: "What is the sentiment of the review?",
    criteria: {
      positive: "The reviewer liked the book.",
      negative: "The reviewer disliked the book.",
      neutral: "The reviewer has no strong opinion.",
    },
  },
  rating: {
    type: "score",
    instructions: "How much did the reviewer enjoy the book?",
    criteria: ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
  },
};

const completion = await client.chat.completions.create({
  model: "typesafe/jev-latest",
  messages: [{ role: "user", content: review }],
  // The SDK types do not know about "questions" yet, hence the cast
  response_format: { type: "questions", questions } as any,
});

const answers = JSON.parse(completion.choices[0].message.content!);
console.log(answers.positive.noul);     // 0.98
console.log(answers.sentiment.choice);  // "positive"
console.log(answers.rating.score);      // 4

curl https://router.requesty.ai/v1/chat/completions \
  -H "Authorization: Bearer YOUR_REQUESTY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-latest",
    "messages": [
      {
        "role": "user",
        "content": "This book was an absolute delight, I could not put it down and finished it in one sitting."
      }
    ],
    "response_format": {
      "type": "questions",
      "questions": {
        "positive": {
          "type": "noul",
          "instructions": "The review is positive."
        },
        "sentiment": {
          "type": "choice",
          "instructions": "What is the sentiment of the review?",
          "criteria": {
            "positive": "The reviewer liked the book.",
            "negative": "The reviewer disliked the book.",
            "neutral": "The reviewer has no strong opinion."
          }
        },
        "rating": {
          "type": "score",
          "instructions": "How much did the reviewer enjoy the book?",
          "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"]
        }
      }
    }
  }'

The answers come back as the JSON content of the assistant message:

{
  "id": "req_...",
  "object": "chat.completion",
  "model": "typesafe/jev-latest",
  "choices": [
    {
      "index": 0,
      "finish_reason": "stop",
      "message": {
        "role": "assistant",
        "content": "{\"positive\":{\"type\":\"noul\",\"noul\":0.98},\"sentiment\":{\"type\":\"choice\",\"choice\":\"positive\",\"confidence\":0.97,\"probabilities\":{\"positive\":0.97,\"negative\":0.01,\"neutral\":0.02}},\"rating\":{\"type\":\"score\",\"score\":4,\"confidence\":0.91,\"legend\":{\"0\":\"Hated it\",\"1\":\"Disliked it\",\"2\":\"Neutral\",\"3\":\"Liked it\",\"4\":\"Loved it\"},\"probabilities\":{\"0\":0.0,\"1\":0.0,\"2\":0.01,\"3\":0.08,\"4\":0.91}}}"
      }
    }
  ],
  "usage": {
    "prompt_tokens": 448,
    "completion_tokens": 55,
    "total_tokens": 503
  }
}

Messages API

Pass the questions in output_config.format.

Python (Anthropic SDK)
TypeScript
cURL

import json
from anthropic import Anthropic

client = Anthropic(
    api_key="YOUR_REQUESTY_API_KEY",
    base_url="https://router.requesty.ai",
)

review = (
    "This book was an absolute delight, I could not put it down "
    "and finished it in one sitting."
)

questions = {
    "positive": {
        "type": "noul",
        "instructions": "The review is positive.",
    },
    "sentiment": {
        "type": "choice",
        "instructions": "What is the sentiment of the review?",
        "criteria": {
            "positive": "The reviewer liked the book.",
            "negative": "The reviewer disliked the book.",
            "neutral": "The reviewer has no strong opinion.",
        },
    },
    "rating": {
        "type": "score",
        "instructions": "How much did the reviewer enjoy the book?",
        "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
    },
}

message = client.messages.create(
    model="typesafe/jev-latest",
    max_tokens=1024,
    messages=[{"role": "user", "content": review}],
    output_config={
        "format": {"type": "questions", "questions": questions},
    },
)

answers = json.loads(message.content[0].text)
print(answers["sentiment"]["choice"])  # "positive"

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_REQUESTY_API_KEY",
  baseURL: "https://router.requesty.ai",
});

const review =
  "This book was an absolute delight, I could not put it down and finished it in one sitting.";

const questions = {
  positive: {
    type: "noul",
    instructions: "The review is positive.",
  },
  sentiment: {
    type: "choice",
    instructions: "What is the sentiment of the review?",
    criteria: {
      positive: "The reviewer liked the book.",
      negative: "The reviewer disliked the book.",
      neutral: "The reviewer has no strong opinion.",
    },
  },
  rating: {
    type: "score",
    instructions: "How much did the reviewer enjoy the book?",
    criteria: ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
  },
};

const message = await client.messages.create({
  model: "typesafe/jev-latest",
  max_tokens: 1024,
  messages: [{ role: "user", content: review }],
  // The SDK types do not know about "questions" yet, hence the cast
  output_config: { format: { type: "questions", questions } },
} as any);

const block = message.content[0];
const answers = JSON.parse(block.type === "text" ? block.text : "{}");
console.log(answers.sentiment.choice);  // "positive"

curl https://router.requesty.ai/v1/messages \
  -H "x-api-key: YOUR_REQUESTY_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-latest",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "This book was an absolute delight, I could not put it down and finished it in one sitting."
      }
    ],
    "output_config": {
      "format": {
        "type": "questions",
        "questions": {
          "positive": {
            "type": "noul",
            "instructions": "The review is positive."
          },
          "sentiment": {
            "type": "choice",
            "instructions": "What is the sentiment of the review?",
            "criteria": {
              "positive": "The reviewer liked the book.",
              "negative": "The reviewer disliked the book.",
              "neutral": "The reviewer has no strong opinion."
            }
          },
          "rating": {
            "type": "score",
            "instructions": "How much did the reviewer enjoy the book?",
            "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"]
          }
        }
      }
    }
  }'

Responses API

Pass the questions in text.format.

Python (OpenAI SDK)
TypeScript
cURL

import json
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_REQUESTY_API_KEY",
    base_url="https://router.requesty.ai/v1",
)

review = (
    "This book was an absolute delight, I could not put it down "
    "and finished it in one sitting."
)

questions = {
    "positive": {
        "type": "noul",
        "instructions": "The review is positive.",
    },
    "sentiment": {
        "type": "choice",
        "instructions": "What is the sentiment of the review?",
        "criteria": {
            "positive": "The reviewer liked the book.",
            "negative": "The reviewer disliked the book.",
            "neutral": "The reviewer has no strong opinion.",
        },
    },
    "rating": {
        "type": "score",
        "instructions": "How much did the reviewer enjoy the book?",
        "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
    },
}

response = client.responses.create(
    model="typesafe/jev-latest",
    input=review,
    text={"format": {"type": "questions", "questions": questions}},
)

answers = json.loads(response.output_text)
print(answers["rating"]["score"])  # 4

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_REQUESTY_API_KEY",
  baseURL: "https://router.requesty.ai/v1",
});

const review =
  "This book was an absolute delight, I could not put it down and finished it in one sitting.";

const questions = {
  positive: {
    type: "noul",
    instructions: "The review is positive.",
  },
  sentiment: {
    type: "choice",
    instructions: "What is the sentiment of the review?",
    criteria: {
      positive: "The reviewer liked the book.",
      negative: "The reviewer disliked the book.",
      neutral: "The reviewer has no strong opinion.",
    },
  },
  rating: {
    type: "score",
    instructions: "How much did the reviewer enjoy the book?",
    criteria: ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"],
  },
};

const response = await client.responses.create({
  model: "typesafe/jev-latest",
  input: review,
  // The SDK types do not know about "questions" yet, hence the cast
  text: { format: { type: "questions", questions } as any },
});

const answers = JSON.parse(response.output_text);
console.log(answers.rating.score);  // 4

curl https://router.requesty.ai/v1/responses \
  -H "Authorization: Bearer YOUR_REQUESTY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-latest",
    "input": "This book was an absolute delight, I could not put it down and finished it in one sitting.",
    "text": {
      "format": {
        "type": "questions",
        "questions": {
          "positive": {
            "type": "noul",
            "instructions": "The review is positive."
          },
          "sentiment": {
            "type": "choice",
            "instructions": "What is the sentiment of the review?",
            "criteria": {
              "positive": "The reviewer liked the book.",
              "negative": "The reviewer disliked the book.",
              "neutral": "The reviewer has no strong opinion."
            }
          },
          "rating": {
            "type": "score",
            "instructions": "How much did the reviewer enjoy the book?",
            "criteria": ["Hated it", "Disliked it", "Neutral", "Liked it", "Loved it"]
          }
        }
      }
    }
  }'

Approved models

If your organization uses Approved Models or access lists, approval is checked per API:

Decisions endpoint: the model must be approved under Decisions in the Model Library.
Chat Completions, Messages and Responses: the model must be approved as a chat model. Approving it under Decisions is not enough.

A decision model that is approved for one API but not the other returns a 403 on the other one. If you call the same model through both, approve it in both places.

Usage and billing

Decision model responses report input and output tokens in the usual usage block, and requests are priced and logged like any other model. See Cost Tracking and Logs.

Errors

Status	Cause
`400`	Missing or empty `questions` or `state`, a non-`questions` response format, `stream: true`, a non-user message, or unsupported content (non-text on Jev, more than 4 images or remote image URLs on Clef)
`403`	The model is not approved for this API. See Approved models
`404`	The model id is not served on this API. Check `/v1/models/decision` for the Decisions endpoint
`429`	Upstream rate limit. Retry after the `Retry-After` interval

Create Decision and Create System One Decision for the dedicated Decisions API, including how to send images
Structured Outputs for schema-constrained JSON from general-purpose models
Supported Models

Getting Started

LLM Gateway

Model Capabilities

Analytics & Monitoring

Access Control

Organization

MCP Gateway

Models

How it works

Question types

`noul`: yes / no

`choice`: pick one option

`score`: position on an ordered scale

Examples

Decisions endpoint (recommended)

Other APIs

Chat Completions API

Messages API

Responses API

Approved models

Usage and billing

Errors

​Models

​How it works

​Question types

​noul: yes / no

​choice: pick one option

​score: position on an ordered scale

​Examples

​Decisions endpoint (recommended)

​Other APIs

​Chat Completions API

​Messages API

​Responses API

​Approved models

​Usage and billing

​Errors

​Related

Models

How it works

Question types

`noul`: yes / no

`choice`: pick one option

`score`: position on an ordered scale

Examples

Decisions endpoint (recommended)

Other APIs

Chat Completions API

Messages API

Responses API

Approved models

Usage and billing

Errors

Related