Decisions

Ask a decision model typed questions about a state (a message, a ticket, a record) and get one typed answer per question. A decision model does not write text. Each answer is a choice, a score, a yes/no, an order, a set of tags or extracted fields, with the probability or confidence behind it. Use it for routing, classification, moderation and other decision points in your code.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"typesafe/jev-1.13",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

No SDK has a decisions method. Send plain HTTP.

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "typesafe/jev-1.13",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {"team": {"type": "choice", "instructions": "Which team?",
                               "criteria": {"billing": "Payments", "technical": "Bugs"}}},
    },
)
answer = r.json()["answers"]["team"]
print(answer["choice"], answer["confidence"])

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "typesafe/jev-1.13",
    state: { ticket: "Help! My payouts have been failing for 3 days." },
    questions: { urgent: { type: "noul", instructions: "Is `ticket` urgent?" } },
  }),
});
const { answers, usage } = await r.json();
console.log(answers.urgent.noul, usage.cost);

Models

The catalog has twelve decision models:

The gateway also accepts bespokelabs/nimble-latest, which no list shows. Bespoke picks the model that answers it. See Bespoke Nimble.

Every call has the same envelope: model and state in, answers and usage out. The questions use the model's own format:

• Eleven models share one format, System One (TypeSafe's): Jev, the two Nimble models, Clef, Clef-flash, Decider 2B, Kev 4B, Perplexity Decider, GPT-6 Luna Decisions, Sage and ScaleDown Classify-1. They take a questions map. A body written for one of them runs on the others with only model changed, within each model's limits. ScaleDown Classify-1 bills each question as its own call.
• GLiNER takes a schema object: classifications, entities, structures, relations.
• A question in another model's format is a 400.
• The twelve are different models, so the gateway never fails over from one to another.

The gateway calls these endpoints:

Each decision model has one provider, so a request has no second provider to try. The Nimble models share one Bespoke deployment: one pool and one health circuit serve all of them.

• Decider 2B and Kev 4B share one RouterPlus deployment: one pool and one health circuit serve both.
• On Workers AI, {account_id} is our Cloudflare account, and the path names the model.
• OpenAI's API does not speak System One. The gateway translates your body into OpenAI's format, and OpenAI's answers back into Jev's shape (see GPT-6 Luna Decisions).
• The x-tm-provider header names the provider that answered.

To compare the models without code, use Decision in the playground. It translates one set of questions for each model.

Authentication

A missing or invalid key returns 401 with error_type: "auth".

Request

The body is JSON, at most 1 MB (413 request_too_large above that). The gateway checks every rule on this page before it reserves money or calls a provider. A refused request has no ledger row, no x-tm-attempts header and no charge.

Model names that are not ids, and provider ids:

System One questions

Nine models take the same question format, TypeSafe's System One: Jev, the two Nimble models, Clef, Clef-flash, Decider 2B, Kev 4B, Perplexity Decider and GPT-6 Luna Decisions. This section holds for each of the nine. Some models add limits of their own: see Bespoke Nimble, Clef and Clef-flash, Decider 2B and Kev 4B, Perplexity Decider v1 27B, GPT-6 Luna Decisions and Sage 1.2.

The examples use Jev. To run them on another System One model, change model.

State. A non-empty string, or any JSON object or array (a chat log, a record, application state). A question can point at a field by name: "Is `ticket.body` urgent?".

Questions. Every question has a type, instructions and, for most types, criteria. instructions is a non-empty string, or a JSON object or array: put the question in one field and the data it refers to in others.

• A question takes only type, instructions and criteria. Any other field is a 400 that names it.
• A question with kind (the format of Levanto's own /decide API) is a 400 that says the model takes System One questions.
• Ask many questions in one call. The model reads the state once and answers every question against it, so one call with ten questions costs less and returns sooner than ten calls.
• Exceptions: Perplexity Decider and Sage read and bill the state once per question. GPT-6 Luna Decisions bills the state once per call, but each question adds about 150 input tokens.
• confidence is not the chance that the answer is right. Some models compute it their own way (see each model's Numbers row). Tune a threshold on the model you use, or use the probabilities.

{
  "model": "typesafe/jev-1.13",
  "state": { "ticket": "Help! My payouts have been failing for 3 days." },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle `ticket`?",
      "criteria": { "billing": "Payments, invoices, refunds", "technical": "Bugs, outages, integrations", "sales": null }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated is the customer?",
      "criteria": ["Calm", "Annoyed", "Angry"]
    },
    "urgent": {
      "type": "noul",
      "instructions": "Is this urgent?",
      "criteria": { "true": "Explicitly time-sensitive", "false": "No urgency expressed" }
    }
  }
}

The sections below list the limits and behavior of each System One model. The gateway checks the rules above. It does not check each model's limits. The Playground's Decision mode does check them, before a run. If a body breaks a model's limits, the provider refuses it, and the gateway relays the refusal as an upstream_error with the provider's message, at no cost. Limits and failures covers the rules for every provider: pool limits, relayed 429s, the health circuit and refusals of our account.

Bespoke Nimble

The gateway calls Bespoke Labs' own API.

Clef and Clef-flash

The gateway calls Cloudflare's own API, Workers AI. Clef-flash is the smaller model (9 billion parameters, against Clef's 27 billion). It costs $0.09 per million input tokens, against $0.24 for Clef.

