Structured Decisions (System One)

When you ask a language model for a decision your code will branch on, you are doing two jobs at once: telling the model to produce the answer, then parsing the text it produced back into your own types. The parsing step is the fragile one — the model changes format, adds a preamble, truncates the JSON.

System One models remove that step. They take a state (the content to judge) and the typed questions you define, and return a structured answer for each question. No free text is generated, so there is nothing to parse. Answers come with a probability or a confidence value, which means the threshold is yours to set in code.

Model

Model	Context	Input / Output ($/1M tokens)
`typesafe/jev-1.14.0`	32,000	0.042 / 0
`typesafe/jev`	32,000	0.042 / 0
`upstage/solar-decide`	524,288	0.10 / 0
`fastino/glide`	40,000	0.15 / 0
`greenpt/metis`	32,768	0.147783 / 0
`perplexity/pplx-decider-v1.1-27b`	262,144	0.02 / 0
`perplexity/pplx-decider-v1-27b`	262,144	0.02 / 0
`llmtr/leyla`	1,024	0.03 / 0
`llmtr/leyla-english`	512	0.03 / 0
`llmtr/leyla-typed-decisions`	1,024	0.03 / 0
`nace/drex-v2.0`	131,072	0.06 / 0
`nace/drex-max-finance`	262,144	0.03 / 0
`liquid/d1-ultra`	32,768	0.042 / 0
`scaledown/classify-free`	131,072	0 / 0
`baseten/mammoth-1`	16,384	0.10 / 0
`baseten/elephant-1`	16,384	0.035 / 0
`baseten/joey-1`	16,384	0.01 / 0
`hume/audio-decision-model`	—	0.47 / 0
`morph/reflex`	65,536	0.042 / 0
`google/gemini-decision-1`	262,144	0.10 / 0

typesafe/jev-1.14.0 is the newest version of TypeSafe's decision model and the only one that answers Box questions. typesafe/jev stays on Jev 1.13 and is for integrations whose thresholds are tuned to that version; a new integration can start on typesafe/jev-1.14.0. The two versions can return slightly different probabilities for the same question; check your thresholds when you move. Both accept images and a longer context, which are experimental features of the provider (Jev experimental features).

The Leyla models are hosted in Turkey; request content does not leave Turkey. llmtr/leyla works in more than 100 languages including Turkish. llmtr/leyla-english is for English text only. llmtr/leyla-typed-decisions is for English decisions on invoices, security incidents, customer-service records and agent traces.

fastino/glide retains the requests and responses you send and may use them to improve its models; for states that contain personal data, prefer the Leyla models.

greenpt/metis is a general-purpose decision model; according to the provider, requests are processed in the European Union. Your account must have given the GreenPT data transfer consent before you can call it; without it the request returns 403 provider_consent_required (Data transfer consent).

The Perplexity Decider models evaluate images as well as text (Image input). perplexity/pplx-decider-v1-27b is the first version and is for integrations pinned to it; a new integration can start on perplexity/pplx-decider-v1.1-27b.

nace/drex-v2.0 is the latest numbered version of Nace's decision model. It reads text only; an image, audio or PDF in the state returns 422 provider_error. The free offer on nace/drex-v1.5-free and nace/drex-v1.0-free ended on 13 October 2026; those ids return 410 model_retired and name nace/drex-v2.0 instead. Drex 2.0 is a different version, so the probabilities it returns can differ from the earlier versions'; check your thresholds when you move.

nace/drex-max-finance is Nace's decision model for finance, reading images as well as text; for example, you can ask whether an invoice exceeds its approved purchase order and whether it should be paid, held or rejected. The request and answer shapes are those of the other Drex models; images go in the top-level images array (Drex Max images). It takes at most 512 questions per request. Its 262,144-token limit covers the whole request: the state, the images, all questions and the model's formatting markers share it, so every question you add uses part of it, even one that would fit on its own. With a long state and many questions, split the questions across requests.

nace/drex-max-free was the version of Nace's Drex that reads images, offered at no charge until 31 October 2026, 23:59 (TRT); the free offer has ended and the id returns 410 model_retired.

liquid/d1-ultra is Liquid AI's largest decision model. It evaluates images as well as text (d1-ultra images); it does not answer Box questions. The text and images you send may be retained by the provider and used to train Liquid's models; do not send sensitive, personal or customer data.

scaledown/classify-free is free until 20 October 2026, 23:59 (TRT); it closes earlier if the quota set aside for free use runs out, and free use is limited per account per day. It reads text only; an image or PDF in the state returns 400 invalid_request. A state object with only a text key ({ "text": "..." }) is given to the model as that text; any other object or array as its JSON text. Once the free offer ends, the model's page lists paid System One models that take the same request. See ScaleDown task models for details.

