---
title: "Moving mesh: sliding interfaces, prescribed motion, and bodies the flow moves"
url: "https://tryreynolds.com/docs/moving-mesh"
description: "What Reynolds does with a mesh that moves: a cyclicAMI sliding interface, solid-body prescribed motion, and a rigid body moved by the forces on it. The two repeatable benchmarks, what the grader reads, the measured numbers, and where the record is thinner."
---

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

# Moving mesh

A mesh that moves is where a CFD tool is easiest to trust and hardest to check, because its failures are quiet ones. Two benchmarks in the agent's repository were run end to end through the product and are graded from nothing but the solver's own output.

## What the agent does

None of this is a special mode. The agent writes the same ordinary OpenFOAM case with whichever dynamic mesh dictionary fits the problem, and the distribution’s own machinery does the moving. Three shapes of problem sit behind the graded record:

| What moves | How |
|---|---|
| **A sliding interface** | A `cyclicAMI` pair between a turning zone and a static one, so a rotor can spin inside a stationary domain without the two meshes matching across the seam. |
| **Prescribed motion** | A solid-body motion function on a `dynamicMotionSolverFvMesh`: the zone turns or translates the way you said it would, whatever the flow does. |
| **A body the flow moves** | `sixDoFRigidBodyMotion`, with the degrees of freedom you do not want constrained away, on a mesh that deforms around the body as it goes. The forces the solver computes are what move it. |

## The benchmarks

Two prompts and a grader live at `benchmarks/moving_mesh/` in the agent’s repository, and they are the cases every moving-mesh claim here rests on. Both were driven end to end through the product as a customer would, and both are kept as cases anyone can rerun and grade the same way.

- **A sliding interface** (`couette_ami.txt`): a 2D circular Couette annulus cut through by a `cyclicAMI` interface, inner wall turning. The velocity profile and the torque on the inner cylinder are closed form, so the reference is exact and there is no tolerance band to hide in.
- **A body on a spring** (`viv.txt`): a cylinder free to move across the stream on a morphing mesh at Re = 100, mass ratio 10, zero structural damping, reduced velocity 5. Williamson (1996) gives St = 0.164 for the fixed cylinder; no amplitude is supplied, on purpose.

```
openreynolds -p "$(cat benchmarks/moving_mesh/couette_ami.txt)"
openreynolds pull --study <study-id>          # the case files, home
python benchmarks/moving_mesh/grade.py couette <case> --control <case without the interface>
python benchmarks/moving_mesh/grade.py viv <fixed case> <released case> [<continuation>]
```

`--json` gives a machine-readable verdict. The grader exits 0 when every graded check passes, 1 when one fails, and 2 when the case could not be read.

## What the grader reads

Only what the solver wrote: `postProcessing`, the logs, and the case’s own `constant/` and `system/`. Never a run’s own analysis. The first time these two cases were graded by hand, four of the runs’ own summary numbers disagreed with their raw files, and one analysis script had read a torque sample from one time and labelled it another, because the solver had restarted and the script never opened the restart’s directory.

So the grader stitches every restart directory and cuts each one at the start time of the next, finds columns by the names in the header rather than by position, and takes every physical constant out of a case file: viscosity from `transportProperties`, density from the function object, the rotation rate and the spring from `dynamicMeshDict`, the radii off the mesh points. A constant it cannot find stops the grader, which names the flag that supplies it rather than assuming a value.

Two of the checks are worth understanding before reading a verdict. In steady circular Couette flow the torques on the two walls are equal and opposite exactly, because angular momentum is conserved, so their imbalance tests the interface against no reference at all. And with zero structural damping nothing can dissipate energy, so integrating lift times velocity over each whole cycle catches an amplitude that is held where it is by the coupling scheme rather than by the physics: a false one can be stationary, sinusoidal and spectrally clean, and pass every conventional test.

## The measured results

Re-derived by the grader from the raw output of the runs behind the two write-ups.

| Measurement | Result |
|---|---|
| Inner-wall torque, across the interface | 1.21154 mN·m/m against an exact 1.20637, 0.43% high (pass) |
| Torque imbalance, the two walls | 0.911% of the inner torque where the exact answer is zero, against 0.011% on the same annulus meshed without an interface (fail, threshold 0.1%) |
| Interface area held | AMI weight sums between 1.0 and 1.0000428, i.e. 43 parts per million (pass) |
| Grid convergence | the conformal control at observed order 1.93, extrapolating to within 0.0004% of the exact torque; the sliding interface at 0.79 |
| Strouhal, cylinder bolted still | 0.166141 against Williamson’s 0.164, 1.31% high (pass); mean drag 1.3555 |
| Amplitude released, loosely coupled | A/D 0.640, locked in, with the fluid doing between 10.1% and 10.4% of negative work per cycle on a structure that cannot dissipate any (fail) |
| Amplitude with the body inside the PIMPLE loop | A/D 0.567, f/fₙ 0.970, locked in, net work between +0.04% and +0.18% per cycle (pass) |

The imbalance is a fail, and the failure is the finding: the interface keeps its area to 43 parts per million while losing nearly a percent of the torque, so the check practitioners usually run returns a clean bill on a case whose single-wall torque is wrong. The grid ladder says why more cells barely help. Holding the timestep and multiplying the cells by four moved the interface’s torque error from 0.2174% to 0.2205%, so what it is first order in is the angular slide per step, not the cell size. Grade a rerun of that case at a stated slide per step.

On the vibration case the energy audit is what took 13% off the answer: the 0.640 had passed every conventional convergence test and was rejected by physics rather than by a literature comparison. The amplitude itself is reported without a verdict, because no published amplitude for exactly this case has been found; the two nearest are cited in the benchmark’s own notes, both at a different mass ratio and twice the blockage.

Each case has a write-up here: [the mesh that slides](https://tryreynolds.com/studies/couette-sliding-interface.md) and [the cylinder let go in its own wake](https://tryreynolds.com/studies/vortex-induced-vibration.md).

## Where the record is thinner

A graded record is worth having because it says where it stops, so here is where this one stops.

- **Overset meshes are outside it.** The overset family is on the image and the agent knows what it is for, but the benchmarks cover the sliding interface and the deforming mesh, and a graded overset case is not among them.
- **The vibration case stands on one mesh.** The sliding interface has a three-mesh ladder behind it; the vibration case has one mesh and no grid study, so its amplitude is a measurement on that mesh and is published as one.
- **The tight result is a continuation.** The A/D of 0.567 carried on from the loosely coupled run rather than starting again from rest.

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