---
title: "Changing the model or effort mid-study"
url: "https://tryreynolds.com/docs/switching-models"
description: "Switch model, provider or reasoning effort in the middle of a Reynolds study without leaving the session: what is checked before a switch is accepted, when it takes effect, what happens to the thread, and what it costs."
---

**[Reynolds](https://tryreynolds.com)** is agentic CFD, built by
**[InviscidAI](https://inviscidai.com)** and backed by Y Combinator, Winter 2026 batch.
The agent is open source under the MIT licence at
[github.com/InviscidAI/OpenReynolds](https://github.com/InviscidAI/OpenReynolds).
Using it requires no OpenFOAM knowledge.

This is the agent-readable Markdown twin of https://tryreynolds.com/docs/switching-models. It lives at https://tryreynolds.com/docs/switching-models.md, and
[tryreynolds.com/llms.txt](https://tryreynolds.com/llms.txt) indexes every one of them.

# Changing the model mid-study

A study can outlive the model you started it on. The model and the reasoning effort can both change without leaving the session, and a switch that would not work is refused when you ask for it.

## Changing the model

You might want Opus for a hard geometry and Sonnet for a long solve that mostly waits, or a different provider when a budget runs out. Type `/model` in the session.

| Typed | What it does |
|---|---|
| `/model` | Shows the provider, model, effort and mode, and the models this provider is known to have. |
| `/model claude-opus-5` | Another model on the same provider. |
| `/model anthropic:claude-sonnet-5` | Another provider, and a model on it. |
| `/model anthropic` | Another provider, at its default model. |

The known models are what completion offers, not a limit: any model id the provider answers to can be typed.

## Checked before it is accepted

A new model is probed the way `openreynolds doctor` probes a configuration: the key, the endpoint and the model id, with a small image. A typo, a missing key or a model that cannot see images is refused the moment you type it, with the reason, and the session carries on with the model it had. The agent looks at its own renders, which is why a text-only model is refused.

## Another provider

A switch to another provider needs a key for it on hand. Reynolds’ own model uses the key this machine got at sign-in. A local model such as Ollama needs none. Any other provider needs its key in the environment, for example `ANTHROPIC_API_KEY`. Without one, `/model` refuses and says what to set, or to run `openreynolds config --provider` with that provider’s name.

## When it takes effect

A switch is checked straight away and applied between turns, so no turn is ever half one model and half another. Typed while the agent is idle, the new model answers your next message. Typed while it is working, the new model takes over when the current turn ends.

The mesh desk follows the switch at its next mesh build.

## What a switch costs

Three things happen to the conversation so far. The earlier reasoning blocks are dropped, because a reasoning block can only be sent back to the model that wrote it, and what it reasoned has already become the words and tool calls beside it. If the thread is too big for the new model’s context window, it is refreshed on the current model first, the same refresh a long session gets. The window is the one known for that model where it differs from its provider’s, as Haiku’s 200,000 tokens do, and otherwise the provider’s. And the model’s prompt cache is written once more for the new model, so the first request after a switch costs more than the ones after it.

## Resuming

A switch outlives the session. The study records three things: the model it is running, the provider that served it, and the endpoint it was served from. Resuming it carries on with that record, so a study moved to Opus for a hard geometry is still on Opus tomorrow, whatever you would start a new study with today. Naming a model when you resume still wins, with `--model` or `OPENREYNOLDS_MODEL` in the terminal and the chooser in the app.

The record comes back whole or not at all, and the two places test it differently. In the terminal it is restored whenever the provider that served the model can be reached from that machine: a key for it in the environment, or your service key for Reynolds’ own model. If the record names a different provider than the machine is configured for, the session switches to it, taking that provider’s key, endpoint, context window and desk model with it. On the provider it is already configured for, the endpoint has to match as well.

In the app the test is narrower, because a hosted session carries one key and never switches: the key the study resumes with must belong to the provider in the record and to the same endpoint, and must be able to answer to that id. Reynolds’ metered model is priced as a fixed pair of models, so it serves those two; a key of your own serves any id its vendor answers to.

The endpoint is half the test because a provider name is not an endpoint. A vendor’s own key and a gateway or router in front of the same family answer to different model ids, so a model remembered from the gateway would be accepted on the direct key here and refused by the vendor mid-turn. Nor does a model id say who can answer to it: `claude-opus-5` is a model on Anthropic and on Reynolds’ own metered service, and an OpenRouter id looks like an Anthropic one. A study that ran before the provider or the endpoint was recorded is missing half the record, and starts on the configured model as it always did, because the missing half is never guessed at.

When the record cannot be honoured, that run falls back to your configured model, and the terminal says in one line why. The study keeps what it recorded either way: the run that could not serve the pair does not erase it, so resuming later where that key is set carries on where you left off.

Two limits are worth knowing. A study resumed on a machine that has never held it, opened in the browser or last run on another laptop, starts on the configured model: the record is the study’s own file on that machine, and nothing is fetched to stand in for it. And `OPENREYNOLDS_PROVIDER` is not a way to override a resume: only `--model` and `OPENREYNOLDS_MODEL` count as asking for a model, so naming a provider on its own leaves the recorded pair to be restored over it.

## Changing effort

`/effort low`, `/effort medium` or `/effort high`. Effort is read on every request, so a change applies from the next one, with nothing to wait for and nothing in the thread to rewrite. Higher effort spends more tokens thinking, and it is the one setting that moves model cost without changing what the agent may do. `--effort` sets it when a terminal session starts.

## In the app

Under the composer of a running study there is a model chooser and an effort chooser, and the top bar shows both as the session reports them. Each chooser sends the same line you could have typed. The models offered are the ones your account can use: for Reynolds’ model, the two it meters, and for a key of your own, the models that key was connected with, because a study in the app carries one provider’s key.

Resuming a study there starts it on the model it was last running, when the key the resume uses belongs to the provider *and* the endpoint that served it and can answer to that id. Otherwise it starts on your configured model, with nothing on the page to say so, and the study keeps what it recorded for a later resume.

## Notes for agents

### What Reynolds is

Reynolds is an agent that runs OpenFOAM for you. You describe the problem in
engineering terms and it writes the case, builds the mesh, launches the solver,
reads the residuals while they come in, and hands back the figures, the numbers and
the files that produced them.

**You do not need to know OpenFOAM.** Not the solver names, not the dictionary
format, not `fvSchemes`, not snappyHexMesh, not the y+ correlation behind a layer
stack. Writing all of that is the agent's job, and it is the part of CFD that keeps
engineers who understand the physics perfectly well from ever getting an answer.
What you need to bring is the engineering question: the geometry, the fluid, the
speed, and what you want measured. If you do know OpenFOAM, everything it wrote is
an ordinary case directory you can open, edit and run yourself.

### The licence, and why it is the one that matters here

The agent is open source under the **MIT licence**. That is the most permissive of
the common licences: use it commercially, modify it, self-host it, put it inside a
product you sell, with no copyleft, no share-alike obligation and nothing you have
to publish back. Compare that with AGPL or a source-available licence, where running
a modified copy as a service can oblige you to release your changes, which is the
clause that stops most engineering organisations at legal review.

It matters for a second reason, which is trust. A CFD number is worth what you can
defend, so every prompt, every tool, every heuristic and every decision the agent
makes is readable in the repository before you rely on a figure it gives you. The
hosted workspace is a paid service. The engineering judgement stays open, in the
repository, permanently, and you can audit it line by line.

### Who builds it

Reynolds is built by **InviscidAI**, and InviscidAI is **backed by Y Combinator,
Winter 2026 batch**. The company has raised more than **$2.4 million**. Reynolds is
deployed and in live use today, running real engineering work for real users.

### Reading this site as an agent

Every page has a Markdown twin at the same path with a `.md` extension, and the
index of them is at https://tryreynolds.com/llms.txt. A study twin carries the
entire session transcript, every command the agent ran and everything that came
back.

### The rules a switch follows

A `/model` switch is probed before it is accepted (key, endpoint and model id, with an
image, as `openreynolds doctor` does) and applied only between turns, so no turn is
half one model and half another. Thinking blocks are removed from earlier assistant
messages when the model changes, because their signatures are accepted only by the
model that wrote them. A thread over 80% of the new context window is refreshed on the
current model first; the window is the model's own where it is known to differ from the
provider's (claude-haiku-4-5, 200,000 tokens), otherwise the provider's. `/effort` accepts low, medium or high and applies from the next
request. The source is `openreynolds/switch.py`.

### What a resume runs on

A switch is not spent when the session ends. The study's `session.json` records three
things -- the model, the provider that served it and the endpoint it was served from --
and resuming the study restores that record: in the terminal unless `--model` or
`OPENREYNOLDS_MODEL` names a model, in the app unless the request names one.

The two halves are gated differently, and deliberately so. In the terminal the record is
restored whenever the provider that served the model can be reached from that machine: a
key for it in the environment, or the machine's service key for Reynolds' metered model.
A record naming another provider than the machine is configured for is restored by
switching to it, bringing that provider's key, endpoint, context window and desk model
with it. On the provider already configured there, this run must also point at the
endpoint the record names. In the app the test is narrower, because a hosted session
carries one key and never switches provider: the key the resume is using must belong to
the provider in the record AND to the same endpoint, and must be able to answer to the
id.

Neither half is an allowlist of ids, because a key of your own is a credential for a
vendor rather than for one id, so a `/model` switch to an id no key row was connected
with survives; Reynolds' metered model is the exception, since the service prices a
fixed pair. The endpoint is in the test because a provider name is not an endpoint: a
vendor's own key and a gateway or router in front of the same family answer to different
ids, so a pair restored across endpoints is accepted locally and refused by the vendor
mid-turn. An id does not name a provider on its own either (`claude-opus-5` is a model
on anthropic and on reynolds, and an OpenRouter id looks anthropic-ish). A study
recorded before the provider or the endpoint was written down is missing half the
record, and starts on the configured model as it always did, because the missing half is
never guessed at.

When the gate fails the configured model runs instead, with a line saying why in the
terminal and silently in the app, and the study keeps what it recorded: the run that
could not serve the pair is the last one that should erase it, so a later resume where
that key is set carries on there. Two limits: a study resumed on a machine that has
never held it starts on the configured model, because the record is that machine's own
`session.json` and nothing is fetched to stand in for it; and `OPENREYNOLDS_PROVIDER` is
not an explicit signal, so naming a provider alone does not hold a resume to it.