baseten/mammoth-1 (27B), baseten/elephant-1 (9B) and baseten/joey-1 (2B) are the decision models of Base Labs, Baseten's research team; they take the same request shape and differ in size and price. They read images in a conversation state (Baseten images) and do not answer Box questions. All three have a 16,384-token context; a question that goes over the model's context together with the state and images returns 422 provider_error; it is not truncated. The provider's service_tier field is not supported; sending it returns 400 invalid_request. The free offer for baseten/mammoth-1-free and baseten/elephant-1-free ended on 27 October 2026, 23:59 (TRT); these ids return 410 model_retired and recommend the paid id of the same model (baseten/mammoth-1, baseten/elephant-1).

hume/audio-decision-model is Hume's decision model for questions about an audio recording. Instead of a text it judges the audio file in the audio field (MP3 or WAV, 5 seconds to 5 minutes); state is a short description of the recording. Besides Noul, Choice and Score it answers the Span question, which finds when something happens in the recording. It does not use the Box question or the assets and images fields. For the request, the limits and how to prepare the recording, see Audio decisions.

morph/reflex is Morph's decision model. It evaluates images as well as text and JSON; images go in the top-level images array or as image_url parts in the state (Reflex images). It does not answer Box or Span questions. It reads the top-level instructions field, shared context placed before all the questions. Each question must fit the 65,536-token context together with the state, the images and instructions; a question that does not returns 422 provider_error. Repeated input can be read from the cache and is billed at a lower price (Billing).

google/gemini-decision-1 is Google's decision model. It evaluates images, audio, video and PDF as well as text and JSON; media goes as content blocks in a state array, and images can also go in the top-level images array and audio in the audio field (Gemini Decision 1 inputs). It does not answer Box or Span questions and does not use the assets or top-level instructions fields. A request takes up to 1,000 questions, and the state, the media and all questions together must fit in 262,144 tokens. The shared input is billed once whatever the number of questions (Billing).

To list the System One models in the catalog:

curl -s "$LLMTR_BASE_URL/v1/models" \
  | jq -r '.data[] | select(.supported_operations[] == "SYSTEM_ONE").id'

Request

curl "$LLMTR_BASE_URL/v1/systemone" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev",
    "state": "I was charged twice on my card and I want the duplicate refunded.",
    "questions": {
      "refund_requested": {
        "type": "noul",
        "instructions": "Is the customer requesting a refund?"
      },
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this request?",
        "criteria": {
          "billing": "Payments, invoicing, refunds",
          "technical": "Bugs, outages, integrations",
          "sales": "Pricing, new accounts"
        }
      }
    }
  }'

Field	Required	Description
`model`	Yes	The System One model id.
`state`	Yes	The content to evaluate. Plain text or structured data (an object or an array). On the Perplexity Decider models the array can also carry images. On the Baseten models an object carrying `messages` is read as a conversation and can carry images. On `hume/audio-decision-model` it is a short description of the recording and must be plain text. On `morph/reflex` an `image_url` part anywhere in the `state` can carry an image. On `google/gemini-decision-1` the array is a list of text and media content blocks.
`questions`	Yes	A map of questions whose keys you choose. Answers come back under the same keys.
`assets`	No	A map of images; Jev models only. See Jev experimental features.
`images`	No	A list of images; `liquid/d1-ultra`, `nace/drex-max-finance`, `morph/reflex` and `google/gemini-decision-1` only. See d1-ultra images, Drex Max images, Reflex images and Gemini Decision 1 inputs.
`audio`	No	An audio file; `hume/audio-decision-model` (required there) and `google/gemini-decision-1` only. See Audio decisions and Gemini Decision 1 inputs.
`instructions`	No	Shared context placed before all the questions, as plain text; `morph/reflex` only. Sent to another model it returns `400 invalid_request`. Each question's own `instructions` is separate and required on every model.
`max_budget_usd`	No	A pre-flight estimated-cost check. See the note below.

Question keys are not sent to the model; they only match answers back to questions. Write the complete question in instructions, however self-explanatory the key looks — the key is not text the model sees.

max_budget_usd is a pre-flight check: the request is refused before it reaches the upstream when the cost estimated from the body exceeds this value. The final charge is computed from the token count the upstream reports and is not re-checked against this ceiling, so input that produces more tokens per character than expected can be billed above the estimate. Use the per-API-key spending limit when you need a hard cap.