Decider 2B and Kev 4B

RouterPlus runs its own decision-model service. Both models run on our own GPUs in the United States, and each reads English.

Rules for both:

Perplexity Decider v1 27B

The gateway calls Perplexity's own API. This model reads and bills the state once per question, so the cost grows with the number of questions.

GPT-6 Luna Decisions

The gateway calls OpenAI's own API. OpenAI's API has its own format, so the gateway translates your System One body on the way out and OpenAI's answers on the way back.

Sage 1.2

The gateway calls Levanto's System One API. Like Perplexity Decider, Sage reads and bills the state once per question.

GLiNER schema

GLiNER-2.5-Decide is a small encoder model. It reads one text and fills in a schema. It classifies the text against your labels, and it can extract entities, structured fields and relations.

State. Text only: a non-empty string, or {"kind": "text", "value": "..."}. A list, an image or any other state is a 400 that names the field. To judge a record, send it as text, for example the JSON as a string.

Schema. GLiNER takes no questions. It takes schema, Fastino's own schema object, which the gateway checks and forwards unchanged. schema has only these four keys. Send at least one, and each key you send must be non-empty (an empty list or object is a 400 that names the key). A flat list in place of the object is a 400 (Fastino has deprecated it).

• Labels are plain strings. A label cannot be an object with a description. To describe a label, put the description in the label itself: "credit: store credit". Descriptions change results. On the same refund ticket, the labels refund, credit, deny chose refund, and the same labels with descriptions chose credit. The answer carries the label text as you sent it.
• The task name is the question. A classification has no instructions field. GLiNER reads the task name, so a task named "Does the customer ask for money back?" with the labels ["yes", "no"] is a yes/no question.
• Result names share one namespace. GLiNER puts every result at the top level of its answer: each task under its task name, each structure under its structure name, the entities under entities and the relations under relation_extraction. At Fastino, two results with one name overwrite each other without an error. The gateway refuses such a collision with a 400 that names both, for example a task named entities in a request that also asks for entities.

{
  "model": "fastino/gliner-2.5-decide",
  "state": "I was charged twice for my March invoice. Please refund the order from Acme Corp. Signed, Jane Doe.",
  "schema": {
    "classifications": [
      { "task": "action", "labels": ["refund", "credit", "deny"] },
      { "task": "issues", "labels": ["double_charge", "angry_customer", "fraud"], "multi_label": true }
    ],
    "entities": ["person", { "name": "organization", "description": "business or institution name" }]
  }
}

GLiNER options

Three optional top-level fields go to Fastino unchanged. Leave them out to use Fastino's defaults.

