> ## 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 self-managed Poolside inference 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.

## Get started

* [Try a Poolside model](https://chat.poolside.ai/) in your browser. No sign-up required.
* [Follow the quickstart](/get-started/quickstart) to use a model with `pool`.
* [Use the Poolside API](/api/overview) for base URLs, model IDs, authentication, and request examples.