Questions in one request are evaluated independently; one answer never becomes context for another. hume/audio-decision-model is the exception: there all the questions in a request are answered together, so adding or reordering questions can change the other answers; send the same questions in the same order for every recording you compare.

Question types

There are five question types. All of them share type and instructions; criteria differs by type. Box works on typesafe/jev-1.14.0 only, Span on hume/audio-decision-model only.

Noul

A yes/no question. Returns the probability that the answer is yes, between 0 and 1. criteria is optional and only clarifies what each end means.

{
  "is_urgent": {
    "type": "noul",
    "instructions": "Does this message convey urgency?",
    "criteria": {
      "true": "Explicitly time-sensitive",
      "false": "No urgency expressed"
    }
  }
}

Choice

Picks one of the options you define. Returns the selected option, the probability distribution across every option, and a confidence value. criteria maps each option name to a description; use null when an option needs no further detail.

Add an option such as other when your inputs might not fit the list; otherwise the model always returns the closest option in it.

{
  "department": {
    "type": "choice",
    "instructions": "Which team should handle this request?",
    "criteria": {
      "billing": "Payments, invoicing, refunds",
      "technical": "Bugs, outages, integrations",
      "other": null
    }
  }
}

Score

Returns a position along ordered levels. criteria is an ordered array of at least two levels. The returned score can fall between two of them. fastino/glide differs: score is the index of the most probable level (an integer from 0), and expected_level is the probability-weighted position between levels.

{
  "frustration": {
    "type": "score",
    "instructions": "How frustrated does the customer appear?",
    "criteria": ["Calm", "Frustrated but civil", "Very angry"]
  }
}

Do not confuse a yes/no judgment with measuring a level. For "is this candidate strong in Python?", a value of 0.5 does not mean the candidate is mid-level; it means the model gives yes and no equal probability. Use Score to measure a level, and a Noul with a clearly defined condition when you need a decision.

Box

Returns where something is in an image, as four edges. It works on typesafe/jev-1.14.0 only and needs an image and the TypeSafe-Danger-Zone-Images: true header (Jev experimental features). The image must be in the state or in the Box question's own instructions; an image in another question's instructions goes to that question only. It takes no criteria.

{
  "shoes": {
    "type": "box",
    "instructions": "the shoes of the person in `photo`"
  }
}

The box field of the answer gives the top, bottom, left and right edges as fractions between 0 and 1, measured from the top-left corner: left and right are fractions of the width, top and bottom of the height. Multiply an edge by the image's width or height to get pixels. Box always returns a box; there is no "not found" answer, and the thing you ask for may not be in the image, so set a confidence threshold on your own images. When the model gives no confidence, confidence is null: check for it before comparing with your threshold and treat such a box as undecided; you can also ask in the same request, with a Noul question, whether the object is in the image at all. Each question finds one target; to find several things, ask one Box question for each.

Span

Returns when something happens in an audio recording, as time spans with a probability each. Works on hume/audio-decision-model only; a request can carry at most 5 Span questions. It takes no criteria; describe the event in full in instructions.

{
  "cancel_moment": {
    "type": "span",
    "instructions": "When does the caller say they want to cancel their service?"
  }
}

The answer's spans list carries audio_start_ms, audio_end_ms and probability, in order of start; an empty list means the event was not found.

Response

{
  "model": "typesafe/jev",
  "answers": {
    "refund_requested": {
      "type": "noul",
      "noul": 0.94
    },
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.88, "technical": 0.07, "sales": 0.05 },
      "confidence": 0.85
    }
  },
  "usage": { "input_tokens": 312, "output_tokens": 61 }
}

Every key in answers is a question key you supplied. Each answer carries its own type, so which fields to read is unambiguous: noul for a Noul, choice + probabilities + confidence for a Choice, score + legend + probabilities + confidence for a Score (plus expected_level on fastino/glide), box + confidence for a Box, spans for a Span.

The model field returns the LLMTR catalog id. The token counts above are illustrative; output_tokens normally comes back greater than zero — what is free is the price of output, not the count. Do not assume this field is zero when building your own token accounting.

On morph/reflex, usage also carries input_tokens_details.cached_tokens: the part of input_tokens read from the cache. When nothing was read from the cache the value is 0.

"usage": { "input_tokens": 1328, "output_tokens": 0, "input_tokens_details": { "cached_tokens": 1216 } }

On google/gemini-decision-1 a Noul answer carries confidence too, and the noul value lies between 0.01 and 0.99. On this model output_tokens is always 0.

Choosing a threshold

