---
title: Models and providers
description: Connect the providers you have a plan with or add a custom provider, then pick a model, its effort and its variant for each chat.
canonical_url: https://lookout.arcadia.is/docs/models
type: guide
section: Use Lookout
last_updated: 2026-11-16
related:
  - https://lookout.arcadia.is/docs/usage
  - https://lookout.arcadia.is/docs/troubleshooting
---

> Every page of these docs: https://lookout.arcadia.is/llms.txt

# Models and providers

Connect the providers you have a plan with or add a custom provider, then pick a model, its effort and its variant for each chat.

Lookout runs on plans you already have. A provider is the company you hold the account with (OpenAI for a ChatGPT
plan, Anthropic for a Claude plan or a Claude API key); you connect it once with its own sign-in, and its models then
appear in the model menu of every chat. OpenCode's free models are on from the start, so a chat can run before you
connect anything.

## Connect a provider

1. Open **Settings › Providers**, or click the settings glyph at the foot of the model menu's rail in the message box.
2. Under **Available**, click the sign-in on the provider's row: it names what you hold, such as **Sign in with
   ChatGPT** or **Sign in with Claude**, or **Add API key** for a key. Anthropic's **Sign in** offers both.
3. Finish the step on the provider's page, which the sign-in opens (below).

The provider moves to **Connected** and its models join the model menu. Click a provider's row to open its page:
**Accounts** (each account and what its plan has left), **Plan use** (with two or more accounts, or extra usage) and
**Models**. **Providers** in the page's title, or Escape, goes back to the list. Anthropic's page lists its Claude
plans and its API key together, then each one's plan use and models under its own name.

