# Models

> The models available on Serenity Edge: the Orion family and the open models, with context, output limits and capabilities read from the API.

Source: https://docs.serenityedge.ai/docs/models/

Serenity Edge serves two families of chat models: **Orion**, Serenity's own model line, and a set of **open models** addressed by their published names. It also serves [decision models](https://docs.serenityedge.ai/docs/models/#decision-models), the models of the [embeddings, rerank and redaction](https://docs.serenityedge.ai/docs/models/#embeddings-rerank-and-redaction) routes and a [speech-to-text](https://docs.serenityedge.ai/docs/models/#speech-to-text) model, each on its own endpoint.

## Catalogue

The table is read from `GET /v1/models` when this page is published and again when you open it, so it shows what the API serves right now; the line under it says when it was read.

| Model id | Family | Context | Max output | Capabilities |
| --- | --- | --- | --- | --- |
| `orion-pro`, Orion Pro | Orion | 262,144 | 32,768 | Streaming, Tool calling, Structured outputs, Reasoning, Prefix caching |
| `orion-plus`, Orion Plus | Orion | 262,144 | 32,768 | Streaming, Tool calling, Structured outputs, Reasoning, Prefix caching |
| `qwen3.8-27b`, Qwen3.8 27B | Open | 262,144 | 32,768 | Streaming, Tool calling, Structured outputs, Reasoning, Prefix caching |
| `qwen3.6-35b-a3b`, Qwen3.6 35B A3B | Open | 262,144 | 32,768 | Streaming, Tool calling, Structured outputs, Reasoning, Prefix caching |
| `paddleocr-vl-1.6`, PaddleOCR-VL 1.6 | Open | 16,384 | 8,192 | Streaming |

Read from the API (`GET /v1/models`) when this page was published, on 20 November 2026, 14:40 UTC.