confidence summarizes how peaked the probability distribution is; where to act automatically is your decision. If you only need the most likely option, you do not need a threshold at all — reading choice is enough. Thresholds earn their place where you separate acting automatically from handing a case to a person.

Keep thresholds and question text together in one file in your code. Those are what a reviewer needs to look at; threshold constants scattered across a codebase are not found again later.

Image input

perplexity/pplx-decider-v1.1-27b and perplexity/pplx-decider-v1-27b evaluate images too. Send state as an array and add each image as an image_url part carrying a base64 data URL; text parts can sit in the same array:

{
  "model": "perplexity/pplx-decider-v1.1-27b",
  "state": [
    "Product photo for listing #881.",
    { "type": "image_url", "image_url": { "url": "data:image/png;base64,iVBORw0KGgo..." } }
  ],
  "questions": {
    "color": {
      "type": "choice",
      "instructions": "What color is the shirt the person is wearing?",
      "criteria": { "navy": null, "white": null, "red": null }
    }
  }
}

PNG, JPEG and WebP data URLs are accepted. The model does not download images from an address; an http or https URL returns 400 provider_error.
An image counts as input tokens and is counted again for every question. A single image comes to at most about 2,050 tokens per question.
An image is read at up to 2,048 squares of 32 × 32 pixels (for example 1440 × 1440 or 2048 × 1024). Resize a larger image to that size before sending it; how an image over the limit is read is not guaranteed. The request body is limited to 24 MB in total, and base64 encoding makes a file about a third larger.

d1-ultra images

liquid/d1-ultra takes images in a top-level images array, and every question sees every image in it. An image can be a base64 data URL or an object with content_type and base64 fields. No header is needed.

{
  "model": "liquid/d1-ultra",
  "state": "The first image is the reference product, the second is the photo the customer sent.",
  "images": [
    "data:image/png;base64,iVBORw0KGgo...",
    { "content_type": "image/jpeg", "base64": "/9j/4AAQSkZJRg..." }
  ],
  "questions": {
    "same_product": {
      "type": "noul",
      "instructions": "Is the product in the second image the same as the one in the first image?"
    }
  }
}

JPEG, PNG and WebP are accepted; a request can carry at most 8 images. Any other file type, an address (http or https) or a ninth image returns 400 invalid_request.
The order of the images matters: refer to them by position in the state or the questions ("the first image", "the second image").
An image's token count is ceil(ceil(width / 32) × ceil(height / 32) × 1.5) and is counted again for every question; a 1024 × 1024 image comes to 1,536 tokens per question. Image tokens count toward the 32,768-token limit per question.
The provider's other documented limits: all images in a request together can cover at most 10,000 squares of 32 × 32 pixels, and an image's longer side can be at most 100 times its shorter side. The request body must stay under 4.5 MB; a larger request returns 413 provider_error. Resize or compress images before sending them.

Drex Max images

nace/drex-max-finance takes images in the top-level images array. Every question sees all the images in the array, in array order, before the state and the question. An image is either a base64 data URL or an object with content_type and base64 fields. No header is needed.

{
  "model": "nace/drex-max-finance",
  "state": "Image 1 is the supplier's invoice, Image 2 the approved purchase order.",
  "images": [
    "data:image/png;base64,iVBORw0KGgo...",
    { "content_type": "image/jpeg", "base64": "/9j/4AAQSkZJRg..." }
  ],
  "questions": {
    "over_po": {
      "type": "noul",
      "instructions": "Does the invoice total in Image 1 exceed the approved amount in Image 2?"
    }
  }
}

Still JPEG, PNG and WebP images are accepted; a request can carry at most 8 images. Any other file type, an address (http or https), a ninth image or an image over 40 million pixels returns 400 invalid_request. The model does not fetch images from addresses.
Refer to the images by their position in the array in the state or the questions: "Image 1", "Image 2". Those words stay plain text; the model matches them to the images by their order in the array.
Images do not go in the state or the questions; an image part in a state array returns 400 invalid_request. Base64 without a data: prefix and references to files uploaded to the provider are not accepted; send the image as a data URL or an object.
Each image is resized to at most the area of 1,280 × 1,280 (1,638,400 pixels); detail past that is not kept. Image tokens are inside the request's 262,144-token limit: the state, the images and all questions share it. Rather than sending a long state, several images and many questions together, split the questions across requests.
Images count toward the 4 MiB body limit as base64, so a request holds about 3 MiB of image bytes in all. A larger request returns 400 invalid_request. Downscale the images before sending them.

Baseten images

