# Exoscale Documentation — On-Demand Inference

> On-demand Inference documentation for pay-as-you-go AI models.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/

---

# On-Demand Inference

- [Quick Start](https://community.exoscale.com/product/concrete-ai/on-demand-inference/quick-start/index.md) - Use your first On-demand Inference model and call it through an OpenAI-compatible endpoint.
- [Overview](https://community.exoscale.com/product/concrete-ai/on-demand-inference/overview/index.md) - Terminology and key features at a glance, learn the core concepts, capabilities, and options of this service before you dive deeper.
- [How-To](https://community.exoscale.com/product/concrete-ai/on-demand-inference/how-to/index.md) - Practical guides for controlling access to On-Demand Inference models and endpoints.
- [Service Boundaries - On-Demand Inference](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/index.md) - Service availability, limitations, pricing, and SLA status for On-Demand Inference.
- [Reference - On-Demand Inference](https://community.exoscale.com/product/concrete-ai/on-demand-inference/reference/index.md) - AI API-key and OpenAI-compatible endpoint references for On-Demand Inference.
- [Recipes](https://community.exoscale.com/product/concrete-ai/on-demand-inference/recipes/index.md) - Informational, concise guides showing how to integrate with external tools and solve specific scenarios.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/quick-start/

---

# Quick Start

In this quick start guide, you will create your first AI API Key and use it to
target an Exoscale OpenAI-compatible endpoint.

> [!IMPORTANT]
> **Private Preview**
>
> On-Demand Inference is currently available as a private preview. Review the
> [service boundaries](/product/concrete-ai/on-demand-inference/service-boundaries/index.md) before you
> begin.

This guide uses `Qwen3.8-27B` for a chat-completions request.

## Prerequisites

You need:

* the Exoscale CLI (`exo`) [installed and configured](/reference/cli/exo/index.md)
* an Exoscale API key with access to the `compute` and `ai` services

## First Steps via CLI

### Configure API Access

On-demand Inference is managed through the Exoscale CLI and API.

Create a IAM role with `compute` and `ai` access:

```bash
exo iam role create ai-role --policy '{
  "default-service-strategy": "deny",
  "services": {
    "compute": {"type": "allow", "rules": []},
    "ai": {"type": "allow", "rules": []}
  }
}'
```

Create an IAM API key for the role:

```bash
exo iam api-key create ai-key ai-role
```

Add the key to your CLI configuration:

```bash
exo config add
```


### Create an AI API Key

Create an AI API Key that grants access to all public models:

```bash
exo ai api-key create akey -z at-vie-2 --all-models
```

Without `--all-models`, `--all-deployments`, `--model` or `--deployment`, the key
grants access to nothing. Alternatively, you can restrict the scope of an AI API
key by specifying one or multiple public models:


```bash
exo ai api-key create akey -z at-vie-2 --model "Qwen3.8-27B"
exo ai api-key create akey -z at-vie-2 \
  --model "Qwen3.8-27B" \
  --model "Qwen3-Embedding-8B"
```
```shell
┼─────────────────┼──────────────────────────────────────|
│ ID              │ 9f5d4a1e-31aa-413e-9136-d9d36eabffe1 │
│ Name            │ akey                                 │
| Models          | Qwen3.8-27B                          |
|                 | Qwen3-Embedding-8B                   |
| Deployments     | n/a                                  |
| All Models      | false                                |
| All Deployments | false                                |
┼─────────────────┼──────────────────────────────────────|
```

Note: The scope of an AI API key can be updated later on via the `update` command.


### Use Your AI API Key on an On-Demand Endpoint

Export both values:

```bash
export ENDPOINT_URL="https://inference.at-vie-2.exoscale-cloud.com/v1"
export API_KEY="<ai-api-key>"
```

Always treat the AI API key as a secret.

### Send a Test Request

On-demand Inference endpoints are OpenAI-compatible. You can call the chat completions route with a standard OpenAI-style request body.

```bash
curl -X POST "$ENDPOINT_URL/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "model": "Qwen3.8-27B",
    "messages": [
      {
        "role": "user",
        "content": "Write a short poem about Switzerland."
      }
    ],
    "max_tokens": 300
  }'
```

The hosted Qwen3.8-27B model supports text generation and reasoning, image and
video understanding, coding, tool calling, structured output, and streaming.

#### Supported Chat Completions Parameters

The private-preview `/v1/chat/completions` endpoint supports the following
OpenAI-compatible request parameters for Qwen3.8-27B:

| Purpose | Parameters |
| :--- | :--- |
| Request | `model`, `messages`, `user` |
| Output length and sampling | `max_tokens`, `temperature`, `top_p`, `n`, `stop`, `seed` |
| Penalties | `frequency_penalty`, `presence_penalty` |
| Streaming | `stream`, `stream_options` |
| Reasoning | `reasoning_effort` (`low`, `medium`, or `xhigh`) |
| Tools | `tools`, `tool_choice`, `parallel_tool_calls` |
| Output format | `response_format` |
| Token probabilities | `logprobs`, `top_logprobs` |
| Qwen extensions | `top_k`, `min_p`, `repetition_penalty`, `chat_template_kwargs.enable_thinking`, `chat_template_kwargs.preserve_thinking` |

Text, image, or video content is supplied through `messages`. Use
`exo ai model show` to inspect the capabilities advertised by the currently
hosted version, and review [Limits and Quotas](/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md) for the current service boundaries.

### Send an Embedding Request

Use the embeddings route with `Qwen3-Embedding-8B`:

```bash
curl -X POST "$ENDPOINT_URL/embeddings" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "model": "Qwen3-Embedding-8B",
    "input": "Vienna is the capital of Austria.",
    "dimensions": 1024,
    "encoding_format": "float"
  }'
```

The model accepts up to 32,768 tokens and supports output dimensions from 32
through 4096. The embeddings endpoint accepts `model`, `input`, `dimensions`,
`encoding_format`, and `user`.

Where supported, cache reads are applied automatically and do not require a
request parameter. A cache read occurs when a request reuses a derived cache
entry created from eligible prompt tokens. These tokens are charged at the
lower [cache-read price](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md/index.md#tentative-pricing) instead of the standard input-token price. Cache entries are isolated per
organization and evicted automatically on a best-effort basis. Customers
cannot currently configure how long cache entries remain or set a TTL.

## First Steps via Portal

On-Demand Inference integration with the Exoscale Portal is coming soon. Until
then, use the Exoscale CLI or API to manage AI API keys and access public
models.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/overview/

---

# Overview

Exoscale On-demand Inference is a managed AI service within the Concrete AI
product suite that allows you to access and query AI models through flexible,
pay-per-use endpoints on Exoscale’s sovereign GPU infrastructure.

> [!IMPORTANT]
> **Private Preview**
>
> On-Demand Inference is currently available as a private preview. Review the
> [service boundaries](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/index.md) for current
> limitations, availability, pricing, and SLA status.

## Architecture

On-Demand Inference exposes public models through a shared, zone-scoped
OpenAI-compatible endpoint (`inference.<zone>.exoscale-cloud.com/v1`). A router
in front of the shared inference infrastructure authenticates your AI API key,
checks that its scope permits the requested model, and forwards the request to
the deployment serving that model.

The serving deployments run on GPU infrastructure operated by Exoscale; no
compute resources are provisioned in your organization. Token usage is recorded
per model and per AI API key, which is what per-token billing is based on.

On-demand Inference is designed for applications with variable
traffic patterns or teams looking to integrate AI capabilities rapidly without
ongoing idle hardware costs. It removes the need for upfront infrastructure provisioning, enabling you to
instantly query models through an OpenAI-compatible API and pay strictly for
what you consume, such as tokens generated, pages processed, or minutes of audio
transcribed.

## Terminology

Understanding the key concepts used in On-demand Inference will help you consume models effectively.

Public Model
: A ready-to-use AI model available on Exoscale that can be queried immediately
without uploading custom weights or managing underlying model deployments.

Model Category
: A classification that groups models by their primary use case. A model can
belong to one or more categories. For example, categories could include
general-purpose, coding, embedding, or transcription.

Model Family
: A group of related models that share the same architecture or model lineage.
Each model belongs to exactly one family, while a family can contain multiple
models or model versions. For example, model families could include Qwen,
Mistral, or GLM.

Model Capability
: A supported input, output, or function. A model can have one or more
capabilities, such as text input, image input, text generation, embeddings, or
tool calling.

The category, family and capability values above are illustrative
examples only. They do not represent or guarantee the values currently
available in the model catalog.

Endpoint
: A shared, fully managed inference API endpoint that accepts requests for
multiple **public models** and streams or returns the model output on demand.

AI API Key
: A secure token used to authenticate requests sent to the inference endpoints,
possibly restricted to a set of **public models**.

## Model lifecycle

The On-demand Inference model catalog evolves as new models and model versions
become available. Each model has a lifecycle status so that you can assess
whether it is suitable for production and plan migrations when necessary.

| Status | Description | What does it mean |
| --- | --- | --- |
| Preview | A model available for early evaluation and not intended for production use. | No model-specific availability commitment applies. Its capabilities, behavior, pricing, and availability can change. |
| Active | A fully supported production model. | The On-demand Inference service SLA applies, and the model is available for new and existing use. |
| Deprecated | An active model that is scheduled for retirement and has a published end-of-life (EOL) date. | The model remains operational until its EOL date. Test and migrate to the recommended replacement, when one is available. |
| EOL | A retired model that has been removed from the service. | Requests that use the retired model name fail with a `404` error. |

New models and model versions are added as separate catalog entries. Adding a
new version does not automatically deprecate an existing model, and requests
are never automatically redirected to a replacement. When an Active model is
deprecated, Exoscale publishes its EOL date at least 30 calendar days in
advance and identifies a recommended replacement when one is available.

Before the EOL date, update your application to use the replacement model name
and test for differences in capabilities, pricing, context limits, and API
behavior. Preview models can be changed or retired with a shorter notice
period. Notice periods can also be shortened when required by urgent legal,
security, licensing, or platform-integrity issues.

## Features

OpenAI-Compatible API
: Use familiar OpenAI client libraries and request formats with minimal
application changes.

Model Catalog
: Discover available public models and inspect their category, family,
capabilities, size, lifecycle status, pricing, and context limits.

Scoped AI API Keys
: Grant an AI API key access to all public models or restrict it to selected
models. Update its scope or revoke the key when access is no longer required.

Model Lifecycle Transparency
: Review each model's lifecycle status, EOL date, and recommended replacement,
when available, before planning and testing a migration.

Usage Visibility
: View usage and billing statistics across the service, including request and
token consumption by model, AI API key, location, and billable token type
(input, output, or cache read, where applicable).

Cached Tokens
: Eligible requests can create temporary, derived cache entries. A cache read
occurs when a later request reuses an entry created from eligible prompt
tokens. These reused tokens are charged at the lower
[cache-read price](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md/index.md#tentative-pricing) instead of the standard input-token price, lowering the cost of repeated
context during conversations. Cache entries are isolated per organization and
are not shared between organizations.

Reliability Commitments
: Review the current [SLA status](/product/concrete-ai/on-demand-inference/service-boundaries/sla/index.md) before
planning production workloads.

Shared Inference Infrastructure
: Run inference on Exoscale’s shared, high-performance GPU clusters, eliminating hardware setup overhead and minimum usage commitments.

Transparent Pricing
: Review current and planned rates in [Tentative Pricing](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md).

Automatic Scaling
: Effortlessly handle incoming request bursts; the shared infrastructure automatically handles scaling capacity to maintain fast response times.

Transparency on Location
: Review current model and location availability in [Limits and Quotas](/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md).

Sovereign & Secure
: All models processing takes place strictly within Swiss & European data centers fully aligned with GDPR and data sovereignty requirements.

## Data privacy and handling

Zero Data Retention (ZDR)
: Exoscale does not store raw inference request payloads or model responses
after processing. Exoscale keeps only the metadata needed for usage reporting.
ZDR applies to the Exoscale inference service. Customer applications and
connected tools may store data separately.

Prompt Caching
: To support cache reads, Exoscale temporarily keeps derived representations of
eligible prompt tokens, not the raw prompt text. Cache entries are isolated per
organization and are not shared between organizations. They are evicted
automatically on a best-effort basis, so there is no fixed retention period.
Customers cannot currently configure how long cache entries remain or set a
TTL.

Use of Customer Data
: Exoscale does not use your prompts, inputs, or model responses to train,
retrain, or fine-tune AI models.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/how-to/

---

# How-To

Find practical guides for controlling access to public models and using
On-Demand Inference securely.

- [Manage Access to Public Models](https://community.exoscale.com/product/concrete-ai/on-demand-inference/how-to/manage-model-access/index.md) - Restrict, update, rotate, and revoke AI API keys for On-Demand Inference public models.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/how-to/manage-model-access/

---

# Manage Access to Public Models

Use scoped AI API keys to control which On-Demand Inference public models an
application can access. Create a separate key for each application or workload
so that you can change or revoke its access independently.

> [!IMPORTANT]
> **Private Preview**
>
> On-Demand Inference is currently available as a private preview. Review the
> [service boundaries](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/index.md) before you
> begin.

## Prerequisites

You need:

* the Exoscale CLI (`exo`) [installed and configured](https://community.exoscale.com/reference/cli/exo/index.md)
* an Exoscale API key with access to the `compute` and `ai` services

## Select the Public Models

List the two private-preview public models available in AT-VIE-2 through the
shared endpoint `inference.at-vie-2.exoscale-cloud.com/v1`:

```bash
exo ai model list --visibility=public -z <zone>
```

Display details for a public model:

```bash
exo ai model show <model-id>|<model-name> -z <zone>
```

Example:

```bash
exo ai model show "Qwen3.8-27B" -z at-vie-2
```

Use the model name from the output when creating the AI API key.

## Create a Scoped AI API Key

Create a key that grants access only to the chat-completions model:

```bash
exo ai api-key create akey -z at-vie-2 --model "Qwen3.8-27B"
```

Grant the same key access to both private-preview models:

```bash
exo ai api-key create akey -z at-vie-2 \
  --model "Qwen3.8-27B" \
  --model "Qwen3-Embedding-8B"
```

The command returns the plaintext key once. Store it securely because it
cannot be retrieved later.

## Verify the Scope

Show the key details and confirm that the intended public models are listed:

```bash
exo ai api-key show <name>|<uuid> -z <zone>
```

A key should grant only the access its application requires. For example, an
embedding-only application does not need access to `Qwen3.8-27B`.

## Update Model Access

Updating a key replaces the public models it can access.

```bash
exo ai api-key update
   <name>|<uuid> \
   --model <name> \
   -z <zone>
```

Examples:

```bash
exo ai api-key update akey -z at-vie-2 --all-models # Grant access to all public models
exo ai api-key update akey -z at-vie-2 --model "Qwen3.8-27B"
exo ai api-key update akey -z at-vie-2 \
  --model "Qwen3.8-27B" \
  --model "Qwen3-Embedding-8B"
```

Show the key again after the update to verify its new scope.

## Rotate an AI API Key

To replace a key without interrupting the application:

1. Create a new key with the same model scope and a different name.
2. Store the new plaintext key when it is returned.
3. Configure the application to use the new key.
4. Send a test inference request with the new key.
5. Revoke the old key after the application is using the replacement.

Creating the replacement before revoking the existing key allows both keys to
work during the migration.

## Revoke Access

Revoke a key when an application no longer needs access or after completing a
key rotation:

```bash
exo ai api-key revoke <name>|<uuid> -z <zone>
```

The key no longer authenticates requests after revocation has propagated. It
remains visible in the key list for 30 days before being purged:

```bash
exo ai api-key list -z <zone>
```

## Diagnose Access Errors

| Response | Meaning | Action |
| :--- | :--- | :--- |
| `401 Unauthorized` | The AI API key is unknown or revoked. | Configure the application with an active key. |
| `403 Forbidden` | The key is valid, but its scope does not include the requested model. | Add the model to the key or use a correctly scoped key. |
| `429 Too Many Requests` | The organization's On-Demand Inference consumption quota is exhausted. | Review usage and quota before retrying. |

For complete command syntax, see the [On-Demand Inference CLI reference](https://community.exoscale.com/reference/cli/exo/ai/index.md).

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/

---

# Service Boundaries - On-Demand Inference

> [!IMPORTANT]
> **Private Preview**
>
> On-Demand Inference is currently available as a private preview. Review the
> documented limitations and SLA status before using the service.

- [Limits and Quotas - On-Demand Inference](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/index.md) - On-Demand Inference private-preview limitations, model availability, usage visibility, and tentative pricing.
- [SLA - On-Demand Inference](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/sla/index.md) - On-Demand Inference private-preview SLA and availability status.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/limits-and-quotas/

---

# Limits and Quotas - On-Demand Inference

> [!IMPORTANT]
> **Private Preview**
>
> Functionality, model availability, limits, and prices can change during the
> private preview. The service is intended for evaluation and is not covered by
> an SLA or availability commitment. See [SLA - On-Demand Inference](https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/sla/index.md).

## Availability

On-Demand Inference is available in one zone during the private preview:

| Zone | Country | City | Availability |
| :--- | :--- | :--- | :---: |
| **`at-vie-2`** | Austria | Vienna | yes |

The OpenAI-compatible endpoint is
`https://inference.at-vie-2.exoscale-cloud.com/v1`.

### Inference API Endpoints

On-Demand Inference exposes OpenAI-compatible endpoints under the zone base URL:

`https://inference.<zone>.exoscale-cloud.com/v1`

| Capability | Method and path | Available model |
| :--- | :--- | :--- |
| Chat completions | `POST /v1/chat/completions` | `Qwen3.8-27B` |
| Embeddings | `POST /v1/embeddings` | `Qwen3-Embedding-8B` |

Authenticate inference requests with an AI API key in the HTTP `Authorization`
header:

```text
Authorization: Bearer <ai-api-key>
```

For request examples and supported model parameters, see the
[On-Demand Inference Quick Start](https://community.exoscale.com/product/concrete-ai/on-demand-inference/quick-start/index.md).

## Available Models

The initial private-preview catalog contains two public models. Both process
requests in AT-VIE-2 and are available under the
[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).

| Model | Status | Capabilities | Parameters and format | Context | License |
| :--- | :--- | :--- | :--- | :--- | :--- |
| [`Qwen3.8-27B`](https://huggingface.co/nvidia/Qwen3.8-27B-NVFP4) | [Preview](https://community.exoscale.com/product/concrete-ai/on-demand-inference/overview/index.md#model-lifecycle) | Text generation; text, image, and video input; reasoning; coding; tool calling; structured output; streaming | 27B, NVFP4 | 262,144 tokens | [Apache-2.0](https://choosealicense.com/licenses/apache-2.0/) |
| [`Qwen3-Embedding-8B`](https://huggingface.co/Qwen/Qwen3-Embedding-8B) | [Preview](https://community.exoscale.com/product/concrete-ai/on-demand-inference/overview/index.md#model-lifecycle) | Text embeddings; 100+ languages; instruction-aware retrieval; output dimensions from 32 to 4096 | 8B, BF16 | 32,768 tokens | [Apache-2.0](https://choosealicense.com/licenses/apache-2.0/) |

All private-preview models have the **Preview** lifecycle status. Model
capabilities, behavior, context limits, and availability can change during the
preview. Use `exo ai model show` to inspect the currently hosted version.

Custom model uploads and custom model weights are not supported by On-Demand
Inference. Use [Dedicated Inference](https://community.exoscale.com/product/concrete-ai/dedicated-inference/index.md) when you need to deploy a
different model.

## Access and Management Limitations

On-Demand Inference is managed through the Exoscale CLI and API during the
private preview.

An AI API key can grant access to all public models or be restricted to one or
more selected models. Availability is shared across customers and does not
reserve dedicated inference capacity.

## Usage and Billing Visibility

Usage and billing statistics provide visibility into request and token
consumption by model, AI API key, location, and billable token type. Billable
token types include input, output, and cache read where applicable.

## Tentative Pricing

Prices are tentative, in EUR/CHF/USD per one million tokens. Exoscale reserves the
right to adjust pricing during or after the private preview.

| Model | Input | Output | Cache read | Availability |
| :--- | ---: | ---: | ---: | :--- |
| `Qwen3.8-27B` | 0.40 | 2.40 | 0.09 | Private preview |
| `Qwen3-Embedding-8B` | 0.09 | Not applicable | Not applicable | Private preview |

Cache-read pricing lowers the cost of eligible input tokens reused from the
cache during a conversation. Cache entries are isolated per organization. Customers cannot currently
configure how long cache entries remain or set a TTL. See [Prompt Caching](https://community.exoscale.com/product/concrete-ai/on-demand-inference/overview/index.md/index.md#data-privacy-and-handling) for details.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/service-boundaries/sla/

---

# SLA - On-Demand Inference

> [!IMPORTANT]
> **No SLA During Private Preview**
>
> On-Demand Inference is currently in private preview. No Service Level Agreement
> (SLA), availability target, uptime commitment, or service-credit scheme applies
> to the service during the private preview.

## Service Commitments

The private preview has no guaranteed endpoint availability, inference latency,
throughput, model performance, or model availability. The service, its models,
and its capabilities can be changed, interrupted, or retired during the preview.

On-Demand Inference is intended for evaluation during the private preview and
should not be used for workloads that require a contractual production service
level.

## Client Responsibilities

Clients remain responsible for:

* securing AI API keys and controlling access to the endpoint;
* validating model outputs, behavior, and suitability for their use case;
* managing prompts, inputs, outputs, and their legal or regulatory compliance;
* monitoring usage and costs; and
* designing applications to handle request failures, interruptions, model
  changes, and changes to preview limits.

For the complete shared-responsibility framework, see the
[Exoscale Shared Responsibility Model](https://community.exoscale.com/platform/compliance/shared-responsability-model/index.md).

## After the Private Preview

If Exoscale introduces an SLA for On-Demand Inference after the private preview,
the applicable availability target, exclusions, service credits, and effective
date will be documented on this page.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/reference/

---

# Reference - On-Demand Inference

- [API AI API Keys](https://community.exoscale.com/reference/api/ai/ai-api-key/index.md) - Create, inspect, update, list, and revoke AI API keys. (external)
- [CLI On-Demand Inference](https://community.exoscale.com/reference/cli/exo/ai/index.md) - List public models and manage On-Demand Inference AI API keys. (external)

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/recipes/

---

# Recipes

Informational, concise guides showing how to integrate with external tools and solve specific scenarios.

- [OpenCode Setup](https://community.exoscale.com/product/concrete-ai/on-demand-inference/recipes/opencode/index.md) - Configure OpenCode to use On-demand Inference endpoints from Exoscale, then connect, select your provider, and pick your model.

---

url: https://community.exoscale.com/product/concrete-ai/on-demand-inference/recipes/opencode/

---

# OpenCode Setup

This guide is provided for informational purposes. Because it involves third party tooling we cannot guarantee things still work exactly as described here.

Additional model providers can be added to OpenCode via configuration. This
example assumes that you have access to the private-preview
`Qwen3.8-27B` model in `at-vie-2`.

Write the following json to the `~/.config/opencode/opencode.jsonc` file:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "exoscale": {
      "name": "Exoscale",
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "https://inference.at-vie-2.exoscale-cloud.com/v1"
      },
      "models": {
        "Qwen3.8-27B": {
          "name": "Qwen3.8-27B"
        }
      }
    }
  }
}
```

Adapt as necessary. Once configured:

- run `opencode`
- type `/connect` in the prompt
- select "Exoscale" in the providers list and enter the API key of your
  deployment.
- type `/models` and pick the public model from the list.