• A single-label task returns its top label only. top_k does not add more labels to the answer.
• When no label reaches the threshold, the task's answer is null. Set "cls_threshold": 0 on the task to always get the top label and its confidence.
• A task with multi_label: true returns every label at or above the threshold, so "cls_threshold": 0 returns every label with its confidence.

Store

Fastino keeps each inference unless the request says store: false. The gateway always sends store: false. A store field that you send is dropped and recorded, never forwarded. Our Fastino account also has Zero Data Retention on, so Fastino does not train on your text. See Data policy.

Not offered yet

The gateway does not reach these parts of Fastino's API:

• Fine-tuned GLiNER models (Fastino's training-job ids).
• Fastino's own batch and async routes.
• Several messages. The gateway sends Fastino one user message: the state. GLiNER does not read a system message.

Parameters that do not apply

Decision models take no sampling or output controls. The gateway forwards no temperature, max_tokens, stream, seed, user or metadata to them. None offers prompt caching, so cache_control does nothing. RouterPlus's answer cache (see Decider 2B and Kev 4B) is not prompt caching, and cache_control does not reach it.

A top-level field that the model does not take is dropped and recorded, never forwarded. RouterPlus's own truncate and cache fields are dropped in this way:

The dropped names are in the x-tm-dropped-params response header and on the attempt's ledger row. To refuse instead, send "provider": {"require_parameters": true}. A field that would be dropped is then a 400 before any money is reserved.

Response

HTTP 200, application/json. Every decision model uses the same envelope: id, object, model, answers and usage.

System One answers

Every System One model returns this shape. The differences:

{
  "id": "5d0c1c4e-3f7a-4c55-9d1b-2f0e7f6f2a10",
  "object": "decision",
  "model": "typesafe/jev-1.13",
  "answers": {
    "team": { "type": "choice", "choice": "billing",
              "probabilities": { "billing": 0.88, "technical": 0.12, "sales": 0 }, "confidence": 0.81 },
    "frustration": { "type": "score", "score": 1.05,
                     "legend": { "0": "Calm", "1": "Annoyed", "2": "Angry" },
                     "probabilities": { "0": 0, "1": 0.95, "2": 0.05 }, "confidence": 0.92 },
    "urgent": { "type": "noul", "noul": 0.95 }
  },
  "usage": { "input_tokens": 436, "output_tokens": 71, "cost": 0.000018 }
}

answers holds one typed answer per question, under the ids you sent, as the provider returned them. GPT-6 Luna Decisions can also return {"type": "refusal"} for a question that OpenAI declined (see GPT-6 Luna Decisions). Check each answer's type before you read its value.

GLiNER answers

answers is GLiNER's result, unchanged. Fastino returns it as a JSON string in choices[0].message.content, and the gateway parses it into an object. For the request in GLiNER schema:

{
  "id": "0b7e4c2a-6f1d-4a39-9c85-3e2d1f7a8b64",
  "object": "decision",
  "model": "fastino/gliner-2.5-decide",
  "answers": {
    "action": { "label": "refund", "confidence": 0.9327635765075684 },
    "issues": [ { "label": "double_charge", "confidence": 0.872347354888916 } ],
    "entities": {
      "person": [ { "text": "Jane Doe", "confidence": 0.99609375, "start": 90, "end": 98 } ],
      "organization": [ { "text": "Acme Corp", "confidence": 0.98828125, "start": 71, "end": 80 } ]
    }
  },
  "usage": { "input_tokens": 33, "output_tokens": 91, "cost": 0 }
}

• A confidence is not a calibrated probability. It is GLiNER's score for that label or span, from 0 to 1. Multi-label confidences are independent and do not sum to 1. Compare them within one model, not with System One's probabilities.
• GLiNER has no "not sure" answer. A low confidence shows that it is unsure.
• The gateway accepts a 200 only when the content parses to a JSON object with every task and structure name you asked for, plus entities and relation_extraction when you asked for them. Anything else is an upstream_error and costs nothing.

Usage and headers

Billing

A decision is metered like any other request: key limits, the reservation, the ledger and usage.cost all work as on the chat routes. Every decision model is priced per million tokens. Each charge rounds down to the micro-dollar.

Decider 2B and Kev 4B are free. The other models charge for input only. On Perplexity Decider and Sage the cost grows with the number of questions as well as with the state.

A dash means the model has no cached-input price.

If a provider answers 200 without a usage object, the gateway bills its own estimate (the amount it reserved) and marks the attempt estimated:

• For GLiNER, the estimate comes from the size of the text and from the tasks, labels and extraction keys in the schema.
• For Perplexity Decider and Sage, it counts the state once per question.
• For GPT-6 Luna Decisions, it counts 192 tokens for each question.

These 200s are an upstream_error and cost nothing:

• A 200 that does not answer every question.
• A GLiNER 200 whose content is not the object described in GLiNER answers.
• A GPT-6 Luna Decisions 200 that answers a question in another type, or with an option or a level that was not asked.

After a provider answers 200, the gateway never sends the same request to a second provider.

Discount

A discount may apply to some or all decision models, each at its own percent, from every key, including the playground's. The list price does not change. The discount can change or end, so read it from each response. A discounted model's row in /api/models.json carries discount_percent, and its page shows the percent beside the struck list price.

• usage.cost is what you pay, after the discount.
• usage.cost_before_discount is the list price of the request.
• usage.discount_percent and the x-tm-discount-percent header give the percent.
• When no discount applies, these three are absent.

A discounted charge is the list charge × (100 − percent) / 100, rounded down to the micro-dollar. At 100 % it is 0, and the request is still metered, limited and recorded in GET /v1/generation. The discount is for organizations with credit. A balance of $0 is refused with 429 insufficient_quota whatever the discount. A new account must complete verified browser sign-in and buy credits before its first decision.

On Decider 2B and Kev 4B the list price is already $0, so the discount changes nothing: usage.cost and usage.cost_before_discount are both 0. When a discount covers one of them, the percent is still reported, so your code can read one shape for all twelve.

Limits and failures

These rules hold for every decision model. Each model's section gives its own numbers.

Pool limits. Each deployment has a pool with limits on requests a minute, tokens a minute and requests in flight. Each organization may use 75 % of each. Your organization's own limits bind first: by default 300 requests a minute, 1,000,000 tokens a minute and 8 in flight (see Rate limits & spend caps). A burst above any limit is a 429 rate_limit from the gateway, before anything reaches the provider. It carries retry-after and the x-tm-limit-* headers. x-tm-limit-kind names the limit: rpm, tpm, concurrency, or cooldown for the pause after a relayed provider 429.

A provider's 429. The gateway relays it as 429 rate_limit with x-tm-upstream-status: 429, the provider's words, and its Retry-After when it sends one. The gateway then pauses the deployment's pool for that retry-after, at least 1 s and at most 60 s. A request inside the pause gets the gateway's own 429 rate_limit, with x-tm-limit-kind: cooldown, x-tm-limit-id: pool:… and no x-tm-upstream-status. A relayed 429 never counts against the deployment's health circuit.

The health circuit. A provider 5xx is a retryable upstream_error that counts against the deployment's health circuit: two in a row open it for 30 s, and in that window every request but one probe gets 503 gateway_error, "all deployments cooling down". Retry after a few seconds, with backoff. A 408, a provider's own timeout, is a retryable 504 upstream_error that does not count.

Our account. A 401, 402 or 403 from any System One provider refuses our account, never yours. You get 503 model_unavailable, "out of capacity at the provider". Each refusal counts against the circuit, so after two of them most requests get the 503 gateway_error above.

A provider's refusal. A 4xx that says the request is wrong is relayed as an upstream_error with the provider's words and x-tm-upstream-status. It is not tried on a second provider, and it costs nothing.

Context

Errors

Errors use the gateway's normal shape. See Errors.

Provider refusals (422 and other 4xx), by model. Each of these costs nothing.

• GLiNER. A Fastino 404 (an unknown upstream model id, which is our misconfiguration, never yours) is a 502 upstream_error, with x-tm-upstream-status: 404.
• Nimble: a request above Nimble's own limits (more than 64 questions, a choice with one option, or a question's prompt with the state above 262,144 tokens on Nimble v4, Nimble v4 Max or bespokelabs/nimble-latest) is Bespoke's 422, relayed with Bespoke's words.
• Clef and Clef-flash: a request outside Clef's own limits (more than 64 questions, a question id that does not match ^[A-Za-z0-9_.-]{1,100}$, or a choice with one option) is Cloudflare's 422 (code 5012) or 400 (code 5006), relayed with Cloudflare's words, for example upstream workers-ai returned 422: Request body failed validation: questions: Dictionary should have at most 64 items after validation, not 65.
• Decider 2B and Kev 4B: a request that RouterPlus refuses is RouterPlus's 400, relayed here with RouterPlus's reason and x-tm-upstream-status: 400. RouterPlus refuses a malformed question (invalid questions, then the reason for each question id, for example score needs criteria: a list of 2 to 10 levels) and a Kev 4B request above 8,192 tokens (the question's id, then ContextOverflow: branch too long).
• Perplexity Decider: a request with more than 128 questions is Perplexity's 400, relayed with Perplexity's words (Each request needs between 1 and 128 questions).

Refusals of our account (503 model_unavailable), by model:

• Sage: Levanto refused our account (its 401, 402 or 403, for example when our month's usage is used up).
• GLiNER: Fastino refused our account for credit or billing (its 402 or 403).
• Nimble: Bespoke refused our account for credit (its 402). metadata.retryable is false.
• Clef and Clef-flash: Cloudflare refused our account, for our token or plan (its 401 or 403), or because the account's free daily allocation is used up (its 429 with code 3036, until 00:00 UTC). metadata.retryable is false.
• A 401, 402 or 403 from any System One provider is handled the same way. That covers TypeSafe (Jev), RouterPlus (Decider 2B and Kev 4B), Perplexity (Perplexity Decider) and OpenAI (GPT-6 Luna Decisions).

On a connection with your own provider key, that provider's 401, 402 or 403 is your account, and it keeps its status. Other models are not affected.

Provider failures (5xx and 529), by model. Each 5xx counts against the circuit, as in Limits and failures.

• Sage: Levanto answers 503 while Sage loads. Retry after a few seconds.
• GLiNER: Fastino answers 425 or 503 while GLiNER starts (a cold start). A cold start can also outlast the gateway's wait for a decision (60 s, a 504). Both are a retryable upstream_error, so retry after a few seconds.
• Nimble, Clef, Decider 2B and Kev 4B, Perplexity Decider and GPT-6 Luna Decisions: see the Busy row in each model's section. A Perplexity 504 is an HTML page, so the message has no words of Perplexity's.

Examples

The examples at the top of this page use Jev. The examples below send the same System One body to other models, then a GLiNER schema.

Nimble

Send the Jev body under a Nimble model's id, or bespokelabs/nimble-latest to let Bespoke pick. Keep to 1 to 64 questions, and 2 or more options in a choice.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"bespokelabs/nimble-v4",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "bespokelabs/nimble-v4",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "team": {"type": "choice", "instructions": "Which team?",
                     "criteria": {"billing": "Payments", "technical": "Bugs"}},
            "urgent": {"type": "noul", "instructions": "Is this urgent?"},
        },
    },
)
answers = r.json()["answers"]
print(answers["team"]["choice"], answers["urgent"]["noul"])  # e.g. billing 0.997817283712868

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "bespokelabs/nimble-v4",
    state: { ticket: "Help! My payouts have been failing for 3 days." },
    questions: { urgent: { type: "noul", instructions: "Is `ticket` urgent?" } },
  }),
});
const { answers, usage } = await r.json();
console.log(answers.urgent.noul, usage.input_tokens, usage.cost);