The Baseten models read images in a conversation state: the state carries a messages array, images go as image_url parts in the content array of a user message, and text parts can sit in the same array. No header is needed.

{
  "model": "baseten/joey-1",
  "state": {
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "Product photo for listing #881." },
          { "type": "image_url", "image_url": { "url": "data:image/png;base64,iVBORw0KGgo..." } }
        ]
      }
    ]
  },
  "questions": {
    "colour": {
      "type": "choice",
      "instructions": "What colour is the t-shirt of the person in the photo?",
      "criteria": { "navy": null, "white": null, "red": null }
    }
  }
}

Send a PNG, JPEG or WebP base64 data URL. The provider also accepts HTTPS addresses on Amazon S3, Google Cloud Storage and Azure Blob Storage; any other address returns 422 provider_error.
Send at most 16 images per request; more return 422 provider_error. An image can only be in a user message; an image in an assistant message returns 422 provider_error.
Do not put an image in a plain state array or in a question's instructions; an image part in that form returns 400 invalid_request.
Image tokens arrive in usage.input_tokens and count toward the context limit per question.

Reflex images

morph/reflex reads images from two places: the top-level images array and image_url parts anywhere in the state (an array, a field of an object, or a messages conversation). Each image must be a base64 data URL. No header is needed.

{
  "model": "morph/reflex",
  "state": "A satellite image of an industrial building. Inspect the equipment outside the building.",
  "images": ["data:image/jpeg;base64,/9j/4AAQSkZJRg..."],
  "questions": {
    "equipment": {
      "type": "choice",
      "instructions": "Is outdoor mechanical equipment visible beside the building?",
      "criteria": {
        "visible": "Outdoor mechanical equipment is visible.",
        "not_visible": "No outdoor mechanical equipment is visible.",
        "unclear": "The image is too unclear to tell."
      }
    }
  }
}

The same image can go in the state instead:

"state": [
  "A satellite image of an industrial building.",
  { "type": "image_url", "image_url": { "url": "data:image/jpeg;base64,/9j/4AAQSkZJRg..." } }
]

PNG, JPEG and WebP are accepted; a request can carry at most 16 images across the images array and the parts in the state together. More return 400 invalid_request.
A request body over about 2.5 MB, base64 included, can be refused by the model with 413 provider_error; base64 encoding makes a file about a third larger. Downscale or compress large photos before sending them.
The model does not download images from addresses; an http or https address in an image_url part returns 400 invalid_request.
The type of an image in the images array is read from the file itself. In an image_url part in the state, the type you declare (such as data:image/png) must be the file's real type; otherwise the request returns 400 invalid_request.
Do not send an image outside an image_url part: the model reads an input_image part or a bare data URL in the state as text, so either returns 400 invalid_request. An image in a question's instructions or criteria returns 400 invalid_request too.
Image tokens arrive in usage.input_tokens, are counted again for every question and count toward the 65,536-token context per question.

Gemini Decision 1 inputs

google/gemini-decision-1 reads media from the content blocks of a state array. A block can be text (a plain string or {"type": "text", "text": "..."}), an image, audio, video or a PDF; every question sees the same input. No header is needed.

{
  "model": "google/gemini-decision-1",
  "state": [
    { "type": "image", "data": "iVBORw0KGgo...", "resolution": "low" },
    { "type": "audio", "data": "UklGRiQAAABXQVZF..." },
    "Damage report: the customer says the parcel arrived crushed."
  ],
  "questions": {
    "is_damaged": {
      "type": "noul",
      "instructions": "Does the photo show a damaged parcel?",
      "criteria": { "true": "Crushed, torn or wet parcel.", "false": "The parcel is intact." }
    },
    "action": {
      "type": "choice",
      "instructions": "Which action fits?",
      "criteria": { "refund": "", "resend": "", "review": "Not enough information to decide." }
    }
  }
}

Block	Accepted file
`image`	PNG, JPEG, WebP
`audio`	WAV, MP3
`video`	MP4
`document`	PDF

