---
title: "Reynolds documentation: the agent, the workspace, and how to run one"
url: "https://tryreynolds.com/docs"
description: "How Reynolds works and how to run it: install and first study, the tool-use loop and its tools, the three modes, choosing and changing a model, what lives on the workspace instance, the commands, and what to do when a run goes wrong."
---

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

# Documentation

Reynolds is an open-source agent with a hosted Linux workspace and OpenFOAM on it. These pages cover how that works, how to run one yourself, and what to do when a solve does not go the way it should.

Two ways in, the same agent behind both. [The app](https://app.tryreynolds.com) runs a study in your browser with the conversation, the jobs, the files and the mesh in one window. The command line runs the same session in a terminal on your own machine. Start with the quickstart; everything else is reference.

Sign up with your company email address and your account starts with $10 of credit, once.

## What you need to know first

**Not OpenFOAM.** Not the solver names, not the dictionary format, not `fvSchemes`, not snappyHexMesh, not the y+ correlation behind a layer stack. Choosing and writing all of that is the agent’s job. What you bring is the engineering question: the geometry, the fluid, the speed or flow rate, what happens physically at each surface, and what you want measured.

These pages describe what the agent does so that you can check it, not so that you have to do it. An engineer who has never opened a `controlDict` gets the same answer as one who has, and can then read the case the agent wrote. The reverse holds too: nothing here is hidden from you. What comes back is an ordinary OpenFOAM case directory, and the agent that produced it is [MIT-licensed and readable in full](https://github.com/InviscidAI/OpenReynolds), so taking the case to your own cluster is a path that stays open.

## How much it asks you, and you choose

Left to itself the agent decides its own route. There is no script and no fixed order, the order changes with the problem, and nothing waits for you. That is **full auto**, the default in both the app and the terminal, and it is the right mode for a question nobody has asked in quite this shape before.

Two other modes exist for when you want a say before money is spent. **Ask before compute** puts every background job, such as a long solve, and every mesh-desk build to you before it runs; a short command the agent runs directly in the shell, capped at five minutes, is not held. A reason you give for declining goes back to the agent in your words. **Structured** runs the study in stages you approve, named after the guided sequence: geometry, preview, mesh, `checkMesh`, probe, solve, reconstruct, render, animate, report. You agree a plan at a checkpoint before any solve or mesh build starts, and the agent knows you want a checkpoint after each stage. That suits a study you intend to repeat, or hand to a colleague, or defend a year from now. What the agent decides *within* a step is its own judgement in every mode, and you can switch modes at any point in a session. [Modes](https://tryreynolds.com/docs/modes.md) has the detail.

![The Reynolds study page: a header carrying the study id, instance, model and token count; a progress bar reading 41 per cent with solver time, residuals and Courant number; the conversation on the left with the agent's reasoning and its tool calls; and the mesh it built on the right.](https://tryreynolds.com/assets/ui-app-study-VSIJnvBr.jpg)

A study in progress. What the agent says is on the left, what it did to the workspace is in the rows underneath, and what it built is on the right. The bar across the top is the solver's own numbers, read out of the log while the job runs.

### Quickstart

From nothing to a finished case: make an account, connect a model, and ask for a simulation. Both the browser and the terminal.

[Quickstart](https://tryreynolds.com/docs/quickstart.md)

### How it works

The tool-use loop, the tools it has, and the one rule the harness keeps: it may report facts to the model, and it may not tell the model how to work.

[How it works](https://tryreynolds.com/docs/how-it-works.md)

### Modes

Full auto, ask before compute, or structured: how much the agent does before it asks you, what each one holds, and how to switch mid-session.

[Modes](https://tryreynolds.com/docs/modes.md)

### Models and cost

Reynolds’ own metered model, or a key from any vendor. Reasoning effort, what drives the bill, and how to spend less without changing what the agent may do.

[Models and cost](https://tryreynolds.com/docs/models.md)

### Changing the model mid-study

Switch model, provider or reasoning effort without leaving the session: what is checked first, when it takes effect, and what it costs.

[Changing the model mid-study](https://tryreynolds.com/docs/switching-models.md)

### The workspace

The instance, the jobs, the files that mirror home, the renders, and what survives when a session ends.

[The workspace](https://tryreynolds.com/docs/workspace.md)

### Moving mesh

Sliding interfaces, prescribed motion and a body the flow moves: the graded benchmarks behind those claims, and where the record is thinner.

[Moving mesh](https://tryreynolds.com/docs/moving-mesh.md)

### The mesh editor

Your hands on the agent’s mesh in the browser: pick faces and name them, draw a domain, move and scale, and hand it back with what you meant by it.

[The mesh editor](https://tryreynolds.com/docs/mesh-editor.md)

### More than one at once

How many studies one account may run at the same time, how many workspaces it may hold, and what two studies share.

[More than one at once](https://tryreynolds.com/docs/running-several-studies.md)

### Command reference

Every subcommand and flag, what each one reads and writes, and where the config file lives.

[Command reference](https://tryreynolds.com/docs/cli.md)

### Driving it from a program

One prompt and an exit code, the whole session as newline-delimited JSON, and answers written back on stdin.

[Driving it from a program](https://tryreynolds.com/docs/from-a-program.md)

### Commands in a session

What you can type while a study runs, `/help` and its topics, and how completion works in the terminal and in the app.

[Commands in a session](https://tryreynolds.com/docs/session-commands.md)

### When something goes wrong

Solves that will not converge, a mesh that fails, a job killed under you, and the errors that are worth reading closely.

[When something goes wrong](https://tryreynolds.com/docs/troubleshooting.md)

## What Reynolds is not

It is not a wrapper that fills in a case template. There is no fixed pipeline, no list of supported geometries, and no menu of problems it knows. It is a model with a shell on a machine that has OpenFOAM installed, and the working method is its own. That is the reason it can do a case nobody anticipated, and also the reason a result needs reading rather than trusting.

It is also not a solver. OpenFOAM does the physics, and every number Reynolds reports comes out of a real run whose case files, logs and mesh are handed back to you. If a figure is wrong, the case that made it is right there to check.

## 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 you need to bring

You need to be able to state the engineering problem. Geometry, fluid, speed or flow
rate, boundary conditions in the sense of what physically happens at each surface,
and what you want measured. That is the whole list.

You do not need OpenFOAM. The solver choice, the discretisation schemes, the
`system` and `constant` dictionaries, the mesh strategy, the layer stack, the
convergence criteria and the post-processing are all the agent's job. These
documentation pages describe what it does so that you can check it, not so that you
have to do it. An engineer who has never opened a `controlDict` gets the same answer
as one who has, and can then read the case the agent wrote if they want to.

The reverse is also true and worth saying: everything here is open to you. The
output is an ordinary OpenFOAM case directory. Take it, change one dictionary, run it
on your own cluster: that path is open, and the licence on the agent is MIT, so you
are free to do whatever you want with it next.