Clef

Send the Jev body under Clef's or Clef-flash's id, within Clef's limits. The Node example uses Clef-flash.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"cloudflare/clef",
       "state":"Checkout has been failing for every customer for the last hour.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this support request urgent?"}}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "cloudflare/clef",
        "state": "Checkout has been failing for every customer for the last hour.",
        "questions": {
            "urgent": {"type": "noul", "instructions": "Is this support request urgent?"},
            "team": {"type": "choice", "instructions": "Which team should handle this request?",
                     "criteria": {"billing": "Payments and invoices", "technical": "Bugs and outages",
                                  "sales": "Plans and upgrades"}},
            "severity": {"type": "score", "instructions": "How severe is the customer impact?",
                         "criteria": ["No impact", "Minor", "Major", "Critical"]},
        },
    },
)
answers = r.json()["answers"]
team = answers["team"]
print(team["choice"], team["probabilities"][team["choice"]], team["confidence"])  # e.g. technical 0.8274 0.5654

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "cloudflare/clef-flash",
    state: { ticket: "Checkout has been failing for every customer for the last hour." },
    questions: { urgent: { type: "noul", instructions: "Is `ticket` urgent?" } },
  }),
});
const { answers, usage } = await r.json();
console.log(answers.urgent.noul, usage.input_tokens, usage.output_tokens); // output_tokens is always 0

