---
title: "The workspace: the instance, the jobs, and what survives"
url: "https://tryreynolds.com/docs/workspace"
description: "Every study gets an isolated Linux instance with OpenFOAM v2512 on it. What lives there, how jobs outlive the calls that start them, how files mirror home, where renders go, and what is kept when a session ends."
---

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

# The workspace

A study is a machine with a case on it, not a conversation with attachments. Knowing what lives where is most of knowing how to use it.

## The instance

Each study gets an isolated Linux instance: OpenFOAM ESI v2512, gmsh, pyvista, a headless VTK for rendering, and the study’s own directory under `/work`. It is a real machine, and the case on it is an ordinary OpenFOAM case.

Two tools beyond the standard distribution ship in the image. cfMesh is there for meshing: `cartesianMesh` and its boundary-layer tooling, which lay a layer over a patch and then improve it rather than eroding it away. HiSA is there for compressible work: an implicit density-based solver with AUSM+up flux, for the transonic and supersonic cases where a pressure-based solver smears the shock it is supposed to capture. Both are part of the image itself, so they are on every instance from the first minute.

The durable thing is the volume, not the container. An instance can be stopped and started again and the case is still there. Stopping keeps the data; only deleting destroys it.

## Jobs

A mesh or a solve is launched as a detached job rather than held open by the call that started it. That is what makes an hours-long run survivable: the state of a job is files on the volume, so its status is re-derived from disk rather than remembered in the process that launched it. Close the laptop and the solve carries on.

Every job ends with an honest reason: it completed, it matched a kill pattern, a client killed it, or the sandbox went away underneath it. That last one matters when you are reading a log and wondering whether to resume.

## Files, and what comes home

A background mirror copies the study’s directory down to your machine while the session runs, through turns and through hours of solving. It fires immediately whenever the agent looks at an image, so a render you are about to be shown is already local.

Deletions on the instance are not propagated home, which is deliberate: a local copy of something the agent cleaned up is a recovered file, not a bug.

```
openreynolds files                # what is in the workspace, and what has been copied down
openreynolds pull                 # bring this study's files down now
openreynolds push local.stl       # send a local file up to the instance
openreynolds renders              # every picture and assembled animation
```

![The files pane showing the case directory: 0 with U and p, constant with transportProperties and polyMesh, system with blockMeshDict and the schemes, a renders folder, and the solver logs, with the largest log marked as still being on the instance.](https://tryreynolds.com/assets/ui-app-files-DBktjbzQ.jpg)

The case as it stands on the instance, with what has already been copied down and what has not. A file too big to have travelled yet says so rather than looking missing.

## Renders

Pictures are made on the instance, next to the data, and only the pictures travel. They are collected into one flat directory per study rather than wherever in the case tree they were written, and a numbered sequence is assembled into an animation on your own machine, where a real encoder lives. The instance image has no encoder on purpose.

![The renders pane: a grid of four figures from the run, each captioned with its filename, including the mesh, the wake velocity field, the vorticity and a lift history plot.](https://tryreynolds.com/assets/ui-app-renders-D0zGS6Es.jpg)

Everything the run drew, collected into one place rather than left wherever in the case tree it was written.

## Ending a session

A clean exit stops the jobs, confirms they actually stopped, and stops the instance. The volume and the local mirror are kept. `--keep-alive` opts out and leaves the work running.

A hard kill, such as closing the window, skips that. An idle instance is reaped automatically, but a running job keeps it alive and billing until it finishes. `openreynolds stop` is the way to end it deliberately, and it verifies the work is dead rather than assuming.

## Resuming

A study is resumable by id. The transcript, the case and the mesh are all still there, and the session picks up with them.

```
openreynolds studies                       # what has run on this machine
openreynolds --study 20260829-054504-2920  # carry on with that one
```

## Two places, one record

A study run in the terminal captures its transcript, results and renders to the service as it goes, so it appears in the app with its record and its pictures even though its case files are on your laptop. A study run in the app has everything on the shared volume. The app says which of the two it is looking at rather than offering actions that cannot work.

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

### Getting your geometry onto it

Surfaces go to `constant/triSurface` in the case and the agent reads them with the
same toolchain it uses for everything else, so `.stl`, `.stlb`, `.obj`, `.ply`,
`.vtk`, `.vtp` and `.vtu` all work. Before anything is meshed the surface is drawn
from four fixed views and measured: bounding box and the unit decision that follows
from it, wetted and frontal area, triangle count and quality, open edges,
non-manifold edges, zero-area faces, and the named regions it contains. The cost of
meshing it is estimated in cells before the mesh is built rather than after, because
a snappyHexMesh build is twenty minutes to several hours and the wrong one is worth
finding out about early.

Everything under the case directory mirrors back to your machine, so the geometry
you uploaded, the mesh, the dictionaries and the results are all files you keep.