---
title: "Modes: full auto, ask before compute, structured"
url: "https://tryreynolds.com/docs/modes"
description: "A Reynolds session runs in one of three modes. Full auto holds nothing, ask before compute puts every background job and mesh-desk build to you first, and structured has you approve a plan and each stage. What each one holds, how to answer, and how to switch."
---

**[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/modes. It lives at https://tryreynolds.com/docs/modes.md, and
[tryreynolds.com/llms.txt](https://tryreynolds.com/llms.txt) indexes every one of them.

# Modes

The mode decides one thing: how much the agent does before it asks you. It never changes what the agent knows about CFD, and you can switch at any point in a session.

## The three modes

| Mode | What it holds |
|---|---|
| **Full auto** (`auto`) | Nothing. The agent decides everything and nothing waits for you. This is the default. |
| **Ask before compute** (`partial`) | Every solve or other background job, and every mesh build, is put to you before it runs. |
| **Structured** (`structured`) | The study goes in stages. You approve a plan at a checkpoint, and no background job or mesh build starts until you have. The agent is told you want a checkpoint after each stage too. |

In every mode the agent runs shell commands, reads and writes files, checks and stops jobs, and copies files home without asking. A shell command runs for up to five minutes, long enough for a small solve, and no mode holds it. A mode decides when background jobs and mesh-desk builds start. It is not a sandbox.

## Why there are modes at all

The harness around the model is not allowed to require approvals or to impose an order of work, because a harness that tells the model how to do CFD caps the work at whatever its author knew. That rule is unchanged in full auto.

What it never meant was that you cannot ask to be consulted. A solve on many cores is your money, and a study you intend to defend is your plan. So the other two modes exist for when you want them, and the harness holds exactly what you chose to have held and nothing else. What the agent decides inside a step is still its own judgement.

## Full auto

The agent works the way Reynolds always has: no question is put to you and no tool call is ever held. It is the right mode for a question nobody has asked in quite this shape before, and for a run you intend to leave alone. You can still steer at any time by typing, because anything you say reaches the agent at its next step.

## Ask before compute

Two things spend compute: starting a background job, such as a mesh or a solve, and handing a shape to the mesh desk, the second agent that builds meshes. In this mode each of those is put to you before it runs, with what would run: a job shows its name, its command and the directory it runs in, and a mesh build shows the shape as the agent described it. Everything else carries on without waiting.

The agent is told, in one sentence, that you chose this, so a declined call is not a surprise to it.

### Answering a question

| You send | What happens |
|---|---|
| `/yes`, or `y`, `yes`, `ok` on its own | It runs. |
| `/no` and a reason, or any other words | It does not run. The agent is told you declined, with your words exactly as you wrote them. |
| `/all` | It runs, and the session switches to full auto for the rest of the session. The agent is told. |

Anything you type that is not a yes, a no or an “all” counts as steering: the call does not run and your words go back as the reason. That makes “use the coarse mesh first” a perfectly good answer. `/status`, `/files`, `/help` and the other local commands are answered while the question stays open. In the app the question arrives as a card with **Approve**, **Decline** and **Approve all**, and each button sends the same line you could have typed.

## Structured

The agent gets one more tool, a checkpoint. At a checkpoint it puts a summary of where the study stands, and what it proposes to do next, in front of you and waits. Approve and it carries on with what it said comes next. Write anything else and your words go back to it as the changes you want, and nothing is approved.

Background jobs and mesh-desk builds are held until you have approved a checkpoint, the plan. A held call does not run, and the agent is told plainly that it was held and why. Once a plan is approved they run without further questions. The agent is told you want a checkpoint after each stage as well; when to call one is its judgement, not a rule the harness enforces.

The stages are named after the guided sequence: geometry, preview, mesh, `checkMesh`, probe, solve, reconstruct, render, animate, report. Whether a study needs every one of them, and what each involves, is the agent’s call. This suits a study you intend to repeat, hand to a colleague, or defend a year from now.

## Choosing a mode

In the app, **New study** asks how much the agent should ask you, and remembers your choice for next time. In the terminal:

```
openreynolds --mode partial                 # ask before each background job and mesh build
openreynolds --mode structured              # approve a plan, then each stage
OPENREYNOLDS_MODE=partial openreynolds      # the same, from the environment
```

A resumed study keeps the mode it had unless you name one. A value that is not a mode names none: it is ignored, and a new study runs in full auto. Ask before compute and structured need someone to answer, so a non-interactive run with `-p` refuses them before anything starts, rather than waiting for an answer nobody can give.

## Switching mid-session

`/mode` on its own says which mode the session is in. `/mode auto`, `/mode partial` or `/mode structured` switches from the next tool call, and the agent is told. In the app, the mode chooser under the composer sends the same line. Switching into structured starts it afresh, so a plan has to be approved in it before compute is spent again.

Switching into or out of structured adds or removes the checkpoint tool, which means the model’s prompt cache is written once more. It is a small, one-off cost, paid only when you switch.

## 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.

### What a mode is, and what it is not

A mode decides one thing: whether compute waits for the person. It changes nothing the
agent is told about CFD. `auto` (Full auto) is the default and holds nothing: the
briefing is the same text it was before modes existed and no tool call is ever held.
`partial` (Ask before compute) puts every `job_start` and `mesh` call to the person
before it runs. `structured` offers a `checkpoint` tool and holds `job_start` and `mesh`
until a checkpoint has been approved since the mode began. In every mode `bash`,
`write_file`, `read_file`, `fetch`, `job_check` and `job_kill` run without asking, so a
mode is not a sandbox.

The source is `openreynolds/modes.py` in the OpenReynolds repository. Aliases accepted
wherever a mode is named: full, full-auto, fullauto, free (auto); ask, approve,
approvals, partial-auto (partial); plan, staged, stages, guided (structured).

For a program driving `openreynolds --output-format stream-json`: a question is an
`approval` event with `id`, `kind` (job, mesh or checkpoint), `title`, `detail` and
`choices`; the answer is an `approval_done` event with `outcome` (approved, declined or
approved_all) and `note`. Answer by writing `{"type": "user", "text": "/yes"}` to stdin,
or `/no <reason>`, or `/all`. `-p` with a non-auto mode exits 2 before anything starts.