The file goes in the data field as standard base64 without a data: prefix. Its type is read from the file itself; the mime_type field is optional. A file whose type does not match its block, or that is not in the table, returns 400 invalid_request.
Addresses are not accepted: a uri field and an http or https address return 400 invalid_request. An image can also be sent as a base64 data URL in an image_url part.
The fields other System One models read are accepted too: the top-level images array (PNG, JPEG or WebP; at most 16 images, 8,000,000 bytes each) and the audio field ({"format": "wav", "data_base64": "..."}; WAV or MP3). They reach the model after the state blocks, in the order you send them.
On an image block the resolution field can be low, medium, high or ultra_high; on a video block low, medium or high, and ultra_high on a video returns 400 invalid_request. The resolution sets how many tokens the file takes; for images that need no detail, low uses fewer tokens.
A line break is put between two adjacent text blocks when the first does not end in whitespace, so texts are never glued together.
An object is read as a content block when its type names a block and it carries one of that block's fields (text, data, uri, mime_type, resolution or image_url); any other object is JSON data. A state sent as an object is read as JSON text; a single content block ({"type": "image", "data": ...}) is read as that block. An array with no string or content block in it is read as JSON text too. An array that mixes content blocks with other data returns 400 invalid_request.
A question's instructions is text only; media goes in the state. An instructions carrying JSON data (an object, or an array with no string or text block in it) is read as JSON text.
The request body is limited to 24 MB including base64, and base64 encoding makes a file about a third larger.

Jev experimental features

typesafe/jev and typesafe/jev-1.14.0 accept images and a longer context; typesafe/jev-1.14.0 also answers Box questions. The provider offers these features as experimental and does not recommend them for production; the request format, answers and limits can change between versions. Each feature is switched on per request with a header; requests without the header are unchanged.

Images

Send the TypeSafe-Danger-Zone-Images: true header and add the images to a top-level assets map. Each image is listed once under a reference key. Write the reference where the image belongs (in the state, in a question's instructions or in criteria values) and the image takes its place. In questions, refer to an image by its name in backticks (`photo`).

curl "$LLMTR_BASE_URL/v1/systemone" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -H "TypeSafe-Danger-Zone-Images: true" \
  -d '{
    "model": "typesafe/jev-1.14.0",
    "state": { "photo": "photo-1" },
    "assets": {
      "photo-1": { "type": "image", "format": "png", "data_base64": "iVBORw0KGgo..." }
    },
    "questions": {
      "color": {
        "type": "choice",
        "instructions": "What color is the shirt the person in `photo` is wearing?",
        "criteria": { "navy": null, "white": null, "red": null }
      },
      "shoes": { "type": "box", "instructions": "the shoes of the person in `photo`" }
    }
  }'

format is png, jpg or jpeg. data_base64 is standard base64 with no data: prefix and no line breaks. Images are accepted in a JSON body only; multipart uploads are not accepted.
An image must be PNG or JPEG, between 280 and 1568 pixels on each side, and at most 16 MiB. An image outside these limits is not resized: a file over 16 MiB, or a file that is not PNG or JPEG, returns 400 invalid_request; an image with dimensions outside the limits returns 400 provider_error. The request body is limited to 24 MB in total, and base64 encoding makes a file about a third larger.
Every listed image must be referenced somewhere. Using a reference in more than one place adds the image again each time, and it is counted again.
A reference can be at most 1,024 bytes and all references together at most 65,536 bytes; once the images are put in place, the request cannot exceed 32 MiB. A request over these totals returns 413 provider_error.
An image in the state is evaluated with every question; an image in a question's instructions goes to that question only. When several questions look at the same image, put it in the state.
An image counts as input tokens at the same price as text, arrives in usage.input_tokens and counts toward the context limit.
assets is accepted on the Jev models only; on any other model it returns 400 invalid_request.

Long context

The default limits are 32K tokens per question (the state with one question) and 64K tokens per request (the state with all questions). With the TypeSafe-Danger-Zone-Long-Context: true header both limits become 262K tokens. The token price does not change. According to the provider, long-context requests are slower and less accurate; turn it on only when you need it.

Leyla with Turkish text

When you send a Turkish state to llmtr/leyla, this way of writing the request gives the best results:

Noul and Score: write instructions and the Score level names in English ("Does the customer ask for a refund?"). The text itself can stay in Turkish.
Choice: write the option descriptions (the criteria values) in Turkish, as short keywords ("fatura, ödeme, iade"). Longer descriptions do not improve the result.
Catch-all option: do not rely on an option such as other being picked. If the highest probability is low (for example below 0.6), treat the result as undecided and route it to a person.
Before going live: measure multi-option classification on your own real examples (at least 50-100) and set your thresholds from that.

Keep the text short: the model works with a 1,024-token context (512 on llmtr/leyla-english). Text past the context returns no error; it is cut and the cut part is not evaluated, so choose the part the decision needs.

Billing

Only input tokens are billed; output tokens are free. The usage field in the response carries both counts.

