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

# Models

> Browse the model catalog and understand modalities, run modes, and pricing.

Omnia offers a catalog of chat, vision, and embedding models sourced across
multiple clouds. Every model has a namespaced id like `Qwen/Qwen3-32B`, and you
call a model by that id. The underlying hardware and provider are an
implementation detail: you interact with one consistent API and one catalog.

## Listing models

Fetch the models available to your workspace at any time with `GET /v1/models`.
The response is an OpenAI-style list of model objects.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://gateway.omnia-voice.com/v1/models \
    -H "Authorization: Bearer $OMNIA_API_KEY"
  ```

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

  client = OpenAI(
      base_url="https://gateway.omnia-voice.com/v1",
      api_key="$OMNIA_API_KEY",
  )

  client.models.list()
  ```
</CodeGroup>

<Note>
  `GET /v1/models` is part of the OpenAI-compatible **inference** API
  (`https://gateway.omnia-voice.com/v1`), not the management API. It uses the same
  workspace key as every other call.
</Note>

The full catalog with live per-token pricing is also on the
[models page](https://platform.omnia-voice.com/models) in the dashboard.

<Note>
  The models you can call are the ones Omnia has priced and offers. A model that
  isn't in the catalog returns `404`. This is deliberate, so you're never billed
  for something without a published rate.
</Note>

## Model ids

Model ids are **namespaced** by their family, in the form `<namespace>/<name>`.
The namespace groups related models; it is not a provider or cloud name. Use the
id exactly as returned by `GET /v1/models`.

```text theme={null}
Qwen/Qwen3-32B
meta-llama/Llama-3.3-70B-Instruct
Qwen/Qwen3-Embedding-8B
```

## Modalities

Models fall into three billable modalities:

| Modality      | Input        | Output | Use it for                         |
| ------------- | ------------ | ------ | ---------------------------------- |
| **Chat**      | text         | text   | Conversations, reasoning, tool use |
| **Vision**    | text + image | text   | Describing/analyzing images        |
| **Embedding** | text         | vector | Search, RAG, clustering            |

## Example models

A few of the models available at launch (see the dashboard for the full, live
list and pricing):

* `Qwen/Qwen3-32B`: general chat
* `meta-llama/Llama-3.3-70B-Instruct`: general chat
* `openai/gpt-oss-120b`: general chat
* `google/gemma-3-27b-it`: general chat
* `Qwen/Qwen2.5-VL-72B-Instruct`: vision
* `Qwen/Qwen3-Embedding-8B`: embeddings

## Two ways to run a model

The same catalog model can be served in two modes, and you choose per workload:

<CardGroup cols={2}>
  <Card title="Shared (per-token)" icon="layer-group">
    The default. Requests run on a pooled, multi-tenant fleet and are billed
    per token, separately for input and output. Nothing to provision; just call
    the model by its id.
  </Card>

  <Card title="Dedicated (per-GPU-hour)" icon="server">
    Reserve private GPU capacity for a specific model and pay per GPU-hour while
    it runs, not per token. Best for sustained high volume, guaranteed
    throughput, or serving a fine-tuned model. See
    [Dedicated endpoints](/dedicated/overview).
  </Card>
</CardGroup>

Both modes are reached through the same inference API. In shared mode you pass
the catalog id (`model="Qwen/Qwen3-32B"`); in dedicated mode you pass
`model="dedicated/<routing-key>"` to route to your own endpoint.

## The Models page in the dashboard

Beyond the catalog, the dashboard's **Models** page is where your own models
live:

* **Your models**: every fine-tune you've deployed and every served model
  version, in one place: what exists, and where it's serving from.
* **Aliases**: the [model aliases](/reference/model-aliases) manager: create,
  repoint, or delete a stable name, set up a canary split, and configure its
  [quality gate](/judges/online-monitoring)
  in the same dialog: judge, mode, sample floor, rollback threshold.

## Pricing

Shared models are priced **per million tokens**, separately for input and
output. Pricing is transparent and shown per model in the dashboard, and you pay
only for the tokens you actually use. Dedicated capacity is billed per GPU-hour
instead of per token. See [Billing](/concepts/billing) for how charges are
metered and settled.

<CardGroup cols={2}>
  <Card title="Dedicated endpoints" icon="server" href="/dedicated/overview">
    Reserve private GPU capacity for a model.
  </Card>

  <Card title="Fine-tuning" icon="wand-magic-sparkles" href="/fine-tuning/overview">
    Train a model on your own data.
  </Card>
</CardGroup>