Can a large language model run a complete computational fluid dynamics study? This piece follows one that did. Given intent and access to a terminal, the LLM read a 3D model, built the mesh, set up and ran the solver, watched it converge, reshaped the geometry to cut drag and produced the visualisations. The engineer supplied the questions; the model wrote every line of code.
The test subject was a life-size seated bear, about 1.9 m tall, facing a 60 m/s wind in Anchorage, chosen because it carries no intellectual-property or export restrictions. OpenFOAM put its baseline drag coefficient at 0.653; a reshaped belly brought it down to 0.593, a 9.2% reduction. The real result, though, is not aerodynamic. It is that an LLM can bridge the gap between an engineering question and the open-source tools needed to answer it.
Disclaimer: This work is a technology demonstration. The results have not been independently validated against new experimental campaigns. This study should not be used for engineering design decisions without further testing and validation.
The LLM as CFD engineer
Computational fluid dynamics has always been one of engineering’s most expert-heavy crafts. Setting up an OpenFOAM simulation from scratch calls on knowledge of domains and meshes, turbulence models, boundary conditions, numerical schemes and convergence, and each step has its own ways of going wrong. It takes years to become fluent.
This study asked a simple question: can an LLM act as a force multiplier for a fluids engineer, taking on the whole implementation layer given only intent and a shell? The request was almost conversational: “simulate airflow over a bear at 60 m/s in Anchorage.” The model chose the solver, worked out the turbulence values from first principles, wrote every configuration file, debugged the mesh, monitored convergence, designed a shape optimiser, scripted ParaView and produced the animations.
“The user asked an engineering question in plain English. The LLM answered it with a working simulation, optimised geometry and finished visualisations. This is the new interface for computational engineering.”
Much of its judgement came unprompted. It recognised that at Mach 0.175 the air could be treated as incompressible, and chose a standard steady solver with the k–ω SST turbulence model. It sized the domain with several body lengths upstream and more than ten downstream, and derived the inlet turbulence from a 5% intensity. It refined the mesh in five levels down to about 30 mm around the bear, with thin layers along the surface. When a configuration file was missing, it found the system template; when the parallel run crashed, it switched to serial. It read the logs, recognised a gently oscillating sideways velocity as the expected behaviour of a bluff body rather than a fault, and stopped at a sensible point. Then it wrote the optimiser and generated 27 renders across three angles and three moments in the run.
Why a bear?
The bear is deliberate. To publish every file, result and script openly, the geometry has to be free of intellectual-property restrictions and export controls such as ITAR. Real aerospace and defence shapes cannot be shared, because their meshes, pressure maps and drag figures may count as controlled technical data, and industrial shapes come with confidentiality agreements. An AI-generated bear carries none of that baggage, and it is complex enough to produce rich turbulent flow, with an obvious target for improvement in its belly.
The geometry is a vessel, not the subject
Swap the bear for a vehicle underbody or a building façade and the workflow is identical. The bear is simply the most open shape available. The subject is the workflow, not the animal.
Aerodynamically, the bear is a classic bluff body, whose drag comes mostly from pressure rather than friction. Its rounded torso and protruding belly make the flow separate early and widely, leaving a low-pressure wake that stretches many body lengths downstream. The belly, close to the ground, forces the air beneath it to speed up and then break away abruptly. That is why the model chose it as the place to optimise.
The subject: a 1.9-metre seated bear
The bear was created by Meshy AI directly from the photograph below, producing a 3D model of nearly 1.3 million triangles, 1.13 m wide, 1.40 m deep and 1.90 m tall, that needed no manual editing beyond a change of units. That height matches a large adult brown bear sitting upright.
From photograph to finished study
The flowchart traces the whole journey as the model carried it out. Every configuration file, solver call, Python script and rendering instruction was written by the LLM in answer to plain-language requests.
The photograph became a 3D model in Meshy AI; a short Python script read it, scaled it to metres and tidied its surface normals. OpenFOAM’s meshing tools carved a block of air around the bear and refined it close to the surface. The solver ran for 350 iterations, logging the forces as it went. A Python optimiser then reshaped the belly, the modified bear was meshed and solved again under identical conditions, and automated ParaView scripts rendered the pressures, streamlines, wake slices and animations.
A sunny, very windy day in Anchorage
The conditions describe a mild 15 °C day with a ferocious 60 m/s wind, slow enough for the air to behave as incompressible but, at a Reynolds number of about 5.7 million, fully turbulent. The bear sat at the centre of a box of air 20 m long, 10 m wide and 8 m tall, with plenty of room upstream and more than ten body lengths downstream for the wake to develop. The final mesh held just under 457,000 cells, coarse far away and fine where it mattered.
Taming the tummy
The belly is the most troublesome part of the bear aerodynamically. It pushes a large rounded bulge into the flow beneath the body, forms a horseshoe vortex where it meets the ground, and encourages early separation around the rump. The optimiser reshaped only this region, using a smooth blending function so that no sharp ridge could artificially disturb the flow. Below the waist it gently narrowed the belly by up to 20% sideways and 15% front to back, and lifted it by a few centimetres near the ground, moving about 42% of the model’s vertices by up to 9 cm while leaving the upper body untouched.
Pressure, separation and the wake
The baseline flow is rich. On the windward chest and forelimbs the air slows almost to a halt, raising the pressure by about 860 Pa above ambient. Along the flanks and underbelly it accelerates and then breaks away, leaving broad zones of suction and a turbulent wake that trails many body lengths behind.
“The wake behind the bear at 60 m/s holds pressure deficits of more than 1,600 Pa, over 70% of the dynamic pressure. That is the aerodynamic hole the bear punches through the airstream.”
Set the two bears side by side and the difference is clear. The rounded belly forces the streamlines into a wide detour and a large suction zone; the slimmer belly lets the flow follow the body further before it separates, and the blue suction region visibly shrinks.
Quantifying the improvement
In force, the drag falls from 2,663 N to 2,419 N, a saving of 244 N. Multiplied by the wind speed, that is 14.6 kW less energy dissipated by drag, a way of putting the improvement in tangible terms rather than a claim that the bear is an engine. Lift tells an equally interesting story. The original belly, sitting in ground effect, generated a noticeable upward force; the reshaped belly removes it almost entirely, so the optimised bear would be less inclined to be lifted off its feet in extreme wind.
A new way of doing engineering
The headline is not the 9.2% drag reduction. It is that LLMs can be a powerful force multiplier for the fluids engineer. Directed in plain language by someone who understands the physics, the model produced a complete aerodynamics study, handling every configuration file, debugging decision, optimisation script and visualisation along the way.
That changes how computational engineering is practised. CFD has long been guarded by OpenFOAM’s steep learning curve, its thousands of options, its cryptic errors and the years of experience needed to master them. An LLM now sits between the engineer’s question and those specialised tools. The engineer keeps the physics and the judgement; the model handles the implementation.
The numbers themselves make physical sense. A drag coefficient of 0.653 places the seated bear between a rough sphere (about 0.47) and a blunt cylinder (about 1.2), just where a large, rounded bluff body should sit, and a drag force of 2,663 N, the weight of roughly 272 kg, illustrates the loads that extreme weather places on wildlife.
Three results
1. A force multiplier: the LLM carried the entire CFD pipeline, directed by plain language. 2. The aerodynamics: drag fell by 9.2% and the belly’s lift disappeared. 3. Open by design: every file can be shared freely, because the geometry is an AI-generated bear.
The limits
The bear is a static AI approximation, not a laser-scanned animal, and fur, limb position and ear shape could all change the result. A steady simulation cannot capture the shedding of vortices in gusty wind, which time-accurate methods such as LES would resolve. And a single reshaping step is only a beginning; a proper optimisation with more variables would probably find bigger gains.
Above all, no simulation replaces experimental validation. The drag, the wake and the pressures are predictions that depend on the turbulence model, the wall treatment, the mesh and the size of the domain, and the turbulence model used here is known to over-predict separation around some bluff bodies. Until they are checked against wind-tunnel forces, surface pressures and flow measurements, they are best read as plausible estimates for comparing designs, not as absolute truth. (The follow-up piece, on validating this study in a smoke tunnel, explores exactly that.)
What comes next
The most exciting direction is taking the same partnership into more demanding territory: pairing the LLM with formal optimisation methods, with the model interpreting progress and proposing next steps; moving to time-accurate simulations of the wake; and applying the same workflow to structures, heat transfer and acoustics. In each case the model’s role is the same: turn intent into working simulations, interpret the results and iterate. For the bear itself, there are standing, running and swimming poses still to explore.
Reproduce it
The study ran on a four-core computer with 7.5 GB of memory, using OpenFOAM 13, Python with NumPy and Matplotlib, and ParaView 5.11 for headless rendering. The whole pipeline reduces to a handful of commands:
# ── Baseline ──────────────────────────────────────────────
cd bear_baseline
blockMesh && snappyHexMesh -overwrite
renumberMesh -overwrite && potentialFoam
foamRun > log.foamRun
# ── Optimized ─────────────────────────────────────────────
python3 tummy_optimize.py # modifies STL, writes bear_optimized/
cd bear_optimized
blockMesh && snappyHexMesh -overwrite
renumberMesh -overwrite && potentialFoam
foamRun > log.foamRun
# ── Visualize ─────────────────────────────────────────────
DISPLAY=:0 pvbatch render_one_case.py baseline
DISPLAY=:0 pvbatch render_one_case.py optimized
python3 analyze_drag.py