Pricing is listed on [Pricing and limits](https://docs.serenityedge.ai/docs/pricing-and-limits/). Use `GET /v1/models` to retrieve the catalogue programmatically; see [List models](https://docs.serenityedge.ai/docs/api/edge/list-models/).

## Two families

### Orion

`orion-pro` and `orion-plus` are the Orion family, Serenity's own model line. Each id is the configuration that Substrate AI recommends and maintains for a kind of workload (sampling defaults, prompt handling and serving configuration tuned for it): `orion-plus` for volume and latency, `orion-pro` for depth. Address the Orion ids to follow that recommended configuration and to benefit from future improvements without changing your code.

> **Preview**
> 
> Substrate AI is preparing fine-tuned Orion models. When they ship, the `orion-pro` and `orion-plus` ids will resolve to them; the change will be announced in the [release notes](https://docs.serenityedge.ai/release-notes/) in advance.

### Open models

`qwen3.8-27b` and `qwen3.6-35b-a3b` are general-purpose open models, each served as an NVFP4 quantisation of its authors' published weights that a third party has published (see [Precision](https://docs.serenityedge.ai/docs/models/#precision)). Use these ids when you want to address an open model by its own name, for example to compare results with other providers.

| Model | Licence |
| --- | --- |
| `qwen3.8-27b` | Apache-2.0, as published by Qwen ([licence text](https://huggingface.co/Qwen/Qwen3.8-27B/blob/1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0/LICENSE)). Served as an NVFP4 quantisation published by a third party under the same licence. |
| `qwen3.6-35b-a3b` | Apache-2.0, as published by Qwen ([licence text](https://huggingface.co/Qwen/Qwen3.6-35B-A3B/blob/345d467b117d1fd5eda9b879a5988de9ae5f47a7/LICENSE)). Served as an NVFP4 quantisation published by a third party. |

`paddleocr-vl-1.6` is an open model for reading document pages: see [Document OCR](https://docs.serenityedge.ai/docs/models/#document-ocr).

## Choosing between `pro` and `plus`

-   Start with `orion-plus`. It is the fast, inexpensive option and handles most conversational, classification and extraction workloads well.
-   Move to `orion-pro` when the task needs more depth: long multi-document reasoning, strict adherence to complex instructions, or reliable multi-step tool calling.

The Orion models, `qwen3.8-27b` and `qwen3.6-35b-a3b` support [streaming](https://docs.serenityedge.ai/docs/streaming/), [tool calling](https://docs.serenityedge.ai/docs/tool-calling/), [structured outputs](https://docs.serenityedge.ai/docs/structured-outputs/) and reasoning; `paddleocr-vl-1.6` supports streaming only. The catalogue above shows the capabilities of each one. See the [API reference](https://docs.serenityedge.ai/docs/api/edge/create-chat-completion/) for the full parameter list.

## Image input

Every chat model reads images as well as text. Send them in a user message as `image_url` parts whose `url` is a base64 data URL (`data:image/png;base64,...`; PNG, JPEG, WebP or GIF), up to the model's limit per request:

```json
{"role": "user", "content": [
  {"type": "text", "text": "What does this chart show?"},
  {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}}
]}
```

| Model | Images per request |
| --- | --- |
| `orion-pro` | 8 |
| `orion-plus` | 8 |
| `qwen3.8-27b` | 8 |
| `qwen3.6-35b-a3b` | 8 |
| `paddleocr-vl-1.6` | 1 |

Images count as input tokens and are billed at the model's input price. Image URLs are not fetched: a part with an `http` or `https` URL, more images than the model reads, or video, audio or file parts are refused with HTTP 400 (`invalid_request_error`, with the offending `param`). Images are counted over the whole conversation, earlier turns included: too many images carry the code `too_many_images`, so in a long conversation send only the most recent images and replace the older ones with a short text. Each model's limit is `supported_inputs.references.max` of its `image` input modality in [`GET /v1/models`](https://docs.serenityedge.ai/docs/api/edge/list-models/). The request body limit of 4 MB applies to the base64 data.

## Reasoning

Reasoning is off unless the request asks for it. Ask with an effort: `reasoning.effort` on the [Responses API](https://docs.serenityedge.ai/docs/responses-api/#reasoning), and on chat completions either `"reasoning": {"effort": "medium"}` or `"reasoning_effort": "medium"` (when both are sent, `reasoning.effort` wins).

| Effort | What the model does |
| --- | --- |
| `none` (the default) or `minimal` | Answers without reasoning |
| `low` | Reasons, at its lowest level |
| `medium` | Reasons, at its middle level |
| `high` or `xhigh` | Reasons, at its highest level (the two are the same level) |
| Any other value | Ignored: the model answers without reasoning |

The levels apply to the models that have them. On the others, `low`, `medium`, `high` and `xhigh` all turn reasoning on in the same way:

| Model | Reasoning levels |
| --- | --- |
| `orion-pro` | Three: `low`, `medium`, and `high` or `xhigh` |
| `orion-plus` | None: any effort from `low` to `xhigh` turns reasoning on |
| `qwen3.8-27b` | Three: `low`, `medium`, and `high` or `xhigh` |
| `qwen3.6-35b-a3b` | None: any effort from `low` to `xhigh` turns reasoning on |
| `paddleocr-vl-1.6` | No reasoning |

On chat completions without an effort, or with one that is ignored, `"reasoning": {"enabled": true}` or a `reasoning.max_tokens` above 0 turns reasoning on at the model's highest level; `reasoning.max_tokens` is not a token budget. `"reasoning": {"enabled": false}` leaves it off. Reasoning tokens are billed as output tokens, and more reasoning means more output tokens and a later answer.

## Document OCR

`paddleocr-vl-1.6` (aliases `baidu/paddleocr-vl-1.6` and `paddlepaddle/paddleocr-vl-1.6`) is PaddleOCR-VL 1.6, an open vision-language model for documents. It reads one page image and returns the page's text, a table, a formula or the data of a chart, depending on the task prompt you send with the image. It is a chat model: call it with [`POST /v1/chat/completions`](https://docs.serenityedge.ai/docs/api/edge/create-chat-completion/).

Send one user message with the page as an `image_url` part (a base64 data URL, as in [Image input](https://docs.serenityedge.ai/docs/models/#image-input)) followed by a `text` part with one of these task prompts, exactly as written:

| Task prompt | What the answer contains |
| --- | --- |
| `OCR:` | The text of the page |
| `Table Recognition:` | The table in the image |
| `Formula Recognition:` | The formula in the image |
| `Chart Recognition:` | The data of the chart in the image |

```bash
curl https://api.serenityedge.ai/v1/chat/completions \
  -H "Authorization: Bearer $SERENITY_EDGE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "paddleocr-vl-1.6",
    "messages": [
      {"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}},
        {"type": "text", "text": "OCR:"}
      ]}
    ]
  }'
```

With the OpenAI Python library, read the page from a file and encode it:

```python
import base64

from openai import OpenAI

client = OpenAI(
    base_url="https://api.serenityedge.ai/v1",
    api_key="YOUR_SERENITY_EDGE_API_KEY",
)

with open("page-1.png", "rb") as image:
    page = base64.b64encode(image.read()).decode("ascii")

completion = client.chat.completions.create(
    model="paddleocr-vl-1.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{page}"}},
                {"type": "text", "text": "OCR:"},
            ],
        }
    ],
)

print(completion.choices[0].message.content)
```

What to know about this model:

-   **One image per request.** A second image is refused with HTTP 400 (`invalid_request_error`, `code: "too_many_images"`, `param: "messages"`, `This model reads at most 1 image(s) per request.`). Send a document of several pages as one request per page; the requests can run in parallel.
-   **Temperature 0 by default.** Without a `temperature` in the request, the model decodes greedily, which keeps transcriptions stable. A `temperature` you send is used as is.
-   **Text in, text out.** The model does not reason, call tools or produce structured outputs: send the image and the task prompt, and read the answer from `choices[0].message.content`. If a transcription reaches the model's maximum output, shown in the [catalogue](https://docs.serenityedge.ai/docs/models/#catalogue), the answer ends with `finish_reason: "length"`.
-   **Billing.** The image counts as prompt tokens: a full page is about 1,250 prompt tokens. Prompt and completion tokens are billed at the prices on [Pricing and limits](https://docs.serenityedge.ai/docs/pricing-and-limits/). In our measurements of 13 October 2026, a full page took 1,243 to 1,273 prompt tokens and was answered in 221 to 312 ms of server time, without the network.
-   **Access.** Call `paddleocr-vl-1.6` directly on the API at `https://api.serenityedge.ai/v1`. Since 2026-10-14 it is also ready for the [OpenRouter onboarding](https://docs.serenityedge.ai/docs/access/openrouter/), which is not live yet.
-   **Output length.** A `max_tokens` or `max_completion_tokens` above 8,192, the model's maximum output, is clamped to 8,192 rather than refused.

## Precision

The open models publish their serving precision in the `quantization` field of `GET /v1/models`: `qwen3.8-27b` and `qwen3.6-35b-a3b` run in NVFP4, a 4-bit floating-point format, which is what their published prices assume, and `paddleocr-vl-1.6` runs in BF16, the precision of its published weights. The Orion ids do not publish a precision.

## Decision models

> **Preview**
> 
> Decision models are in public preview. Their availability will be announced in the [release notes](https://docs.serenityedge.ai/release-notes/).

Decision models answer typed questions (yes or no, one of several options, a level on a scale) with calibrated probabilities instead of generating text, on their own endpoints: `POST /v1/decisions` and `POST /v1/systemone`. They are not chat models and are not listed in the catalogue above. `orion-compass` is for questions that need more depth; `orion-compass-flash` is for the lowest latency and price at volume. See [Decisions](https://docs.serenityedge.ai/docs/decisions/) for when to use them and how.

The table is read from `GET /v1/models?format=openai` when this page is published and again when you open it.

| Model id | Context | Reads | Input | Output | Endpoints |
| --- | --- | --- | --- | --- | --- |
| `d3`, also `vllm-sr/d3` | 24,576 | text, image | $0.042 | Free | /v1/decisions, /v1/systemone |
| `orion-compass`, alias of `orion-compass-26.1` | 32,000 | text | $0.034 | Free | /v1/decisions, /v1/systemone |
| `orion-compass-flash`, alias of `orion-compass-flash-26.1` | 32,000 | text, image | $0.017 | Free | /v1/decisions, /v1/systemone |

Read from the API (`GET /v1/models?format=openai`) when this page was published, on 20 November 2026, 14:40 UTC.

## Embeddings, rerank and redaction

Three more models are served on their own routes, for search, retrieval-augmented generation and privacy: `qwen3-embedding-0.6b` on `POST /v1/embeddings` (vectors in OpenAI's format), `qwen3-reranker-0.6b` on `POST /v1/rerank` (relevance scores in the format of Cohere and Jina) and `privacy-filter` on `POST /v1/redact` (personal data found and masked). They are not chat models and are not listed in the catalogue above. See [Embeddings, rerank and redaction](https://docs.serenityedge.ai/docs/embeddings-rerank-and-redaction/) for how to call them.

The table is read from `GET /v1/models?format=openai` when this page is published and again when you open it. Prices are in US dollars per million input tokens.

| Model id | Input | Endpoint |
| --- | --- | --- |
| `privacy-filter`, also `openai/privacy-filter` | $0.009 | /v1/redact |
| `qwen3-embedding-0.6b`, also `qwen/qwen3-embedding-0.6b` | $0.008 | /v1/embeddings |
| `qwen3-reranker-0.6b`, also `qwen/qwen3-reranker-0.6b` | $0.008 | /v1/rerank |

Read from the API (`GET /v1/models?format=openai`) when this page was published, on 20 November 2026, 14:40 UTC.

## Speech to text

`vibevoice-asr` transcribes audio files on `POST /v1/audio/transcriptions`, in the format of OpenAI's speech-to-text API, with speaker labels and timestamps for each segment on request. It is not a chat model and is not listed in the catalogue above. See [Speech to text](https://docs.serenityedge.ai/docs/audio-transcriptions/) for how to call it, its limits and its quality.

The table is read from `GET /v1/models?format=openai` when this page is published and again when you open it. The price is in US dollars per second of audio.

| Model id | Per second of audio |
| --- | --- |
| `vibevoice-asr`, also `microsoft/vibevoice-asr` | $0.000047 |

Read from the API (`GET /v1/models?format=openai`) when this page was published, on 20 November 2026, 14:40 UTC.
