Choosing a tier

Compare kavi, vaani, and mira by profile, output cap, deadline, and reasoning default, then pick the tier that fits each call.

You choose a tier on every chat request with the model field. A tier is a stable public id: the gateway resolves it to an upstream model on the server and never exposes which one, so the tier is the contract your code depends on. GET /api/v1/models returns the live catalog, so read it at runtime instead of hardcoding what this page shows:

curl https://api.cruxy.ai/api/v1/models \
  -H "Authorization: Bearer $CRUXY_API_KEY"

const res = await fetch('https://api.cruxy.ai/api/v1/models', {
  headers: { Authorization: `Bearer ${process.env.CRUXY_API_KEY}` },
})
 
const { data } = await res.json()
for (const tier of data) {
  console.log(tier.id, tier.label, tier.profile, tier.max_output, tier.reasoning)
}

The three tiers

Each tier has a display name (label) and a one-word profile that names its role. The profile is a qualitative descriptor, not a performance number.

Tier	Label	Profile	Output cap	Non-streaming deadline
`kavi`	Kavi	Deep	8192 tokens	90 s
`vaani`	Vaani	Balanced	4096 tokens	90 s
`mira`	Mira	Fast	2048 tokens	45 s

Output cap is the tier's max_output. A max_tokens you send above it, or no max_tokens at all, is clamped to the cap, so the gateway never generates more than the cap.
Non-streaming deadline bounds a stream: false call. The gateway makes one attempt; a call that runs past the deadline is cancelled and answered 504 upstream_timeout, and nothing is billed. A streaming call may run for up to five minutes.

Every tier reads images today (supports_vision is true on each). Read each tier's context_window, latency_target_ms, supports_tools, and pricing from the catalog response.

How each tier reasons

A tier can think before it answers. Each catalog entry's reasoning object gives the effort a request gets when it sends no reasoning_effort (default_effort) and whether low, medium, and high are different depths on that tier (graded):

Tier	Profile	`default_effort`	`graded`	What that means
`kavi`	Deep	`high`	`false`	Thinks unless you send `none`. The control is on or off, so `low` thinks as long as `high`.
`vaani`	Balanced	`low`	`true`	Thinks lightly by default; `medium` and `high` think longer.
`mira`	Fast	`none`	`true`	Answers without thinking unless you ask; `low`, `medium`, and `high` are graded.

These are the shipped defaults; the catalog reports the live ones. Reasoning effort covers every value and when to change it.

Pick a tier for the job

	Kavi	Vaani	Mira
Model id	`kavi`	`vaani`	`mira`
Reach for it when	The task needs multi-step reasoning or a long answer. It thinks by default and has the largest output cap.	Everyday calls. It thinks lightly by default, and its graded effort gives you more depth when a request needs it.	Short, direct calls. It answers without thinking unless you ask.
Watch for	Thinking spends `max_tokens`. Leave `max_tokens` unset or large, or send `reasoning_effort: "none"` for a direct answer.	A 4096-token output cap. An answer that needs more ends with `finish_reason: "length"`.	The smallest output cap and a 45 s non-streaming deadline: stream a long turn. On a signed-in plan, `mira` has a monthly request cap of its own.

Rate limits and budgets shows how to read the mira request cap and the other budgets in GET /api/v1/limits, where it sits in the signed-in plan's token_pool.

Pin a tier or let the router choose

Name a tier when you need its behavior to hold on every call: the same output cap, deadline, and reasoning default. Send model: "auto" when your requests vary and you would rather the gateway pick per request; Auto routing covers what the router guarantees and how to read the tier it chose.

A developer API key can carry a model allowlist. A request for a tier the allowlist excludes is 403 model_not_allowed; see Get your API key.

Next steps

Auto routing: let the gateway pick the tier per request.
Reasoning effort: control how much a tier thinks.
Models: every field in the catalog response.
Chat: send your first request to a tier.