POST /v1/decisions

Ask a decision model typed questions about a state, and get one typed answer per question. A decision model does not write text. You send a state (a message, a ticket, a record) and your questions. 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.

The catalog has ten decision models:

The question format follows the model. Every call has the same envelope: model and state in, answers and usage out. The questions go in the model's own form: a questions map for the System One models, a schema object for GLiNER. What goes inside a question, and what comes back inside an answer, is the model's own format. Nine models share one format, System One (TypeSafe's): Jev, Mercury Decide, Nimble, Clef, Clef-flash, Decider 2B, Kev 4B, Perplexity Decider and Sage. A body written for one runs on the others with only model changed, when it is inside each model's limits. A question in another model's format is a 400. The ten are different models, so the gateway never fails over from one to another.

The gateway calls these endpoints:

For Jev you send one request shape. The gateway sends each provider the id it expects, and you get one answer shape back, whichever provider served it. If TypeSafe fails before it answers (overloaded, down, rate limited), the gateway tries OpenRouter. Mercury Decide, Nimble, Clef, Clef-flash, Decider 2B, Kev 4B, Perplexity Decider, Sage and GLiNER have one provider each, so their requests have no second provider to try. On Workers AI, {account_id} is our Cloudflare account, and the path names the model. Decider 2B and Kev 4B share one RouterPlus deployment: one pool and one health circuit serve both. The x-tm-provider header names the provider that answered.

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

Authentication

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

Request

JSON body, 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.

System One questions

Eight models take the same question format, TypeSafe's System One: Jev, Mercury Decide, Nimble, Clef, Clef-flash, Decider 2B, Kev 4B and Perplexity Decider. Everything in this section holds for each of the eight; only model differs, and Nimble, Clef, Clef-flash, the two RouterPlus models and Perplexity Decider have some limits of their own (see Bespoke Nimble v3, Clef and Clef-flash, Decider 2B and Kev 4B and Perplexity Decider v1 27B). The examples show Jev; put another System One model's id in model, for example inception/mercury-decide, bespokelabs/nimble-v3, cloudflare/clef, routerplus/decider-2b or perplexity/pplx-decider-v1-27b, and the same body runs on that model.

State. A non-empty string, or any JSON object or array (a chat log, a record, application state). Questions 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 in a question 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 is cheaper and faster than ten calls. Perplexity Decider and Sage are the exceptions: they read and bill the state once per question, so on them one call saves round trips, not tokens (see Perplexity Decider v1 27B and Sage 1.2).

{
  "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" }
    }
  }
}

Mercury Decide

Inception's Mercury Decide is a System One model: the state, the questions and the answers above are its format too. What is its own:

A free endpoint is, in OpenRouter's own words, not production-suitable. For a decision that must come back, keep Jev as your System One fallback in your own code: the gateway never fails over between models.

Bespoke Nimble v3

Bespoke Labs' Nimble is a System One model: the state, the questions and the answers above are its format too. The gateway calls Bespoke's own API. What is its own:

Clef and Clef-flash

Cloudflare's Clef and Clef-flash are System One models: the state, the questions and the answers above are their format too. Clef-flash is the smaller model (9 billion parameters, against Clef's 27 billion): it is faster and costs less. The gateway calls Cloudflare's own API, Workers AI. What is their own:

Decider 2B and Kev 4B

RouterPlus is our own decision-model service. Its two models run on our own GPUs in the United States, and both are System One models: the state, the questions and the answers above are their format too. Each reads English. What is their own:

What holds for both:

Perplexity Decider v1 27B

Perplexity's Decider v1 27B is a System One model: the state, the questions and the answers above are its format too. The gateway calls Perplexity's own API. One thing sets it apart from the rest of the family, and it changes the cost: it reads and bills the state once per question. What is its own:

Sage 1.2

Levanto's Sage is a System One model: the state, the questions and the answers above are its format too. The gateway calls Levanto's System One API. Like Perplexity Decider, it reads and bills the state once per question. What is its own:

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 from it.

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. The gateway checks it and forwards it as it is. 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 matter: 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 exactly as you sent it.

The task name is the question. A classification has no instructions field. GLiNER reads the task name, so a task name can be a question: 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. Two results with one name would overwrite each other at Fastino without an error. So the gateway refuses 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 as they are. 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

These parts of Fastino's API are not reachable through the gateway today:

• 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, and none offers prompt caching, so cache_control has nothing to act on. RouterPlus's answer cache (see Decider 2B and Kev 4B) is not prompt caching: it works by itself on a whole identical request, and cache_control does not reach it. A top-level field that the model does not take is dropped and recorded (D8 §2), 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 would-be drop 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

The shape is the same from both of Jev's providers, from Mercury Decide (with "model": "inception/mercury-decide" and "cost": 0), from Nimble (with "model": "bespokelabs/nimble-v3" and its numbers at full precision), from Clef and Clef-flash (with "model": "cloudflare/clef" or "model": "cloudflare/clef-flash", its numbers to 4 decimals and "output_tokens": 0), from Decider 2B and Kev 4B (with their catalog ids in model) and from Perplexity Decider (with "model": "perplexity/pplx-decider-v1-27b", its numbers at full precision and one output token per question):