These sign-ins happen in the app. Your Lookout account carries them to your other machines, so a machine with only
the CLI gets them once it is on your account: [Providers on this machine](https://lookout.arcadia.is/docs/cli#providers).

**Sign out** on an account signs it out on all your devices and on the web dashboard, whether it still works or its
sign-in expired. An expired sign-in your account holds reads **Sign-in expired** on every device's Providers page,
even on one that never had it, with **Sign in again** and **Sign out**, and counts there as it does on the dashboard.
It stays listed until you do one or the other.

### On a machine with only the CLI

With no Lookout account, or before the machine is on it, the CLI still runs:

- OpenCode's free models, with no sign-in.
- A provider whose key is in the environment of the process running Lookout (your shell, or the service's unit):
  `META_API_KEY` (Muse Code), `COMMAND_CODE_API_KEY` (Command Code), `KIMI_API_KEY` (Kimi Code), `LOOKOUT_ZAI_KEY`
  (Z.ai Coding Plan) and `LOOKOUT_DEEPSEEK_KEY` (DeepSeek). The key stays on that machine and never syncs.
- On macOS, an Anthropic API key kept in the Keychain: `lookout providers import-key anthropic --keychain SERVICE`
  ([With an API key](https://lookout.arcadia.is/docs/models#api-key)).

### With a code

SpaceXSI (Grok), Moonshot AI (Kimi) and Meta (Muse Code). Lookout opens the provider's page and the row shows **Your code**. Enter the code on that page
and approve. **Copy code and open the page** copies the code and opens the page again. The code expires: the row
says when.

### In the browser

Google (Antigravity), OpenAI (ChatGPT), Anthropic (Claude) and Command Code. For your first account Lookout opens the provider's sign-in page, and
the row says **Finish in your browser.** until you do. **Open it again** opens the page again. When the provider
already has an account, the page doesn't open by itself: the step offers **Open sign-in** and **Copy link for a
private window** side by side, because the page signs in whoever your browser is already signed in as. When Lookout
knows which account the step is for, it says so, for example **Approve as you@example.com on claude.ai.**

The page signs in whoever your browser is already signed in as. For another account, click **Copy link for a private
window** (or **Copy the link** on a first sign-in) and open it in a private window or another browser profile on the
same Mac ([Add another account](https://lookout.arcadia.is/docs/usage#add-account)). If the page signs in an account you already added, nothing
is added and the page says so: choose **Add account** again and use **Copy link for a private window**.

### From another device

OpenAI (ChatGPT), Google (Antigravity) and Anthropic (Claude plan) can be finished in a browser on any device, such as
your phone or a friend's computer. Click **Use another device** under the step, then **Copy the link**, and open it in
that browser and approve:

- **Anthropic**: the page then shows a code. Paste it into the field under the step.
- **OpenAI** and **Google**: that browser then lands on a page that won't open, because it points back at the machine
  running Lookout. Copy that page's whole address from the address bar and paste it into the field.

Lookout tries what you paste at once and adds the account. The code or address works for this sign-in only, once: if
it has expired or was already used, open the link again. A sign-in [with a code](https://lookout.arcadia.is/docs/models#code) works from any
device as it is. Command Code's sign-in finishes in a browser on the machine running Lookout only.

When the Command Code CLI is signed in on this device, the row offers that sign-in first: click **Use this
account**, or **Sign in with another account**.

Every Claude account in Lookout is Lookout's own sign-in: Lookout renews it itself, it syncs to your other devices,
and it keeps working whatever Claude Code is signed in to, so you can switch Claude Code between your subscriptions
as often as you like. When Claude Code is signed in to an account you haven't added, **Sign in with Claude** offers it: **Add
you@example.com** starts the sign-in for that account, and the step says **Approve as you@example.com on
claude.ai.** If your browser is signed in to claude.ai as another account, use **Copy link for a private window**,
sign in to claude.ai there as that account, and approve. Use one private window per account, and close it before the
next. If you keep one Claude Code login per account (a `CLAUDE_CONFIG_DIR` each, such as
`CLAUDE_CONFIG_DIR=~/.claude-work claude`), Lookout offers each of their accounts in turn. Signing an account out in
Lookout doesn't affect Claude Code.

Lookout never reads Claude Code's sign-in, only which account it is signed in to. A Claude account an older version
borrowed from Claude Code no longer works: add it again with **Sign in with Claude**. A Claude sign-in lasts about a
month; three days before it ends, its row says **Sign-in ends** with the date and offers **Sign in again**, and keeps
working until then.

### With an API key

Anthropic, DeepSeek and Z.ai. Click **Add API key** and paste your key. **Get a key** opens the provider's page that
issues keys. Lookout checks the key with the provider, and a key the provider refuses is not kept.

Anthropic is one provider with two kinds of access: a Claude Pro, Max or Ultra plan (**Sign in with Claude**, bought
on claude.ai) and an API key from the Claude Console (**Add API key**, billed per token). Either works alone, or both
together, and the Anthropic row lists every account of both, each naming its kind (**Claude Ultra**, **API key**). Its
**Add account** offers **Sign in with Claude** first and **Add API key** second; the key goes in a dialog whose **Get a
key** opens the Claude Console's API keys page. The key's models have their own IDs (`anthropic/` and the model's
name), so a chat says which bill it runs on, and where the model menu lists a model on both, the API key's row ends with **API key** and each row's
tooltip says **On your Claude plan** or **On your API key**. The provider reports no balance for a normal key, so the key's line shows budget
left: the budget you set minus what Lookout counted as spent on this device, at Anthropic's list prices ([Read a
plan's meters](https://lookout.arcadia.is/docs/usage#meters)). That is not Anthropic's remaining credit. To bring in a key you keep in the macOS
Keychain without pasting it:

```sh
lookout providers import-key anthropic --keychain SERVICE [--keychain-account ACCOUNT] [--models claude-haiku-5-5] [--budget 100]
```

The key is read from the Keychain item, checked with Anthropic and kept like a pasted one, and it is never printed.
`--models` limits the account to those models (the others stay listed as **not enabled for this key**), and
`--budget` stops it once its spend reaches that many US dollars.

### With another app's sign-in

Cognition's Devin signs in through its own command-line app. When that app is signed in on this device, **Sign in
with Devin** uses its sign-in. When it isn't, the row shows the command to run first: run it in a terminal and sign in, and
Lookout picks the sign-in up by itself.

| Provider | App | Command |
|---|---|---|
| Cognition | The Devin CLI | `devin auth login` |

### A free tier

OpenCode needs no sign-in, and its free models are on from the start. To take them out of the model menu, open the
OpenCode row and choose **Remove** from its menu. **Add** brings them back. This choice stays on the device you make
it on. OpenCode's free models run in chats only: subagents and workflow agents are not offered them.

The list follows OpenCode's own: Lookout reads the model catalog the OpenCode app reads (models.dev), so a model
OpenCode makes free joins the model menu, with its context, output limit and effort levels as OpenCode lists them,
within the hour and without a restart, and one it retires leaves it. A chat set to a retired model keeps its history,
and its next message says the model left OpenCode's free models and names those free now; **Continue on** under it
moves the chat. Names show as OpenCode writes them. When the OpenCode app is signed in with an OpenCode Go key,
Go's free models show too, marked **(Go)**; they run on that key.

When OpenCode refuses Lookout's client on a model, the chat that hit it says so and that model reads unavailable on
that device until a request to it succeeds again. When it refuses every free model, the row in **Settings ›
Providers** reads **Refused Lookout's client since** the day it began, with what OpenCode said on its page.

## Providers

| Provider | What you need | Sign-in | Accounts | Web search |
|---|---|---|---|---|
| Anthropic | A Claude Pro, Max or Ultra plan, a Claude API key billed per token, or both | [In the browser](https://lookout.arcadia.is/docs/models#browser), [API key](https://lookout.arcadia.is/docs/models#api-key) | Up to 15 of each | Yes |
| Cognition | A Devin seat | [The Devin CLI](https://lookout.arcadia.is/docs/models#other-app) | 1 | Yes |
| Command Code | A Command Code plan | [In the browser](https://lookout.arcadia.is/docs/models#browser) | Up to 15 | No |
| DeepSeek | A prepaid DeepSeek API balance | [API key](https://lookout.arcadia.is/docs/models#api-key) | Up to 15 | No |
| Google | A Google Antigravity plan | [In the browser](https://lookout.arcadia.is/docs/models#browser) | Up to 15 | No |
| Meta | A Muse Code subscription | [Code](https://lookout.arcadia.is/docs/models#code) | Up to 15 | Yes |
| Moonshot AI | A Kimi Code membership | [Code](https://lookout.arcadia.is/docs/models#code) | Up to 15 | No |
| OpenAI | A ChatGPT plan | [In the browser](https://lookout.arcadia.is/docs/models#browser) | Up to 15 | Yes |
| OpenCode | Nothing: free models from OpenCode Zen | [None](https://lookout.arcadia.is/docs/models#free-tier) | None | No |
| SpaceXSI | A paid X Subscription plan, or a SuperGrok plan | [Code](https://lookout.arcadia.is/docs/models#code) | Up to 15 | Yes |
| Z.ai | A Z.ai Coding Plan | [API key](https://lookout.arcadia.is/docs/models#api-key) | Up to 15 | Yes |

With web search, the agent can search the web while it works. On every model it can still read a web page whose
address it has. Several accounts on one provider: [Accounts and usage](https://lookout.arcadia.is/docs/usage#add-account).

## Custom providers

A model host that isn't in the table, such as a hosted model with its own API or a server on your Mac, is a custom
provider. In **Settings › Providers**, **Add provider** under **Custom providers** asks for a name, the base URL, the
API format it speaks (**Chat Completions**, **Responses** or **Anthropic Messages**) and its key, which stays hidden
unless you show it. Lookout checks the key with the host's model list before it keeps anything, then offers that list:
check the models you want. A model the host doesn't list goes in with **Add model**.

Each model has its ID, the name the model menu shows, its context window and the most a reply may use. **Smart
configuration** fills them from the host's list, or from Lookout's own catalogs when the model is one they know.
**Advanced settings** hold the rest: image input, the host's own web search, the reasoning levels it takes, and the
JSON that carries the chosen level in each request. **Test** sends one small request and says whether it went through.

A custom provider's models appear in the model menu under its name. Its usage counts tokens only: Lookout knows no
plan or price for it. The provider and its key sync to your other devices with your account, sealed in its vault: the
web dashboard counts its tokens under "custom" and never sees its name, address or models. On a machine with only
the CLI, `lookout providers custom add` does the same ([CLI](https://lookout.arcadia.is/docs/cli#providers)).

## Models

A new install lists these models. Once you sign in, the list follows your account: a plan can add a model or a
context window, a model your plan or key can't run says why under its name, such as **Not on your plan** or **Not
enabled for this key**, and one the provider is retiring shows
**Retires** and the date. **Settings › Providers** lists what your account has. The ID is what `lookout exec -m`
takes.

| Provider | Model | Variant | Context | Effort | ID |
|---|---|---|---|---|---|
| Anthropic, API key | Fable 5.2 |  | 1M | Low to Max | `anthropic/claude-fable-5-2` |
| Anthropic, API key | Haiku 5.5 |  | 1M | Low to Max | `anthropic/claude-haiku-5-5` |
| Anthropic, API key | Mythos 5.2 |  | 1M | Low to Max | `anthropic/claude-mythos-5-2` |
| Anthropic, API key | Opus 5.5 |  | 1M | Low to Max | `anthropic/claude-opus-5-5` |
| Anthropic, API key | Sonnet 5.5 |  | 1M | Low to Max | `anthropic/claude-sonnet-5-5` |
| Anthropic, Claude plan | Fable 5.2 |  | 1M | Low to Max | `claude-fable-5-2` |
| Anthropic, Claude plan | Haiku 5.5 |  | 1M | Low to Max | `claude-haiku-5-5` |
| Anthropic, Claude plan | Mythos 5.2 |  | 1M | Low to Max | `claude-mythos-5-2` |
| Anthropic, Claude plan | Opus 5.5 |  | 1M | Low to Max | `claude-opus-5-5` |
| Anthropic, Claude plan | Sonnet 5.5 |  | 1M | Low to Max | `claude-sonnet-5-5` |
| Cognition | Gemini 4 Argon |  | 1M | Low to High | `gemini-4-argon` |
| Cognition | SWE-2 |  | 262K | Medium to Max | `swe-2` |
| Command Code | DeepSeek V4.1 Flash |  | 1M | None to Max | `deepseek-v4.1-flash` |
| Command Code | MiMo V2.6 Pro |  | 1M | Not adjustable | `mimo-v2.6-pro` |
| DeepSeek | DeepSeek V4.1 Flash |  | 1M | None to Max | `deepseek-flash` |
| Google | Gemini 3.8 Flash |  | 1M | Low to High | `gemini-3.8-flash` |
| Google | Gemini 4 Argon |  | 1M | As your plan lists | `antigravity/gemini-4-argon` |
| Google | Gemini 4 Carbon |  | 1M | As your plan lists | `antigravity/gemini-4-carbon` |
| Google | Gemini 4 Hydrogen |  | 1M | As your plan lists | `antigravity/gemini-4-hydrogen` |
| Meta | Spark 1.3 |  | 1M | Minimal to Extra high | `muse-spark-1.3` |
| Meta | Spark 1.3 | Contributor | 1M | Minimal to Max | `muse-spark-1.3-contributor` |
| Meta | Wonder 1.0 |  | 1M | Minimal to Max | `muse-wonder-1.0` |
| Meta | Wonder 1.0 | Contributor | 1M | Minimal to Max | `muse-wonder-1.0-contributor` |
| Meta | Wonder 1.0 Full |  | 1M | Minimal to Max | `muse-wonder-full-1.0` |
| Meta | Wonder 1.0 Full | Contributor | 1M | Minimal to Max | `muse-wonder-full-1.0-contributor` |
| Moonshot AI | Kimi K2.8 Preview |  | 1M | Low to Max | `kimi-for-coding` |
| Moonshot AI | Kimi K3.1 Pro |  | 1M | Low to Max | `k3.1-pro` |
| Moonshot AI | Kimi K3.1 Pro | Highspeed | 1M | Low to Max | `k3.1-pro-highspeed` |
| OpenAI | GPT-6 Astra |  | 272K | Low to Max | `gpt-6-astra` |
| OpenAI | GPT-6 Astra | Fast | 272K | Low to Max | `gpt-6-astra:priority` |
| OpenAI | GPT-6 Luna |  | 272K | Low to Max | `gpt-6-luna` |
| OpenAI | GPT-6 Luna | Fast | 272K | Low to Max | `gpt-6-luna:priority` |
| OpenAI | GPT-6.1 Sol |  | 500K | Low to Max | `gpt-6.1-sol` |
| OpenAI | GPT-6.1 Sol | Fast | 500K | Low to Max | `gpt-6.1-sol:priority` |
| OpenAI | GPT-6.1 Terra |  | 500K | Low to Max | `gpt-6.1-terra` |
| OpenAI | GPT-6.1 Terra | Fast | 500K | Low to Max | `gpt-6.1-terra:priority` |
| OpenCode | OpenCode's free models, as OpenCode lists them ([A free tier](https://lookout.arcadia.is/docs/models#free-tier)) |  |  |  | OpenCode's own, such as `big-pickle` |
| SpaceXSI | Grok 4.7 |  | 256K | Low to Extra high | `grok-4.7` |
| SpaceXSI | Grok 4.7 | Fast | 256K | Low to Extra high | `grok-4.7-fast` |
| Z.ai | GLM-5.3 |  | 1M | Low to Max | `GLM-5.3` |
| Z.ai | GLM-5.3 Flash |  | 1M | Low to Max | `GLM-5.3-Flash` |

Fable 5.2 starts at **Medium** effort on both a Claude plan and an Anthropic API key, with a 1M context window and
up to 128K output tokens. Saved Fable 5.1 model selections move to Fable 5.2 within the same provider; Lookout says
when the selection changes. An effort you already chose stays chosen.

Mythos 5.2 needs Anthropic's approval on each account, and it starts switched off ([below](https://lookout.arcadia.is/docs/models#lineup)). It
runs once one of your signed-in accounts lists it (Lookout reads each account's model list, which costs nothing), only
on the accounts that have it, and Anthropic's page in **Settings › Providers** says on how many of your accounts it is. Until then its row
reads **Off by default: needs approval for your account**.

Gemini 4 Carbon, Hydrogen and Argon on Google start switched off. Lookout reads your Antigravity plan's own model list,
which costs nothing: a model the plan marks unavailable reads **Off by default: not on your plan**, and where Lookout
says why, it names the plans that have it in Google's words ("needs an Ultra plan"). A plan that includes one runs it
by the name, window and effort levels the list gives. Cognition's Gemini 4 Argon is a model of its own under
Cognition, with its own ID.

## Choose which models your lists show

Each model under **Models** on a provider's page in **Settings › Providers** has a switch. On, the model is in your model list: the model
menu in the message box, an agent's **Profile** (its model, its fallbacks and the
models it may run on), the subagent model in **Settings** and in a project's settings, **Continue on**, the model a new
chat starts on, and the lists your agents read (`Sessions`, `lookout_models`, the models a Task names when it refuses).
Off, the model leaves all of them. **Choose models**, the settings glyph at the foot of the model menu's rail, opens that provider's page at its
**Models**. On Anthropic's page the Claude plan's models and the API key's each have their own group of switches. With every model switched
off, the menu says **No models in your list**, and a new chat still starts where it would have.

A switch hides a model; it never takes one away. A chat, project, agent, fallback list or subagent default that
already uses a model you switch off keeps running on it, and where it is set the model reads **Not in your model
list**, still there to pick. A model named by its ID, its name or its family, from a Task, the CLI, MCP or the API,
runs as before. A switch never moves the model a new chat starts on from your plan to one billed per token. A model can
start off, such as one that needs your account approved first: its row says so. A provider whose models are all off
has no group in the model menu. The switches belong to the machine that runs your chats, as its accounts do.

Only you change them, in the app, at your terminal or from your own MCP client, as with how a provider's accounts take
requests; an agent and a chat's Shell are refused:

```sh
lookout providers models PROVIDER               # its models and their switches
lookout providers models PROVIDER --off ID      # out of your lists
lookout providers models PROVIDER --on ID       # back in
lookout providers models PROVIDER --reset ID    # back to the model's default
```

A switch you set for a model the provider no longer lists is kept but read nowhere; the list shows it, and `--reset`
clears it.

## Pick a model for a chat

1. In the message box, click the model's name (it reads with its effort, such as **Opus 5.5 Max**), or press `⌘E`.
2. Choose a provider on the rail down the menu's side, then a model: the list names the provider and its plan once,
   then its models by name. Rest the pointer on a model for its context and effort range. **Search models** at the
   top finds a model across every provider. The chip at the end of the chosen model's row opens its effort and its
   own switches; `⌘E` opens the menu there, and `←` `→` step the effort from any row. With two or more accounts at a
   provider, the chip at the end of its line picks the chat's account: **Auto**, or one account, each with what it has
   left. The menu lists the models your switches show ([Choose which models your lists show](https://lookout.arcadia.is/docs/models#lineup)).
3. Send your message.

Each chat keeps its own model. Switch it at any time: a turn already running finishes on the model it started with,
and your next message runs on the new one. Its subagents that took the chat's model move along the next time they
run; one you put on a model of its own keeps it ([subagents](https://lookout.arcadia.is/docs/subagents#model)). A new chat starts on the model
you picked last, while it or the same model from another provider can run. Lookout never moves a chat onto a provider
billed per token, such as an API key, without you choosing it: when only such a provider could run it, the message box
offers the switch instead ([When a model can't run](https://lookout.arcadia.is/docs/models#cant-run)).

From a terminal, name a model by its ID:

```sh
lookout exec -m ID --effort LEVEL "PROMPT"
lookout resume THREAD -m ID "PROMPT"
```

An ID whose provider is signed out or doesn't offer it here runs as the same model on another provider you have, and
the run says where first, as long as that provider isn't billed per token: `anthropic/claude-haiku-5-5` with no
Anthropic key and a Claude plan connected runs as `claude-haiku-5-5`. The other way round is never automatic:
`claude-haiku-5-5` with no Claude plan connected and an Anthropic key added stops before the run and names the
command that runs it on the key, billed per token (`lookout exec -m anthropic/claude-haiku-5-5`). An ID that can run here
always runs as named. `resume` with `-m` switches that chat to the model. `--effort` takes none, minimal, low, medium,
high, xhigh or max; a level the model doesn't offer moves down to the closest level it has, or up to its lowest when it
has none below ([Choose the effort](https://lookout.arcadia.is/docs/models#effort)). Leave it out for a model whose effort is not adjustable:
Lookout refuses the run otherwise.

### A model outside your plan

A model the provider still serves after your plan ended, or while it reports no plan at all, is billed per token by
the provider: Meta answers Spark 1.3 and Wonder 1.0 over its paid API on the same key once a Muse Code plan has
ended. Such a model ends its row in the model menu with **API key**, and the usage card beside the message box
names it **API key**, **Billed per token**, with no meter. It runs when you pick it for a chat or an agent, and never
otherwise: a new chat or agent doesn't start on it, no fallback moves to it, and an account still on the plan takes its
requests first.

## Choose the effort

Effort sets how long the model reasons before it answers: lower is faster, higher is smarter. The level follows
the model's name in the message box, a shade lighter, and the same menu sets both: the effort sits under the models.

1. Click the model's name, or press `⌘E` in the message box to go straight to the effort.
2. Move the slider between **Faster** and **Smarter**, or use `←` and `→` (from any model row too).
3. Press `⏎` to keep it, or `Esc` to go back to the level you had.

You can also type `/effort` and one of the model's levels in the message box: `/effort high`, `/effort extra high`, or a
number counting from the model's lowest level. The levels, lowest first, are None, Minimal, Low, Medium, High, Extra
high and Max. Each model offers some of them, from the lowest to the highest the Effort column above names; some skip
a level in between, and the slider shows only the model's own. When you switch models, the effort moves to the nearest
level the new model has at or below it, or to its lowest when it has none below: Max on a model that tops out at Extra
high runs at Extra high. A model whose effort is not adjustable shows its name alone, and its menu no slider.

A change of effort while a turn runs applies from that turn's next request; a change of model waits for the turn to end. The chat notes each change, who made it (you, an MCP client by its name, the fallback policy) and when it applies.

## Turn on a variant

A variant is an option on the same model, such as Fast or Contributor. While it is on, the model in the message box
names it, such as **Spark 1.3 Contributor**.

1. Open the model menu and click the chip at the end of the selected model's row: the variant's labeled switch is
   there, with what the variant does under it.
2. Or type `/` in the message box and choose the variant's command, followed by `on` or `off`.

In an agent's **Profile**, open
**Model** or a model under **Fallbacks** to set its variant there. Switching keeps the context window and any effort
the selected model supports; an effort above its range moves down to a supported level.

Lookout remembers your choice for that model. A variant can be on by default: in **Settings › Providers**, the
tooltip on the variant's badge says so. A variant can also widen the effort range: with Contributor on, Spark 1.3 adds
Max.

## Pick a context window

A model with more than one context window is still one row in the model menu. The chip at the end of the chat's
model's row offers its windows: a **Long context** switch when there are two, a **Context** list when there are more.

## When a model can't run

The model menu lists the models that can run now and that your switches show. A chat whose model can't run says why above the message box, and
offers **Use** with the same model on a provider that can run it, named (**Use Haiku 5.5 on your API key, billed per
token**), else with the model a new chat would start on. A switch onto a provider billed per token happens only when
you click it. While the chat's stopped turn offers **Continue on**, the sentence drops **Choose a model** and **Use**:
Continue on is the one move there. A provider whose sign-in expired, or whose plan is used up, never moves a chat to
another provider on its own: sign in again, or see [Accounts and usage](https://lookout.arcadia.is/docs/usage#plan-runs-out).

| The message box says the model isn't available because | What to do |
|---|---|
| The provider isn't connected | [Connect the provider](https://lookout.arcadia.is/docs/models#connect). |
| The provider is signed out | Sign in to it again in **Settings › Providers**. |
| The provider needs a sign-in | The sign-in expired: click **Sign in again** on the provider's row. |
| The provider refused the sign-in | Click **Sign in again** on the provider's row. |
| The provider has no active plan | The plan was canceled or expired: renew it with the provider, or remove the account on the provider's row. |
| It isn't on your plan | Pick another model, or change your plan with the provider. |
| The provider refuses Lookout's client | Pick another model: [its free tier](https://lookout.arcadia.is/docs/models#free-tier) stopped serving Lookout. |
| It isn't available right now | Pick another model. |

A spent plan doesn't stop you from picking a model: the menu says when its limit resets, and
[Accounts and usage](https://lookout.arcadia.is/docs/usage#plan-runs-out) says what happens next. `lookout exec` exits with code 4 when the
model's provider needs a sign-in.

## Related

- [Accounts and usage](https://lookout.arcadia.is/docs/usage.md): Use several accounts per provider, choose how Lookout routes between them, and see what each plan has left.
- [Troubleshooting](https://lookout.arcadia.is/docs/troubleshooting.md): Find your symptom and its fix, run the doctor check, and collect what to send when you need help.
