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

# Supported models

> Compare supported Poolside models by intended use, context window, and reasoning support.

Poolside models are foundation models for software engineering. Use this page to choose a model, compare reasoning support and context windows, and find the right setup guidance for API access or deployment planning.

Supported models are models that Poolside validates, ships, upgrades, patches, and helps operate in a Poolside deployment. Model availability, provider-specific variants, and model IDs can vary by access method.

## Compare models

| Detail         | [<img src="https://mintcdn.com/poolside/rJq4dlnoOSHhVAZp/images/landing/laguna-s-2-1-banner.svg?fit=max&auto=format&n=rJq4dlnoOSHhVAZp&q=85&s=268dec910a80faf724c0fb2456c09167" alt="Laguna S 2.1" width="699" height="176" data-path="images/landing/laguna-s-2-1-banner.svg" />](/release-notes/models#laguna-s-2-1)<br />[Laguna S 2.1](/release-notes/models#laguna-s-2-1) | [<img src="https://mintcdn.com/poolside/kkMWX_7zqePBFTSJ/images/landing/laguna-xs2-1-banner.svg?fit=max&auto=format&n=kkMWX_7zqePBFTSJ&q=85&s=eac5353718aa8fac2228bf8cd8a4e1c0" alt="Laguna XS 2.1" width="699" height="176" data-path="images/landing/laguna-xs2-1-banner.svg" />](/release-notes/models#laguna-xs-2-1)<br />[Laguna XS 2.1](/release-notes/models#laguna-xs-2-1) | [<img src="https://mintcdn.com/poolside/kkMWX_7zqePBFTSJ/images/landing/laguna-m1-banner.svg?fit=max&auto=format&n=kkMWX_7zqePBFTSJ&q=85&s=adc60dffb9cb8d80995501917f0c3954" alt="Laguna M.1" width="699" height="176" data-path="images/landing/laguna-m1-banner.svg" />](/release-notes/models#laguna-m-1)<br />[Laguna M.1](/release-notes/models#laguna-m-1) |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Best for       | Long-horizon agentic coding and extended tool-use workflows                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Fast agentic coding and rapid iteration                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Complex, multi-step coding tasks where agent quality matters more than raw throughput                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Parameters     | 118B total, 8B active per token                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 33B total, 3B active per token                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 225B total, 23B active per token                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Context window | 1M tokens                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 256K tokens                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 256K tokens                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Model type     | Mixture of Experts                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Mixture of Experts                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Mixture of Experts                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Modality       | Text-to-text                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Text-to-text                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Text-to-text                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Reasoning      | Native reasoning with thinking on or off per request                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Native reasoning with thinking on or off per request                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Native reasoning with thinking on or off per request                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Model weights  | [Hugging Face](https://huggingface.co/poolside/Laguna-S-2.1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | [Hugging Face](https://huggingface.co/poolside/Laguna-XS-2.1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | [Hugging Face](https://huggingface.co/poolside/Laguna-M.1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| License        | OpenMDW-1.1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | OpenMDW-1.1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Apache 2.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |

## Reasoning terminology

Poolside and compatible providers use related terms for model reasoning behavior:

* **Reasoning**: The general model capability or behavior. In API contexts, this can also refer to fields such as OpenRouter's `reasoning` object or assistant `reasoning_content`.
* **Thinking**: The Poolside term for turning reasoning behavior on or off per request.
* **Effort**: A generic scale used to express how much reasoning to request. ACP clients support `default`, `max`, `xhigh`, `high`, `medium`, `low`, `minimal`, and `none`; OpenRouter `reasoning.effort` values depend on provider model metadata.
* **Thought level**: The ACP session config option that maps to effort values.

## Access models

How you access Poolside models determines which API base URL, reasoning controls, and model IDs are available.

To find model IDs for your access method, see [List available models](/api/openai-api-examples#list-available-models).

| Access method                              | API base URL                                       | Reasoning controls                                                                                                                                                                                                                     |
| ------------------------------------------ | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Poolside Platform                          | `https://inference.poolside.ai/v1`                 | Poolside Platform enables thinking by default. To turn it off for an API request, set `chat_template_kwargs.enable_thinking` to `false`. In Poolside ACP sessions, thought level maps `max` to thinking on and `none` to thinking off. |
| Poolside deployment                        | `https://<api-domain>/openai/v1`                   | Depends on the deployed models and serving configuration.                                                                                                                                                                              |
| OpenRouter                                 | `https://openrouter.ai/api/v1`                     | OpenRouter `reasoning.effort`. Supported values depend on provider model metadata.                                                                                                                                                     |
| OpenAI-compatible provider or local server | The base URL your provider or model server exposes | Provider-specific.                                                                                                                                                                                                                     |

<Tip>
  Want to try a model before choosing an access method? Use [chat.poolside.ai](https://chat.poolside.ai/) to send prompts from your browser. No sign-up required.
</Tip>

For authentication and request examples, see [Poolside API](/api/overview). To choose a login method for `pool`, see [Log in to Poolside](/get-started/log-in).