RouterPlus models

Send the Jev body under Decider 2B's or Kev 4B's id. A cold start can take 15 to 20 s, so give your client a timeout above 60 s, the gateway's own wait.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"routerplus/decider-2b",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "routerplus/decider-2b",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "team": {"type": "choice", "instructions": "Which team?",
                     "criteria": {"billing": "Payments", "technical": "Bugs"}},
            "urgent": {"type": "noul", "instructions": "Is this urgent?"},
        },
    },
    timeout=70,
)
answers = r.json()["answers"]
print(answers["team"]["choice"], answers["urgent"]["noul"], r.headers["x-tm-upstream-model"])  # e.g. billing 0.97 decider-2b

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "routerplus/decider-2b",
    state: { ticket: "Help! My payouts have been failing for 3 days." },
    questions: { urgent: { type: "noul", instructions: "Is `ticket` urgent?" } },
  }),
  signal: AbortSignal.timeout(70_000),
});
const { answers, usage } = await r.json();
console.log(answers.urgent.noul, usage.input_tokens, usage.cost);

Perplexity

Send the Jev body under Perplexity Decider's id, with 1 to 128 questions. Each question is billed with the whole state, so ask only the questions you need.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"perplexity/pplx-decider-v1-27b",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "perplexity/pplx-decider-v1-27b",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {"urgent": {"type": "noul", "instructions": "Is this urgent?"}},
    },
)
body = r.json()
print(body["answers"]["urgent"]["noul"], body["usage"]["input_tokens"])  # e.g. 0.9297849172276498 95

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "perplexity/pplx-decider-v1-27b",
    state: { ticket: "Help! My payouts have been failing for 3 days." },
    questions: {
      team: { type: "choice", instructions: "Which team should handle `ticket`?", criteria: { billing: "Payments", technical: "Bugs" } },
      urgent: { type: "noul", instructions: "Is `ticket` urgent?" },
    },
  }),
});
const { answers, usage } = await r.json();
// Two questions: Perplexity bills the state twice.
console.log(answers.team.choice, answers.urgent.noul, usage.input_tokens, usage.cost);

