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

# Supported models

> Every base model available for post-training, with training modes, context lengths, GPU types, and adapter capacity.

Consider these factors when choosing a base model:

* **Training mode:** Every model supports low-rank adapter (LoRA) training. Not every model supports full-weight training. Check the **Training modes** column in the catalog, or [list models programmatically](#list-supported-models-programmatically).
* **Context length:** The trainer's maximum sequence length differs between LoRA and full-weight training.
* **GPU type:** Post-training currently runs only on B200 GPUs (`B200-SXM`). Support for B300 and GB300 GPUs will be added soon.
* **Adapter capacity:** Each resource caps how many LoRA sessions it accepts at once, which matters if you plan to train several adapters together.

Start with `Qwen/Qwen3.8-27B` to get your training loop working, then scale up once it runs.

<Note>
  The post-training service currently only supports text models. To fine-tune on images, use [vision fine-tuning](/docs/fine-tuning/vision).
</Note>

## Catalog

This table lists the public B200 configurations and syncs daily from `/v1/rl/supported-models`. For the live catalog, [list the models programmatically](#list-supported-models-programmatically).

| Model | API ID | GPU types | Training modes | Max context (LoRA) | Max context (full) | Max LoRA rank | Generator context | LoRA sessions per resource |
| - | - | - | - | - | - | - | - | - |
| Qwen3.6 35B A3B | `Qwen/Qwen3.6-35B-A3B` | `B200-SXM` | LoRA | 262,144 | Not supported | 64 | 262,144 | 5 |
| Qwen3.8 27B | `Qwen/Qwen3.8-27B` | `B200-SXM` | LoRA, full | 262,144 | 131,072 | 64 | 262,144 | 5 |
| Kimi K3 | `moonshotai/Kimi-K3` | `B200-SXM` | LoRA | 65,536 | Not supported | 32 | 69,632 | 3 |
| GLM 5.3 | `zai-org/GLM-5.3` | `B200-SXM` | LoRA | 159,744 | Not supported | 32 | 163,840 | 3 |
| MiniMax M3 | `MiniMaxAI/MiniMax-M3` | `B200-SXM` | LoRA | 262,144 | Not supported | 32 | 262,144 | 3 |

How to read the columns:

* **Training modes:** Every model lists **LoRA**. Models that also list **full** support full-weight training. For the others, use `lora_enabled=True`.
* **Max context:** The longest sequence (prompt plus response) that one `forward_backward` sample can hold.
* **Generator context:** The longest sequence (prompt plus completion) that a `sample` call can handle. Where it's larger than **Max context (LoRA)**, keep [GRPO](/docs/post-training/grpo) rollouts within the trainer's limit, because `forward_backward` rejects longer samples.
* **LoRA sessions per resource:** The number of adapter sessions one resource accepts at once. The service catalog sets this limit per model and per GPU type. The API doesn't return it yet, so this column is maintained by hand. To train several adapters on one resource, see [Train multiple adapters on one base model](/docs/post-training/multi-lora).

### Single-session variants

The following models also support single-session variants for better throughput. These variants support LoRA training only and accept a single LoRA adapter, so each resource can run only one training session at a time.

* **Qwen3.6 35B A3B:** `Qwen/Qwen3.6-35B-A3B-single-session`.
* **Qwen3.8 27B:** `Qwen/Qwen3.8-27B-single-session`.

## List supported models programmatically

To list the live B200 configurations:

```python theme={null}
from together import Together

client = Together()

for model in client.post_training.supported_models.get().data:
    for config in model.compute_configs or []:
        print(model.base_model)
        trainer = config.trainer_config
        generator = config.generator_config
        modes = []
        if trainer is not None and trainer.lora is not None:
            modes.append(f"lora (ctx {trainer.lora.max_seq_length})")
        if trainer is not None and trainer.full is not None:
            modes.append(f"full (ctx {trainer.full.max_seq_length})")
        if generator is not None:
            modes.append(f"sampling (ctx {generator.context_length})")
        print(f"  {config.gpu_type}: {', '.join(modes)}")
```

The output has one block per model, like this:

```text theme={null}
Qwen/Qwen3.6-35B-A3B
  B200-SXM: lora (ctx 262144), sampling (ctx 262144)
```

To run a similar listing from a cookbook checkout, use `uv run python scripts/supported_models.py`.

## Choose a GPU type

Set `gpu_type="B200-SXM"` inside `ComputeConfig` when you [create a resource](/docs/post-training/model-resources#create-a-resource). The trainer and generator always run on the same GPU type.

Check the model's row in the catalog for the training modes available on B200.

## Request a model

To request a model or config that isn't in the catalog, contact your Together AI account team.


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