The Jev models, greenpt/metis and the Drex models count the state once; combine the questions about one state into one request. upstage/solar-decide, fastino/glide, Perplexity Decider and the Leyla models count the state for every question; send only the questions you will use. scaledown/classify-free counts the state for every question too. liquid/d1-ultra counts the state and every image for every question. nace/drex-max-finance counts both the state and the images once. The Baseten models count the state, with the images in it, once too. On hume/audio-decision-model the count depends mostly on the recording's length; the text of the questions and of state counts too.

morph/reflex counts the state, the images and instructions for every question. Repeated input, such as the state for the further questions of a request or a request sent again, can be read from the cache; the cache works on its own, with no flag or id. The part read from the cache is billed at $0.008 per 1M tokens and the rest of the input at $0.042, and it is shown in usage.input_tokens_details.cached_tokens in the response. Short requests may not be cached; send the questions about one state in one request. The max_budget_usd estimate uses the uncached price.

google/gemini-decision-1 counts the shared input (the state, images and audio) once per request, whatever the number of questions; each question adds tokens for its own text and format. Image, audio, video and PDF tokens are billed at the same price as text; there is no cache. For a request with media the estimated cost is taken over the whole context window (about $0.026); if max_budget_usd is lower, a request with media is refused before it is sent. The final charge is computed from usage.input_tokens in the response.

Platform margin is not added to model prices; the margin applies to credit top-ups only. Because the provider publishes its price in euros, the greenpt/metis price in the table is the euro price converted to USD at the European Central Bank rate plus an 8% exchange-rate allowance, so it is not the provider's published figure as is. See Billing for details.

Limits

LLMTR accepts at most 1,000 questions per request; more are refused with 400 invalid_request. When a model's own limit is lower, the value in the table below applies: on the Leyla models a request over 64 returns 413 provider_error, on the Perplexity Decider models a request over 128 returns 400 provider_error, on greenpt/metis a request over 32 returns 422 provider_error, on nace/drex-v2.0 and nace/drex-max-finance a request over 512 returns 400 invalid_request. On the Baseten models a request carrying more than 512 answer options in all (each noul question counts as 2) returns 400 invalid_request. hume/audio-decision-model takes at most 25 questions (Noul, Choice and Score together 20, Span 5); its limits are on the Audio decisions page.

Limit	Jev models	`upstage/solar-decide`	`fastino/glide`	`greenpt/metis`	Perplexity Decider	Leyla models	`nace/drex-v2.0`	`nace/drex-max-finance`	`liquid/d1-ultra`	`scaledown/classify-free`	Baseten models	`morph/reflex`	`google/gemini-decision-1`
Request size	each question together with `state`, 32K tokens; `state` and all questions together, 64K tokens; both 262K with the long-context header	`state` at most 1 MiB	each question together with `state`, 40,000 tokens	`state`, `questions` and the model's fixed prompt together, 32,768 tokens	each question together with `state`, under 262,144 tokens	`state` at most 50,000 characters	`state` at most 131,072 tokens, each question together with `state` at most 262,144 tokens; `state` and `questions` together at most 4 MiB	`state`, all images and all questions together at most 262,144 tokens; request body at most 4 MiB, images included	each question together with `state` and all images, 32,768 tokens or 250,000 bytes of text; request body under 4.5 MB	`state` at most 131,072 tokens	each question together with `state` and images must fit the 16,384-token context; at most 16 images per request	each question together with `state`, images and `instructions` must fit the 65,536-token context; at most 16 images per request; request body about 2.5 MB, base64 included	`state`, media and all questions together, 262,144 tokens; request body 24 MB, base64 included
Questions per request	1,000	1,000	1,000	32	128	64	512	512	1,000	1,000	bounded by 512 options in all (each `noul` counts as 2)	1,000	1,000
Choice options	no documented limit	2-26	at most 255	2-255 per question, at most 2,048 per request in all (each `noul` question counts as 2)	at most 255	at most 100; up to 20 recommended when options carry descriptions	no documented limit	at most 255	no documented limit	no documented limit	1-255 per question, at most 512 per request in all	at least 1; no documented upper limit	2-255
Score levels	at least 2	2-10	2-255	2-10	2-10	at most 32	at least 2	2-255	at least 2	2-10	2-10	2-10	2-255

On google/gemini-decision-1 a question key must be 1 to 64 letters, digits, _ or -. A choice option key can be at most 128 characters and cannot start or end with whitespace. A key that breaks these rules returns 400 invalid_request.

fastino/glide accepts only text in instructions; an object or array returns 422 provider_error.

On the Perplexity Decider models response time grows with the input; a request near the context limit can take close to a minute. Set your client timeout to at least 90 seconds.

This endpoint does not support streaming. The response arrives in one piece; there is no generated text to stream.

