> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memory.anonalabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Model selection

> Choose which LLM answers your reason and chat calls, and pay that model's rate.

By default every call runs on the model Anona serves as standard. You can name a
different one (per request, in the dashboard, or as a default for a space), and
credits are charged at that model's own rate rather than a flat tier.

> [!NOTE]
>
> Not to be confused with [memory models](https://docs.memory.anonalabs.com/api-reference/models.md), which are standing
> answers a space keeps current. This page is about the **LLM** that does the work.

## Every model is available on every plan

There is no plan gate. A Developer account can select the most expensive model in
the catalog, and a Scale account pays the same rate for it.

That works because credits are derived from each model's real per-token cost. A
credit balance is therefore a **spend cap**, and the choice of model cannot move it.
It only changes how fast the balance goes down. Spent entirely on input, the same
5,000 credits buy roughly 10.7M tokens of `nova-micro`, 2.5M of `gpt-oss`, or 68K
of `claude-opus-4.6`, and cost us the same either way.

The practical limit is throughput, not entitlement: request-per-minute quotas are
per model, and the premium models carry the least headroom. See `requests_per_minute`
in the table below.

## The default

Omit `model` and you get **`openai.gpt-oss-120b-1:0`**, also reachable as the tier
name `balanced`. It replaced Nova Pro as the default in September 2026: same
extraction quality on our own benchmark, a fifth of the credits per operation,
and twenty times the requests-per-minute headroom. Nova Pro is still selectable
by name as `nova-pro`.

## Pick one, and copy the call

Take a name out of [the rate table](#what-it-costs) below and drop it into the
`model` field. Nothing else about the call changes:

```bash theme={null}
curl https://api.anonalabs.com/v1/reason \
  -H "Authorization: Bearer $ANONA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "support",
    "query": "what does this customer keep asking for?",
    "model": "gpt-oss"
  }'
```

`"model": "gpt-oss"` is the default, so that call is also what you get by leaving
the field out: **2 credits per 1K input, 8 per 1K output, 1,000 requests a
minute.** Swap the one string for any other name in the table — `nova-lite` for a
fifth of the rate, `claude-opus-4.6` for about forty times it — and the credit rate
moves with it.

The same field works on the chat proxy, and on
`PUT /v1/spaces/{id}/reason-settings` to make it the space default.

## Three ways to name a model

**A short name**, like `nova-pro`, `deepseek` or `glm`, is what you will use most. One per
model, and pinned to that model permanently: a short name is never re-pointed at
something else.

Most short names carry no version, because most families have one member here.
Where a family has two, both names carry the version: `claude-sonnet-4.5` and
`claude-sonnet-4.6`, `claude-opus-4.5` and `claude-opus-4.6`. That is the same
promise, not an exception to it. A bare `claude-sonnet` would have to mean one
of them today and could only mean the other later, which is exactly the
substitution short names exist to prevent.

**A tier name**, like `fast` or `balanced`, names an *intent* rather than a model, and Anona
keeps it pointed at a sensible choice as the landscape changes. That re-pointing is the
value: ask for `fast` and you keep getting whatever "fast" should mean.

**A full model id**, like `us.amazon.nova-pro-v1:0`, also works, and always has. Nothing
that already sends one needs to change. `GET /v1/models` returns the full id for every
model, along with its exact credit rates.

**A host-qualified name**, like `cerebras/gpt-oss-120b`, is accepted for any model served
outside Bedrock. It is the `provider/model` form other tools use, and it is worth knowing
because two entries here can be the same open weights at different hosts: `gpt-oss` and
`gpt-oss-turbo` are both GPT-OSS 120B, and `gpt-oss-turbo` charges **2.33x on input and
1.25x on output**, which is 2.02x blended. If you are ever unsure which one a name refers
to, spell the host out.

> [!WARNING]
>
> The difference between the first two matters. A **short name is stable**; a **tier name
> may move**. If you have measured a model and want that exact behaviour to stay put, name it:
> `gpt-oss`, not `balanced`.

```json theme={null}
{ "space_id": "support", "query": "what does this customer keep asking for?", "model": "nova-lite" }
```

These all name the same model, and any of them is accepted anywhere `model` is:

```json theme={null}
{ "model": "gpt-oss" }
{ "model": "balanced" }
{ "model": "openai.gpt-oss-120b-1:0" }
```

And these three all name the Cerebras-hosted one, which is a different model and a
different price:

```json theme={null}
{ "model": "gpt-oss-turbo" }
{ "model": "cerebras.gpt-oss-120b" }
{ "model": "cerebras/gpt-oss-120b" }
```

Models served through OpenRouter are named `openrouter/<vendor>/<model>`. This one
is GPT-OSS 120B again, at a third host and its own, lower, price:

```json theme={null}
{ "model": "gpt-oss-or" }
{ "model": "openrouter/openai/gpt-oss-120b" }
```

The vendor name on its own (`openai/gpt-oss-120b`) is not accepted, because more than
one host serves those weights and the price depends on which.

The first two agree **today**. `balanced` is an intent that may be re-pointed later,
and in September 2026 it moved from Nova Pro to GPT-OSS; `gpt-oss` is that model
permanently. If you had pinned `nova-pro`, you are still on Nova Pro.

## Using it from the API

Resolution runs **request → space default → platform default**, so a request always
wins over a stored setting.

```bash cURL theme={null}
# Per request (reason)
curl -X POST https://api.anonalabs.com/v1/reason \
  -H "Authorization: Bearer anona_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"space_id": "support", "query": "...", "model": "balanced"}'

# Space default (reason)
curl -X PUT https://api.anonalabs.com/v1/spaces/support/reason-settings \
  -H "Authorization: Bearer anona_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "fast", "depth": null}'

# Space default (proxy)
curl -X PUT https://api.anonalabs.com/v1/spaces/support/chat-settings \
  -H "Authorization: Bearer anona_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"chat_model": "fast"}'
```

```python Python theme={null}
from anona import AnonaClient

anona = AnonaClient(api_key="anona_live_YOUR_KEY")

# Per request (reason)
answer = anona.reason(space_id="support", query="...", model="balanced")

# Space default (reason) — both fields, always: the PUT is a full replace
anona.set_reason_settings(space_id="support", model="fast", depth=None)

# Space default (proxy)
anona.set_chat_settings(space_id="support", chat_model="fast")
```

```typescript TypeScript theme={null}
import { Anona } from "@anona-labs/memory";

const anona = new Anona({ apiKey: "anona_live_YOUR_KEY" });

// Per request (reason)
const answer = await anona.reason({
  spaceId: "support",
  query: "...",
  model: "balanced",
});

// Space default (reason) — both fields, always: the PUT is a full replace
await anona.setReasonSettings({ spaceId: "support", model: "fast", depth: null });

// Space default (proxy)
await anona.setChatSettings({ spaceId: "support", chatModel: "fast" });
```

Both settings `PUT`s replace the whole record, which is why the SDK methods send every
field: an argument you leave out is an argument that clears.

Because the proxy is drop-in, a stock OpenAI SDK can set it once and forget it:

```python Python theme={null}
from openai import OpenAI

client = OpenAI(
    api_key="anona_live_YOUR_KEY",
    base_url="https://api.anonalabs.com/v1",
    default_headers={"X-Anona-Space-Id": "support"},
)

resp = client.chat.completions.create(
    model="fast",                      # a tier name or a model id
    messages=[{"role": "user", "content": "What did we decide about pricing?"}],
)
```

```typescript TypeScript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "anona_live_YOUR_KEY",
  baseURL: "https://api.anonalabs.com/v1",
  defaultHeaders: { "X-Anona-Space-Id": "support" },
});

const resp = await client.chat.completions.create({
  model: "fast", // a tier name or a model id
  messages: [{ role: "user", content: "What did we decide about pricing?" }],
});
```

```bash cURL theme={null}
curl https://api.anonalabs.com/v1/chat/completions \
  -H "Authorization: Bearer anona_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Anona-Space-Id: support" \
  -d '{
    "model": "fast",
    "messages": [{"role": "user", "content": "What did we decide about pricing?"}]
  }'
```

A space default is stored as a **resolved model id**, even when you send a tier
name. If `fast` is later re-pointed at a different model, spaces that already chose
it stay where they are. You picked a behaviour, not a subscription to ours.

`GET /v1/spaces/{space_id}/reason-settings` reads the current value; sending
`{"model": null}`, or `DELETE`, returns the space to the platform default.

That resource holds a second setting beside the model — [`depth`](https://docs.memory.anonalabs.com/api-reference/reason#depth),
how hard `reason` looks before it answers — and **the `PUT` replaces the whole
record**, so a body naming only `model` clears the depth. Send both fields, which
is why the example above states `"depth": null` rather than leaving it out.

The reason model also writes the space's **memory models**. A memory model is a
`reason` answer the space keeps, so `POST /v1/spaces/{id}/models` and
`POST /v1/spaces/{id}/models/{id}/refresh` run on the same model `/v1/reason`
does, and so does a refresh that consolidation starts on its own. Change the
reason model and the next refresh picks it up — existing content is not
rewritten until then.

> [!WARNING]
>
> `PUT /v1/spaces/{id}/chat-settings` replaces the whole record, so a field you omit is
> cleared, not kept. The reason settings are a **separate** resource for exactly this
> reason, so saving chat defaults never disturbs them — but that `PUT` replaces its
> whole record too, and it holds both `model` and `depth`.

## Using it from the dashboard

Open a space, then the **chat defaults** tab:

| Row | What it changes |
| - | - |
| **Chat model** | The LLM that answers proxied chat calls (`/v1/chat/completions`, `/v1/responses`, `/v1/messages`) for this space. |
| **Reason model** | The LLM that answers `/v1/reason` for this space — and the one that writes its memory models. |
| **Reason depth** | How hard `reason` looks before it answers here: *Fast* lets a current memory model answer on its own, *Thorough* always reads the notes and raw memories underneath. See [Depth](https://docs.memory.anonalabs.com/api-reference/reason.md#depth). |

Each row has an **override** toggle. Left off, the row is inherited: the space
follows the platform default, and it keeps following it if that default ever moves.
Turn the toggle on and the picker appears, listing every model with its credit rate
per 1K tokens so the cost of the choice is visible at the moment you make it.

These write the same `reason-settings` and `chat-settings` resources the API uses,
so a value set here is the value a request sees, and vice versa.

## List what you can use

```http theme={null}
GET /v1/models
Authorization: Bearer anona_live_YOUR_KEY
```

```bash cURL theme={null}
curl https://api.anonalabs.com/v1/models \
  -H "Authorization: Bearer anona_live_YOUR_KEY"
```

```python Python theme={null}
catalog = anona.list_catalog_models()
for model in catalog["data"]:
    print(model["id"], model["credits_per_1k_input"])
```

```typescript TypeScript theme={null}
const catalog = await anona.listCatalogModels();
for (const model of catalog.data) {
  console.log(model.id, model.credits_per_1k_input);
}
```

```json theme={null}
{
  "object": "list",
  "data": [
    {
      "id": "us.amazon.nova-lite-v1:0",
      "object": "model",
      "created": 0,
      "owned_by": "anona",
      "short_name": "nova-lite",
      "display_name": "Nova Lite",
      "alias": "fast",
      "default": false,
      "credits_per_1k_input": 0.8,
      "credits_per_1k_output": 3.2,
      "requests_per_minute": 400,
      "relative_cost": 0.4,
      "provider": "bedrock",
      "supports_memory_operations": true
    }
  ]
}
```

The envelope is the standard OpenAI list shape, so `client.models.list()` works
unchanged against the [proxy](https://docs.memory.anonalabs.com/api-reference/chat.md). Entries come back **cheapest
first**, ordered by `relative_cost`. The names, `alias`, `default`, the credit
rates, `requests_per_minute`, and `relative_cost` are Anona's additions; an SDK
that does not know about them ignores them. `short_name` always names this exact
model and never moves; `alias` names a tier and may be re-pointed.

`default` marks the model you get by omitting the `model` field. At most one
entry carries it, and sometimes none, when this deployment serves a model
outside the catalog.

## Where each model works

Most models answer everything. A few answer chat only, and `GET /v1/models` says
which with **`supports_memory_operations`** — read it rather than assuming, and
filter on it before offering a list as a reason model.

The reason is the shape of the product rather than a restriction on you. Chat
requests are proxied: Anona calls the model's host directly, so any host we hold
a key for can answer one. Memory operations — `/v1/reason`, the memory models,
the Slack and MCP asks — run inside the memory engine, which talks to one host.
A model outside it is refused with `unsupported_model` and a message naming what
is available for memory operations, rather than accepted and failed later.

`provider` names the host. It matters because the same open weights can be
served by more than one, at different prices and very different speeds:
`gpt-oss` and `gpt-oss-turbo` are the same 120B model, the second on Cerebras at
roughly 2x the credits and, measured over tool-calling calls of the shape reason
sends, several times faster per step. Anona
holds every one of these keys; there is no bring-your-own-key path, and a model
you can name is one we pay for.

## What it costs

Credit rates are derived from each model's real per-token price, so a model that
costs five times more charges roughly five times the credits, with no rounding
into tiers.

**Cost vs default** compares against `gpt-oss`, blended 10:1 input:output. It is a
shopping aid, not a billing figure: a model's in/out ratio is its own. Llama 70B
charges the same for both, GPT-OSS charges 4x more for output, so cost a real
workload from the exact credit rates on `GET /v1/models`, not from the multiplier.

| Model | Use in `model` | Tier | Credits per 1K (in / out) | Cost vs default |
| - | - | - | - | - |
| GPT-OSS 20B (OpenRouter) | `gpt-oss-20b-or` | - | 0.25 / 1.27 | 0.14x |
| DeepSeek V4 Flash 0423 (OpenRouter) | `deepseek-v4-flash-or` | - | 0.36 / 0.71 | 0.15x |
| Nova Micro | `nova-micro` | - | 0.47 / 1.87 | 0.23x |
| Nova Micro 1.0 (OpenRouter) | `nova-micro-v1-or` | - | 0.49 / 1.97 | 0.25x |
| GPT-OSS 120B (OpenRouter) | `gpt-oss-or` | - | 0.52 / 2.63 | 0.28x |
| Llama 3.1 8B Instruct (OpenRouter) | `llama-3.1-8b-instruct-or` | - | 0.7 / 1.13 | 0.29x |
| Gemma 4 26B A4B (OpenRouter) | `gemma-4-26b-a4b-it-or` | - | 0.59 / 3.09 | 0.32x |
| Nemotron Nano 3 30B | `nemotron-nano` | - | 0.8 / 3.2 | 0.40x |
| Nova Lite | `nova-lite` | `fast` | 0.8 / 3.2 | 0.40x |
| Nova Lite 1.0 (OpenRouter) | `nova-lite-v1-or` | - | 0.84 / 3.38 | 0.42x |
| Nemotron 3 Nano 30B A3B (OpenRouter) | `nemotron-3-nano-30b-a3b-or` | - | 0.84 / 3.38 | 0.42x |
| Nemotron 3.5 Lightning (OpenRouter) | `nemotron-3.5-lightning-or` | - | 0.98 / 2.81 | 0.45x |
| GPT-OSS 20B | `gpt-oss-20b` | - | 0.93 / 4 | 0.48x |
| GLM 4.7 Flash | `glm-flash` | - | 0.93 / 5.33 | 0.52x |
| DeepSeek V4.1 Flash (OpenRouter) | `deepseek-v4.1-flash-or` | - | 0.63 / 8.44 | 0.53x |
| GLM 4.7 Flash (OpenRouter) | `glm-4.7-flash-or` | - | 0.98 / 5.63 | 0.55x |
| GLM 5.3 Flash (OpenRouter) | `glm-5.3-flash-or` | - | 1.27 / 4.22 | 0.60x |
| Ministral 3 3B 2512 (OpenRouter) | `ministral-3b-2512-or` | - | 1.55 / 1.55 | 0.61x |
| Nemotron 3 Super (OpenRouter) | `nemotron-3-super-120b-a12b-or` | - | 1.2 / 6.33 | 0.65x |
| Llama 3.3 70B Instruct (OpenRouter) | `llama-3.3-70b-instruct-or` | - | 1.41 / 4.5 | 0.66x |
| GPT-6 Luna Pro (OpenRouter) | `gpt-6-luna-pro-or` | - | 1.55 / 7.74 | 0.83x |
| GPT-6 Luna (OpenRouter) | `gpt-6-luna-or` | - | 1.55 / 7.74 | 0.83x |
| MiMo-V2.6-Flash (OpenRouter) | `mimo-v2.6-flash-or` | - | 1.97 / 3.94 | 0.84x |
| Ministral 3 8B 2512 (OpenRouter) | `ministral-8b-2512-or` | - | 2.32 / 2.32 | 0.91x |
| GLM 5.2 (OpenRouter) | `glm-5.2-or` | - | 1.99 / 6.25 | 0.93x |
| Qwen3.8 Flash (OpenRouter) | `qwen3.8-flash-or` | - | 2.11 / 6.61 | 0.99x |
| Hy3 (OpenRouter) | `hy3-or` | - | 1.97 / 8.16 | 0.99x |
| **GPT-OSS 120B** | **`gpt-oss`** | **`balanced`** | **2 / 8** | **1x, the default** |
| Nemotron 3 Super 120B | `nemotron-super` | - | 2 / 8.67 | 1.0x |
| GLM 5.3 (OpenRouter) | `glm-5.3-or` | - | 2.19 / 6.87 | 1.0x |
| Llama 4 Scout | `llama4-scout` | - | 2.27 / 8.8 | 1.1x |
| Mistral Small 4 (OpenRouter) | `mistral-small-2603-or` | - | 2.32 / 9.28 | 1.2x |
| Ministral 3 14B 2512 (OpenRouter) | `ministral-14b-2512-or` | - | 3.09 / 3.09 | 1.2x |
| DeepSeek V4 Pro 0423 (OpenRouter) | `deepseek-v4-pro-or` | - | 2.94 / 5.87 | 1.3x |
| Llama 4 Maverick (OpenRouter) | `llama-4-maverick-or` | - | 2.64 / 9.18 | 1.3x |
| MiniMax M2.7 (OpenRouter) | `minimax-m2.7-or` | - | 2.95 / 11.82 | 1.5x |
| DeepSeek V3.2 (OpenRouter) | `deepseek-v3.2-or` | - | 3.66 / 5.35 | 1.5x |
| GPT-5.6 Luna Pro (OpenRouter) | `gpt-5.6-luna-pro-or` | - | 3.09 / 18.57 | 1.8x |
| GPT-5.6 Luna (OpenRouter) | `gpt-5.6-luna-or` | - | 3.09 / 18.57 | 1.8x |
| DeepSeek V3.1 (OpenRouter) | `deepseek-chat-v3.1-or` | - | 3.8 / 14.07 | 1.9x |
| Qwen3.8 27B (OpenRouter) | `qwen3.8-27b-or` | - | 2.85 / 26.37 | 2.0x |
| MiniMax M2.1 | `minimax` | - | 4 / 16 | 2.0x |
| DeepSeek V3.1 Terminus (OpenRouter) | `deepseek-v3.1-terminus-or` | - | 4.22 / 14.07 | 2.0x |
| GPT-OSS 120B (Cerebras) | `gpt-oss-turbo` | - | 4.67 / 10 | 2.0x |
| MiniMax M2.5 (OpenRouter) | `minimax-m2.5-or` | - | 4.15 / 16.88 | 2.1x |
| MiniMax M2.1 (OpenRouter) | `minimax-m2.1-or` | - | 4.22 / 16.88 | 2.1x |
| Gemini 3.1 Flash Lite (OpenRouter) | `gemini-3.1-flash-lite-or` | - | 3.87 / 23.21 | 2.2x |
| Command A+ (OpenRouter) | `command-a-plus-or` | - | 4.22 / 21.1 | 2.3x |
| GLM 5.3 FlashX (OpenRouter) | `glm-5.3-flashx-or` | - | 5.2 / 17.58 | 2.5x |
| MiMo-V2.6-Pro (OpenRouter) | `mimo-v2.6-pro-or` | - | 6.12 / 12.24 | 2.6x |
| Nova 2 Lite (OpenRouter) | `nova-2-lite-v1-or` | - | 4.22 / 35.17 | 2.8x |
| Gemini 3.5 Flash Lite (OpenRouter) | `gemini-3.5-flash-lite-or` | - | 4.64 / 38.68 | 3.0x |
| Mistral Large 3 | `mistral-large` | - | 6.67 / 20 | 3.1x |
| Mistral Medium 3.1 (OpenRouter) | `mistral-medium-3.1-or` | - | 6.19 / 30.95 | 3.3x |
| Llama 70B | `llama-70b` | - | 9.6 / 9.6 | 3.8x |
| DeepSeek | `deepseek` | - | 8.27 / 24.67 | 3.8x |
| GLM | `glm` | - | 8 / 29.33 | 3.9x |
| GLM 4.7 (OpenRouter) | `glm-4.7-or` | - | 8.44 / 30.95 | 4.1x |
| Kimi K2.6 (OpenRouter) | `kimi-k2.6-or` | - | 8.42 / 35.45 | 4.3x |
| Kimi K2.5 | `kimi` | - | 8 / 40 | 4.3x |
| GLM 5 (OpenRouter) | `glm-5-or` | - | 9.85 / 31.51 | 4.6x |
| Kimi K2.5 (OpenRouter) | `kimi-k2.5-or` | - | 8.44 / 46.77 | 4.7x |
| Nemotron 3 Ultra (OpenRouter) | `nemotron-3-ultra-550b-a55b-or` | - | 8.79 / 43.96 | 4.7x |
| Nova Pro | `nova-pro` | - | 10.67 / 42.67 | 5.3x |
| Nova Pro 1.0 (OpenRouter) | `nova-pro-v1-or` | - | 11.25 / 45.01 | 5.6x |
| Gemini 3.8 Flash (OpenRouter) | `gemini-3.8-flash-or` | - | 10.55 / 52.75 | 5.7x |
| Gemini 3.7 Flash (OpenRouter) | `gemini-3.7-flash-or` | - | 10.55 / 52.75 | 5.7x |
| Gemini 3.6 Flash (OpenRouter) | `gemini-3.6-flash-or` | - | 11.6 / 58.02 | 6.2x |
| GLM 5 | `glm-5` | - | 13.33 / 42.67 | 6.3x |
| Grok 4.3 (OpenRouter) | `grok-4.3-or` | - | 17.58 / 35.17 | 7.5x |
| Claude Haiku 4.5 | `claude-haiku` | - | 14.67 / 73.33 | 7.9x |
| Claude Haiku 4.5 (OpenRouter) | `claude-haiku-4.5-or` | - | 15.47 / 77.37 | 8.3x |
| Mistral Medium 3.5 (OpenRouter) | `mistral-medium-3-5-or` | - | 23.21 / 116.05 | 12.4x |
| Qwen3.8 2.4T A95B (OpenRouter) | `qwen3.8-2.4t-a95b-or` | - | 28.13 / 84.4 | 13.1x |
| Grok 4.5 (OpenRouter) | `grok-4.5-or` | - | 28.13 / 84.4 | 13.1x |
| Gemini 3.5 Flash (OpenRouter) | `gemini-3.5-flash-or` | - | 23.21 / 139.26 | 13.3x |
| Grok 4.7 (OpenRouter) | `grok-4.7-or` | - | 30.95 / 92.84 | 14.4x |
| Grok 4.6 (OpenRouter) | `grok-4.6-or` | - | 30.95 / 92.84 | 14.4x |
| Claude Sonnet 5.5 (OpenRouter) | `claude-sonnet-5.5-or` | - | 28.13 / 140.67 | 15.1x |
| Claude Sonnet 5 (OpenRouter) | `claude-sonnet-5-or` | - | 28.13 / 140.67 | 15.1x |
| GPT-5.6 Sol Pro (OpenRouter) | `gpt-5.6-sol-pro-or` | - | 28.13 / 140.67 | 15.1x |
| GPT-5.6 Sol (OpenRouter) | `gpt-5.6-sol-or` | - | 28.13 / 140.67 | 15.1x |
| GPT-6.1 Sol Pro (OpenRouter) | `gpt-6.1-sol-pro-or` | - | 30.95 / 154.73 | 16.6x |
| GPT-6.1 Sol (OpenRouter) | `gpt-6.1-sol-or` | - | 30.95 / 154.73 | 16.6x |
| GPT-6 Sol Pro (OpenRouter) | `gpt-6-sol-pro-or` | - | 30.95 / 154.73 | 16.6x |
| GPT-6 Sol (OpenRouter) | `gpt-6-sol-or` | - | 30.95 / 154.73 | 16.6x |
| GPT-5.6 Terra Pro (OpenRouter) | `gpt-5.6-terra-pro-or` | - | 30.95 / 185.68 | 17.7x |
| GPT-5.6 Terra (OpenRouter) | `gpt-5.6-terra-or` | - | 30.95 / 185.68 | 17.7x |
| Kimi K3 (OpenRouter) | `kimi-k3-or` | - | 31.65 / 196.93 | 18.3x |
| GLM 5.3 Prime (OpenRouter) | `glm-5.3-prime-or` | - | 39.39 / 123.79 | 18.5x |
| Claude Sonnet 4.5 (OpenRouter) | `claude-sonnet-4.5-or` | - | 42.2 / 211 | 22.6x |
| Claude Sonnet 4.6 (OpenRouter) | `claude-sonnet-4.6-or` | - | 42.2 / 211 | 22.6x |
| Claude Sonnet 4.5 | `claude-sonnet-4.5` | - | 44 / 220 | 23.6x |
| Claude Sonnet 4.6 | `claude-sonnet-4.6` | - | 44 / 220 | 23.6x |
| Qwen3.8 Max Prime (OpenRouter) | `qwen3.8-max-prime-or` | - | 56.27 / 168.8 | 26.1x |
| Claude Opus 5.5 (OpenRouter) | `claude-opus-5.5-or` | - | 56.27 / 281.33 | 30.1x |
| Claude Opus 4.5 (OpenRouter) | `claude-opus-4.5-or` | - | 70.33 / 351.67 | 37.7x |
| Claude Opus 4.6 (OpenRouter) | `claude-opus-4.6-or` | - | 70.33 / 351.67 | 37.7x |
| Claude Opus 5 (OpenRouter) | `claude-opus-5-or` | - | 70.33 / 351.67 | 37.7x |
| Claude Opus 4.8 (OpenRouter) | `claude-opus-4.8-or` | - | 70.33 / 351.67 | 37.7x |
| Claude Opus 4.7 (OpenRouter) | `claude-opus-4.7-or` | - | 70.33 / 351.67 | 37.7x |
| Claude Opus 4.5 | `claude-opus-4.5` | - | 73.33 / 366.67 | 39.3x |
| Claude Opus 4.6 | `claude-opus-4.6` | - | 73.33 / 366.67 | 39.3x |
| GPT-5.5 (OpenRouter) | `gpt-5.5-or` | - | 77.37 / 464.2 | 44.2x |
| Claude Fable 5.1 (OpenRouter) | `claude-fable-5.1-or` | - | 140.67 / 703.33 | 75.4x |
| Claude Fable 5 (OpenRouter) | `claude-fable-5-or` | - | 140.67 / 703.33 | 75.4x |
| GPT-6 Astra (OpenRouter) | `gpt-6-astra-or` | - | 154.73 / 773.67 | 82.9x |
| GPT-6 Astra Pro (OpenRouter) | `gpt-6-astra-pro-or` | - | 154.73 / 773.67 | 82.9x |

`GET /v1/models` is the authoritative list; this table is a snapshot. The two can
differ in length as well as in content: a model whose host this deployment holds no
key for is **not listed**, though it stays resolvable by id so naming it gets you a
precise `model_unavailable` rather than a flat `unsupported_model`. If a name in this
table is missing from your `GET /v1/models`, that is why.

Reason also carries a flat base of 5 credits, so a short answer on a cheap model
costs 5 rather than fractions of one.

> [!NOTE]
>
> A worked example. A reason call reading 4,000 tokens of context and writing 400 on
> the default costs `5 + (4 × 2.0) + (0.4 × 8.0)` ≈ **16 credits**. The same call on
> `nova-micro` costs `5 + (4 × 0.47) + (0.4 × 1.87)` ≈ **8 credits**, and at that end of
> the catalog the flat base is most of the bill, not the tokens.

## Which model answered

Reason echoes it back, so you can reconcile an answer and its cost against the model
that actually produced them rather than the one you asked for:

```json theme={null}
{
  "insights": "...",
  "model": "us.amazon.nova-lite-v1:0",
  "usage": { "input_tokens": 4120, "output_tokens": 380 }
}
```

## Errors

Anona never quietly substitutes a different model. If the one you named cannot serve
the request, the request fails and says so.

| Code | Status | Meaning |
| - | - | - |
| `unsupported_model` | 400 | Not a model this deployment serves — or, on a memory operation, a chat-only one (see `supports_memory_operations`). For an unknown name the message suggests up to three close matches, for example `Did you mean 'claude-sonnet-4.6', 'claude-sonnet-4.5'?`, and points to `GET /v1/models`; for a chat-only model it lists the models memory operations accept. |
| `model_throttled` | 429 | That model is at capacity right now. Retry, or use one with more headroom (see `requests_per_minute`). |
| `model_unavailable` | 503 | The model is listed but this deployment cannot reach it. Ours to fix. |

Request limits are **per model**, which is also a reason to choose one: the
high-throughput models carry forty times the headroom of the premium ones
(1,000 rpm against Opus's 25).

## Choosing well

* **Leave it alone** unless you have a reason. The default is the balanced option.
* **`fast`** for high-volume, low-stakes work: classification, short recall
  summaries, anything where you would rather have ten answers than one better one.
* **A premium model** for reason over a large space, where the synthesis is the
  product and a better one is worth several times the credits. `mistral-large` is
  3.1x the default and `kimi` 4.3x; the Claude family runs from `claude-haiku` at
  7.9x to `claude-opus-4.6` at 39.3x. Price is identical within each Claude
  family, so prefer the higher version: it carries a larger context window for
  the same rate.
* **Watch the credit burn, not the plan.** Nothing stops a Developer account
  running any model in the catalog; it simply exhausts the month's credits sooner.
  `claude-opus-4.6` burns about **170 times** faster than `nova-micro`, and the
  dearest entry in the catalog about **355 times** faster. Both figures are the
  ratio of the **Cost vs default** column below, so they carry its 10:1 blend.
* **`gpt-oss-turbo` is cheapest exactly where it is fastest.** It is the same
  model as the default at a faster host. It charges 2.33x on input and only
  1.25x on output, so what you pay depends on the shape of the call — and so
  does what you gain. Measured against prod with alternating calls:

  | call | credits | speed |
  | - | - | - |
  | short reply (\~50 tokens out) | **the same 3** | 1.24x faster |
  | long answer (\~700 tokens out) | 6 → 8, **1.33x** | **3.64x faster** |
  | large context in, short answer out | up to **2.2x** | barely faster |

  So: worth it for drafting, summarising and anything that writes at length,
  where it is over three times faster for a third more credits. Not worth it for
  stuffing a large context in to get a sentence back — that is where it costs
  most and helps least. A short interactive reply is free either way, because
  both land on the 3-credit chat floor. Choose it per call rather than as a
  space default.
* **Measure before pinning an id.** Reason is a multi-step agent loop, so a slower
  model costs more wall time than its per-call latency suggests.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.