GPT-6 Luna Decisions

Send the Jev body under GPT-6 Luna Decisions' id, with 1 to 200 questions and 2 or more options in a choice. Check each answer's type, because OpenAI can decline one question.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"openai/gpt-6-luna-decisions",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "openai/gpt-6-luna-decisions",
        "state": {"ticket": "Help! My payouts have been failing for 3 days."},
        "questions": {
            "team": {"type": "choice", "instructions": "Which team should handle `ticket`?",
                     "criteria": {"billing": "Payments, invoices, refunds",
                                  "technical": "Bugs, outages, integrations", "sales": None}},
            "frustration": {"type": "score", "instructions": "How frustrated is the customer?",
                            "criteria": ["Calm", "Annoyed", "Angry"]},
            "urgent": {"type": "noul", "instructions": "Is this urgent?",
                       "criteria": {"true": "Explicitly time-sensitive", "false": "No urgency expressed"}},
            "business": {"type": "noul", "instructions": "Is the customer a business?"},
        },
    },
)
for qid, answer in r.json()["answers"].items():
    if answer["type"] == "refusal":
        print(qid, "declined by OpenAI")  # billed, but no value
    else:
        print(qid, answer)

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "openai/gpt-6-luna-decisions",
    state: { ticket: "Help! My payouts have been failing for 3 days." },
    questions: {
      team: { type: "choice", instructions: "Which team should handle `ticket`?", criteria: { billing: "Payments", technical: "Bugs" } },
      urgent: { type: "noul", instructions: "Is `ticket` urgent?" },
    },
  }),
});
const { answers, usage } = await r.json();
// A declined question comes back as { type: "refusal" }, with no value.
for (const [id, a] of Object.entries(answers)) console.log(id, a.type === "refusal" ? "declined" : a);
// Two questions: about 150 input tokens each, on top of the state.
console.log(usage.input_tokens, usage.output_tokens, usage.cost); // output_tokens is always 0