System One models do not appear in the Playground and cannot be called on chat endpoints; they answer on /v1/systemone only.

Errors

Status	Meaning
`400 invalid_request`	The request body does not match the schema. The message names the offending field. Also returned when `assets` or a Box question is sent to a model that does not answer them, for a Box question with no image it can see (the image must be in the `state` or in that question's `instructions`), and for an image over 16 MiB or not a PNG or JPEG file. Also returned when `images` is sent to a model that does not read that array, and on `liquid/d1-ultra` and `nace/drex-max-finance` for an image that is not a JPEG, PNG or WebP file, for more than eight images and for an image part in a `state` array (images go in the `images` array). On `nace/drex-max-finance` also for more than 512 questions, more than 255 options or levels in a question, an image over 40 million pixels and a body over 4 MiB with the images. On the Baseten models also for an image or file part in a plain `state` array or in `instructions` (images go in a user message of a conversation), a choice question with no option or more than 255, more than 10 levels in a score question and more than 512 answer options in the request. Also returned when `audio` is sent to a model that does not read it or a Span question to a model other than `hume/audio-decision-model`; for the audio model's own cases see Audio decisions. Also returned when the top-level `instructions` is sent to a model other than `morph/reflex`. On `morph/reflex` also for more than 16 images across the `images` array and the `state`, an image sent outside an `image_url` part (an `input_image` part or a bare data URL in the `state`), an `image_url` part carrying an address or a declared type that does not match the file, an image in a question, a choice question with no option and a score question with more than 10 levels. On `google/gemini-decision-1` also for media carrying a `uri` or an address, a file whose type does not match its block or field or is not supported, a question or option key that breaks the rules, fewer than 2 or more than 255 options or levels, and media in a question; the message names the `state` block or the question.
`400 content_filter`	The input was blocked by the model's safety filter (`google/gemini-decision-1`). Retrying with the same content gives the same result.
`403 provider_consent_required`	Your account has not given the data transfer consent for the model's provider (`greenpt/metis`). Consent is given in the Settings tab.
`404 model_not_found`	The model id is not in the catalog.
`410 model_retired`	The model was retired; the message gives the date. On the free Drex models, the free Baseten models and `scaledown/classify-free` it means the free offer has ended.
`400 unsupported_operation`	The model does not support this endpoint. The response lists the endpoints it does support.
`400 provider_error`	The model did not accept the request. On `fastino/glide`, if the message says the context window was exceeded, one of the questions does not fit together with the `state`; shorten the `state` or that question. On Perplexity Decider the message names the limit that was exceeded or the unsupported image address. On the Jev models the message names the problem: the images header is missing, an image is invalid or outside the size limits, or the request is over the context limit; for the last, shorten the request or send the long-context header. On `google/gemini-decision-1` the message either names where a file that could not be read is (a `state` block, an `images` position or `audio`) or says the request is over the model's limits (1,000 questions, 262,144 tokens); for the latter, reduce the `state` or the questions.
`413 provider_error`	The request exceeds the model's limit on questions, options or text length, on the Jev models the total limits for image references, or on `liquid/d1-ultra` the 4.5 MB body limit. Make the request smaller. On `morph/reflex` the request body is too large for the model; send fewer or smaller images. On `google/gemini-decision-1` too, the request body is too large for the model; shrink the files or split the request.
`422 provider_error`	A question definition or the `state` is in a shape the model does not accept, or exceeds that model's limit. The message carries which field is at fault. On `liquid/d1-ultra`, if the message says a question is over the 32,768-token limit, shorten the `state`, the images or that question; if it says an image cannot be read, save the file again as JPEG, PNG or WebP. On `nace/drex-max-finance` a message with the path `images.<index>` says that image could not be read or is over a limit; downscale it as a still JPEG, PNG or WebP and send it again. On the Baseten models, if the message says the state with one of the questions is over the token limit, shorten the `state` or that question; if it refuses where an image is or its address, put the image in a user message as a base64 data URL. On `morph/reflex`, if the message says a question is over the 65,536-token context, images included, shorten the `state`, the images or that question.
`429 rate_limit_error`	The API key's request limit was exceeded.
`502 provider_error`	The model could not complete the request. On Perplexity Decider, if a question together with the `state` goes over 262,144 tokens, the request returns this error after about a minute; shorten the `state`.
`503 model_busy`	The model is at capacity right now. Wait for the time in the `Retry-After` header and try again.
`503 model_unavailable`	The model is temporarily unable to answer. If the response carries a `Retry-After` header, wait that long.

See Errors for the error format.