{
  "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, exactly as the provider returned them.

GLiNER answers

answers is GLiNER's own result, verbatim: the JSON that Fastino returns as a string in choices[0].message.content, parsed into an object. The gateway adds nothing and removes nothing. 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 is the sign 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, plus entities and relation_extraction when you asked for them. Anything else is an upstream_error and costs nothing.

Usage and headers

Response headers: x-request-id, x-tm-provider (typesafe, openrouter-decisions, openrouter-decisions-free, bespokelabs, workers-ai, routerplus, perplexity-decisions, levanto or fastino), x-tm-served-by (the provider OpenRouter names, when it names one: Inception for Mercury Decide), x-tm-upstream-model (the provider's own name for the model, for example clef or clef-flash from workers-ai, decider-2b from routerplus, pplx-decider-v1-27b from perplexity-decisions), x-tm-attempts, x-tm-upstream-status, x-tm-discount-percent when a discount applied and, when something was dropped, x-tm-dropped-params.

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. Jev, Nimble, Clef, Clef-flash, Perplexity Decider, Sage and GLiNER charge for input only. Mercury Decide is $0 both ways while OpenRouter serves only its free variant; a paid variant, or Inception serving it directly, would be a new listed price, and this page would say so. Decider 2B and Kev 4B run on RouterPlus, our own service, and they are free: $0 in and out, so usage.cost is 0 on every call. Each charge rounds down to the micro-dollar. Perplexity Decider bills the state once per question (see Perplexity Decider v1 27B): its cost grows with the number of questions as well as with the state.

If a provider answers 200 without a usage object, the gateway bills its own estimate, the same amount it reserved, and marks the attempt estimated. For GLiNER it 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. A 200 that does not answer every question, or whose GLiNER content is not the object described in GLiNER answers, is an upstream_error and costs nothing. After a provider answers 200, the gateway never sends the same request to a second provider.

Discount

A discount may apply to decision models: to every decision model, or to some of them, each at its own percent. It applies from every key, including the playground's. The list price does not change, and the discount can change or end: read it from each response, not from this page. 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, so a new account must complete verified browser sign-in and buy credits before its first decision.

On Mercury Decide, 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, as on every model it covers, so your code can read one shape for all ten.

Errors

Errors use the gateway's normal shape — see Errors.

Jev reads at most 64 000 tokens per request through TypeSafe (32 000 for the state plus the longest question), and 32 000 through OpenRouter. Mercury Decide reads at most 32 768 tokens per request. Sage reads at most 32 768 tokens per request, the state and every question together. Nimble reads at most 32,768 tokens for each question's prompt, the state included, and never cuts a prompt. Clef and Clef-flash read at most 65,536 tokens per request, the state and every question together, as Cloudflare estimates them (about 4 characters a token); Cloudflare refuses a longer request with the 413 context_overflow above. Decider 2B's context is 25,600 tokens and Kev 4B's 8,192. GLiNER-2.5-Decide's context is 8,192 tokens. A request above a provider's limit is refused by that provider. Decider 2B cuts it instead, and bills only the tokens the model read; Kev 4B refuses it with a 400. See Decider 2B and Kev 4B. Perplexity Decider reads at most 262,144 tokens for each question's prompt (the state and that question), and never cuts one: Perplexity refuses a longer one with the 400 context_overflow above. See Perplexity Decider v1 27B.

Examples

Jev

curl https://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?"}}}'

import os, httpx

r = httpx.post(
    "https://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://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);

Mercury Decide

The same System One body as for Jev, under Mercury Decide's id. A 429 rate_limit here is either our pool (wait retry-after) or OpenRouter's daily cap on free requests (wait for its reset): switch on the class, as Errors says, and read the message.

curl https://api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"inception/mercury-decide",
       "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://api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "inception/mercury-decide",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "team": {"type": "choice", "instructions": "Which team?",
                     "criteria": {"billing": "Payments", "technical": "Bugs"}},
            "angry": {"type": "score", "instructions": "How angry is the customer?",
                      "criteria": ["Calm", "Mild", "Moderate", "Upset", "Furious"]},
        },
    },
)
if r.status_code == 429:
    print("rate limited:", r.json()["error"]["message"], "retry after", r.headers.get("retry-after"))
else:
    answers = r.json()["answers"]
    print(answers["team"]["choice"], answers["angry"]["score"], r.json()["usage"]["cost"])  # cost is 0

const r = await fetch("https://api.routerplus.com/v1/decisions", {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.TM_API_KEY}`, "content-type": "application/json" },
  body: JSON.stringify({
    model: "inception/mercury-decide",
    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); // 0.95, 0

Nimble

The same System One body as for Jev, under Nimble's id. Keep to Nimble's limits: 1 to 64 questions, and 2 or more options in a choice.

curl https://api.routerplus.com/v1/decisions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"bespokelabs/nimble-v3",
       "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://api.routerplus.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['TM_API_KEY']}"},
    json={
        "model": "bespokelabs/nimble-v3",
        "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://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-v3",
    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

The same System One body as for Jev, under Clef's or Clef-flash's id. Keep to Clef's limits: 1 to 64 questions, ids of 1 to 100 letters, digits, _, . or -, and 2 or more options in a choice.

curl https://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://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://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

The same System One body as for Jev, under Decider 2B's id. For Kev 4B, change only model. A first request after a quiet period can take 15 to 20 s while the model starts, so give your client a timeout above 60 s, the gateway's own wait.

curl https://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://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://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

The same System One body as for Jev, under Perplexity Decider's id. Keep to its limits: 1 to 128 questions, and text or JSON only. Each question is billed with the whole state, so ask only the questions you need.

curl https://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://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://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);

Sage

The same System One body as for Jev, under Sage's id. Each question is billed with the whole state, so ask only the questions you need.

curl https://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

curl https://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://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://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://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://app.routerplus.com/api/models.json. The Anthropic shape of GET /v1/models never lists them.