A sample answer to the Python request:

{
  "id": "8c1f4b2e-7d3a-4e90-a6b5-1f2e3d4c5b6a",
  "object": "decision",
  "model": "openai/gpt-6-luna-decisions",
  "answers": {
    "team": { "type": "choice", "choice": "billing",
              "probabilities": { "billing": 1, "technical": 0, "sales": 0 }, "confidence": 1 },
    "frustration": { "type": "score", "score": 1.02,
                     "legend": { "0": "Calm", "1": "Annoyed", "2": "Angry" },
                     "probabilities": { "0": 0.03, "1": 0.92, "2": 0.05 }, "confidence": 0.88 },
    "urgent": { "type": "noul", "noul": 0.96 },
    "business": { "type": "noul", "noul": 0.49 }
  },
  "usage": { "input_tokens": 561, "output_tokens": 0, "cost": 0.000056 }
}

Sage

Send the Jev body under Sage's id. Each question is billed with the whole state, so ask only the questions you need.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"levanto/sage-1.2",
       "state":"Help! My payouts have been failing for 3 days.",
       "questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

GLiNER

Each answer sits under its task name.

curl https://dev2-api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"fastino/gliner-2.5-decide",
       "state":"Help! My payouts have been failing for 3 days.",
       "schema":{"classifications":[{"task":"Is this urgent?","labels":["yes","no"]}]}}'

import os, httpx

r = httpx.post(
    "https://demo-api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "fastino/gliner-2.5-decide",
        "state": "Help! My payouts have been failing for 3 days.",
        "schema": {"classifications": [{"task": "team",
                                        "labels": ["billing: payments", "technical: bugs"]}]},
    },
)
answer = r.json()["answers"]["team"]
print(answer["label"], answer["confidence"])  # a confidence, not a calibrated probability

const r = await fetch("https://demo-api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "fastino/gliner-2.5-decide",
    state: "Help! My payouts have been failing for 3 days.",
    schema: {
      classifications: [
        { task: "topics", labels: ["billing", "outage", "fraud"], multi_label: true, cls_threshold: 0 },
      ],
    },
  }),
});
const { answers, usage } = await r.json();
console.log(answers.topics, usage.input_tokens, usage.output_tokens, usage.cost);

Model discovery

curl -s "https://demo-api.routerplus.com/v1/models?output_modalities=decisions" \
  -H "Authorization: Bearer $TM_API_KEY"

Decision models carry architecture.output_modalities: ["decisions"] in GET /v1/models, and output_modalities: ["decisions"] in the public feed https://demo.routerplus.com/api/models.json. The Anthropic shape of GET /v1/models never lists them.