Models and fallback

Each call uses a base model or one of your fine-tuned models. This page helps you choose one, and decide what happens when it can’t answer. To list the models, call GET /v1/models:

curl --fail-with-body https://api.sqwish.ai/v1/models \
  -H "Authorization: Bearer $SQWISH_API_KEY"

Each entry has its id, status, limits and availability. A listed model may be unavailable on the current deployment.

Base models

The kettei decision models come in three sizes, largest first:

Model	Reads images	Fine-tuning
`kettei-fat`	Yes	Not available
`kettei-chub`	Yes	Available
`kettei-core`	No	Available

A fine-tuned model reads text only, even from a size that reads images. kettei-fat v1.0 and kettei-chub v1.0 were released on 14 October 2026. Every model, fine-tuned ones included, takes up to 65,536 input tokens a request. They are counted the same way as for billing. max_input_tokens in /v1/models gives the limit. A request that names no model asks for kettei-core. Images explains how to send pictures, and how to send them fast.

Choose a size

To read images, use kettei-chub or kettei-fat. kettei-core reads no images.
A larger size costs more per input token. Pricing lists the price of each.
To fine-tune, start from kettei-core or kettei-chub. Fine-tuning kettei-fat is not available yet.
To see which size answers your decisions best, compare them on your own labelled data. Compare models shows how.

Your models

A fine-tuned model belongs to a family, such as support-router. Call it through the family, which answers with the model it serves. Or call it by its number, such as support-router@3. A fine-tuning job also produces an adapter ID. You can read it, but never call it. Call a family or a model says when each one answers.

Request	Lists
`GET /v1/models`	Base models and your fine-tuned models
`GET /v1/families`	Your families
`GET /v1/families/support-router`	One family, with its line of models (how a family grows)

For reproducible comparisons, call an exact model such as support-router@3 with fallback: "none". Record the model and version each answer names. GET /v1/models also gives each of your fine-tuned models a request_latency: the median time of your calls to it over the last seven days, and in samples how many calls that counts. To keep a fine-tuned model loaded between calls, see Keep a model warm.

Choose fallback

Fallback applies only when the model you asked for can’t answer at that moment, for availability or capacity reasons. Invalid inputs and policy errors still return errors.

`fallback`	If the requested model can’t answer
`"auto"`, the default	The base sizes that are serving are tried in turn, largest first. A fine-tuned model tries its own base size first, because it behaves most like the fine-tune. Earlier fine-tuned models are never tried
`"none"`	You get the error, not another model’s answer
A list of up to four families or models	They are tried in order after the requested model. One that doesn’t answer calls is passed over: switched off, serving no model, deleted or discarded

{
  "model": "kettei-core",
  "fallback": "none",
  "context": "Please refund the duplicate charge on order 4471.",
  "decisions": [{"id": "refund", "kind": "binary", "question": "Is a refund requested?"}]
}

Send that body to /v1/decide with your key. When another model answers, the response has fallback.from, fallback.to and fallback.reason. Check fallback before you attribute a result to the model you asked for. Depending on your application, you might accept the answer, send it for review or mark it in an evaluation. Metering explains how a fallback’s answer is charged.

Readiness and cold starts

GET /v1/models/{model_id}/ready answers ready. When a call sent at that moment wouldn’t run, it also gives a reason. It loads and runs nothing, and costs nothing. ready is true for a fine-tuned model that isn’t loaded, so its first call can still wait for a load. Check ready, not the HTTP status: a 200 doesn’t mean the model is ready. You might then wait, send the call anyway or choose another model. A fine-tuned model that isn’t kept warm can be unloaded to make room for another model. The next call to an unloaded model loads it again. This is a cold start, and it can take several seconds, so the first call after a quiet spell is slower. The call waits up to 10 seconds. If the load takes longer, the load carries on, and the call gets:

`fallback`	The call gets
`"auto"` or a list	An answer from the next model that fallback tries, such as the base size, with `fallback.reason` `model_warming`
`"none"`	`503 model_warming` with `Retry-After: 5`. Nothing is charged

The Idempotency-Key keeps that 503, so retryable is false. Wait 5 seconds, then send the request again with a new Idempotency-Key. The SDKs can do this for you. Pass wait_for_warm=30 in Python, or waitForWarm: 30 in TypeScript. Both values are in seconds (retries).

Get started

Make decisions

Improve accuracy

Use the API

Account and billing

Privacy and security

Integrations