acceptodds
Under review as a conference paper at ICLR 2027

KaleidoFlow: an autonomous data engine for learning flows on diverse geometries

Abstract

Neural operators are emerging as surrogates that predict a flow much faster than a numerical solver. However, a neural operator generalizes only within the geometry families it was trained on. This limitation comes from the data. Every existing flow dataset depends heavily on human experts to design every geometry and to verify its mesh, so it is expensive to scale. Thus, each dataset can cover only a single geometry or similar geometries from the same family. We present KaleidoFlow, an autonomous data engine that scales a flow dataset to diverse geometries in three stages, all without human intervention. First, a language model agent continuously proposes new geometry families, together with the geometric parameters and the Reynolds numbers that vary them. Second, the agent designs the mesh of every family and repairs it iteratively until a convergence test verifies its discretization error. Third, OpenFOAM solves every combination of the geometric parameters and the Reynolds number, and each solution is one trajectory. The engine has produced 3,948 distinct geometries from 459 families, with 16,512 trajectories. Our results show that (1) the engine proposes diverse geometries automatically, covering 10 application categories from cyclones to biomedical vessels, and (2) it successfully repairs the mesh strategies that fail, which most of the families require. With this dataset, we build the first benchmark that measures how far a neural operator generalizes across geometry families. On the benchmark, we find that (1) current neural operators generalize poorly to a new geometry family, where the error of all nine architectures we evaluate increases by 3× to 6× from G2 to G3, and (2) the error on new families decreases with the number of training families approximately as a power law, for a convolutional, a transformer, and a spectral architecture. We will release the engine and the benchmark for future development of foundation neural operators that generalize across diverse geometries.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Operator Learning, PDE, Large Language Model, Data Generation

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_rkVhOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The authors introduce KaleidoFlow that utilises LLM to generate 2D incompressible laminar flow datasets with no human in the loop. The process can be divided into 3 general steps: (i) using LLM to propose geometries, which is one set of shape parameters, (ii) designing the mesh and verifying it via a standard grid-independence test, and (iii) simulating via opensource solver (OpenFOAM) under larminar and transient settings. Finally, the datasets contain a total of 3948 simulation cases. With that, the authors carried out 4 test splits for benchmarking under 9 architectures.

Critical strengths
  1. I like the illustrations presented in this paper. They are consistent and informative, though they are clearly LLM-assisted. Overall,this paper is quite comprehensive and well written.
Critical weaknesses
  1. In the context of this paper, the main contribution is to use an LLM to generate a large dataset. It is essentially a dataset generation method, nothing more than that. Current commercial LLMs can easily do this work for non-experts, but for experts, it is useless. Hence, the novelty and contribution are minimal. The authors should consider whether "datasets and benchmarks" is the better primary area to submit.
  2. As per the title "flows on diverse geometries", I suppose the dataset contains different flow conditions other than just varying the Reynolds number. This dataset currently contains only 2D, laminar, and internal flows. Also, the Reynolds number is up to 40000, yet there is no turbulence model, and for any internal flow with Re> 2100, it is no longer considered to be laminar. Thus, the claim in App. A.3 that "every released trajectory is a physically consistent solution" is too strong for the high-Re part of the dataset.
  3. Regarding the power law claim, the testing K=32, 64, 128 is only two folds between each, not an order of magnitude difference as many smooth decaying curves look linear in log-log over that range.
Questions for authors
  1. What fraction of trajectories has Re > 2300? Do the diversity and G3 results hold if the high-Re cases are removed? Is a 2D laminar solution at Re up to 40,000 considered physical, and how should users interpret these trajectories?
  2. Why doesn't the divergence excess improve with K? Does this suggest purely data-driven scaling cannot fix physical consistency?
  3. Why did the authors choose to map the simulated fields onto the uniform grids? Isn't that going to corrupt the continuity of the flow, reducing the fidelity? Why no preverse the grids and retain the physical information in them?
4 comments

Thanks for your thoughtful reviews and insightful questions. They have significantly improved this work. We respond point-by-point below.

[W1] "It is essentially a dataset generation method."

We respectfully clarify that this work is not only a dataset generation method. Our main contribution is the first systematic study of how neural operators generalize across diverse geometry families, an important open problem in operator learning [1, 2]. It shows quantitatively that current architectures generalize poorly to new families (Sec. 4.3) and identifies an approximate power law between their error and the number of training families (Sec. 4.4). These findings require verified flow data on hundreds of geometry families, which existing tools and agents [3] cannot readily produce, so we built an autonomous data engine (Appendix A).

State-of-the-art LLMs are powerful, but they cannot readily generate diverse and verified flow data at very large scale. (i) An LLM asked for many geometries tends to repeat familiar shapes, so the engine requires each proposal to target sparsely covered flow mechanisms and to differ from its closest existing families (Appendix A.1). (ii) A simulation can run normally and still have a large discretization error, which the solver output does not reveal, so the engine judges every mesh strategy by a grid convergence test and repairs failed strategies (Appendices A.2 and B.1). The engine is thus a harness that lets an LLM agent produce a large, diverse, and verified dataset, and a stronger LLM yields a better dataset. It is therefore useful to both experts and non-experts.

Therefore, we believe that this work makes significant contributions in neural operator studies and fits the current primary area. We have revised the abstract and Sec. 1 accordingly.

[W2] "Only 2D, laminar, and internal flows; no turbulence model."

Regarding "only 2D, laminar, and internal flows": We acknowledge that the current dataset is 2D and consists mainly of laminar flows in bounded domains, as now stated in Sec. 6. However, the dataset is highly diverse within this scope (Sec. 3.1). (1) It has 459 geometry families from 10 application categories, 40 times more families than any existing flow dataset. (2) In 54.0% of the families the flow passes obstacles and forms wakes, and in 28.1% it has several inlets or outlets. (3) The boundary conditions include moving or rotating walls, symmetry planes, periodic pairs, and time-varying inlets. The Reynolds number ranges from 1 to 40,000, and the three highest-Re families use the k-omega SST turbulence model. This scope is sufficient for our findings, whose question does not depend on the dimension. Even on 2D, mostly laminar flows, all nine architectures generalize poorly to new families (Sec. 4.3), so this gap is not an artifact of a simple setting, and we expect that 3D or turbulent flows would make it even more challenging rather than close it. The engine has not yet been tested in 3D.

Regarding "there is no turbulence model" and the claim in Sec. A.3 being "too strong for the high-Re part": We agree that the original version did not state the flow model and that this claim was too strong. (1) We clarify that the dataset does use a turbulence model. The three families with the highest Reynolds numbers, 152 trajectories including all 39 above Re 5,000, use the k-omega SST model. (2) We have revised the claim to the form that we can verify: every released trajectory is a verified solution of the equations of its flow model. Each mesh strategy passes the grid convergence test [5] on its hardest trajectory with an index below 5% for the time-averaged fields (Appendix B.1), and every trajectory is checked for mass conservation, the Courant number, and time-step collapse (Appendix B.2). In CFD terminology, this is solution verification. Validating a flow model for a specific physical flow is beyond the scope of this work.

[W3] "K=32, 64, 128 is only two folds between each."

Following your suggestion, we extended KK to 24–271, with six architectures and three seeds. The table gives the G3 error (10−210^{-2}, mean ± std over three seeds), α\alpha, and R2R^2 (Table 16). Over this wider range, the error of every architecture follows an approximate power law, error∝K−α\text{error} \propto K^{-\alpha}, with R2R^2 from 0.95 to 0.98. It also extrapolates: fitted on K≤128K \le 128 only, it predicts the error at K=192K = 192 and 271271 within 6% for five architectures. In contrast, an exponential decay, which would mean early saturation, underestimates these errors by 9 to 41% (Appendix E.4).

ArchitectureK=24K=24K=271K=271α\alphaR2R^2
UNet-c4.54±0.142.17±0.010.33±0.010.98
HNO4.30±0.202.31±0.010.30±0.020.95
CNO5.20±0.182.87±0.050.24±0.000.98
F-FNO5.05±0.122.96±0.030.23±0.000.95
DilRes4.30±0.212.62±0.110.20±0.050.96
FNO5.79±0.114.36±0.030.13±0.010.95

[Q1]

(1) "What fraction of trajectories has Re > 2300?" Only 1.35% of the trajectories have a Reynolds number above 2,300. This work focuses on geometry, so the dataset varies the geometry most widely. Many applications, such as biomedical devices and fuel cells, operate at low or moderate Reynolds numbers.

(2) "Do the results hold without the high-Re cases?" Without the high-Re trajectories, the diversity statistics remain essentially unchanged, and the G3/G2 error ratio of a retrained UNet-c remains similar. Every family has trajectories at or below Re 2,300, so removing the trajectories above Re 2,300 keeps all 459 families and 3,924 of the 3,948 geometries. The between-family share of the shape variance stays at 92%, and the nearest-family distance relative to the within-family spread stays at 3.8 (Table 1). We retrained UNet-c once without the SST families and the trajectories above Re 2,300 (2.9% of the training data), and the G3/G2 ratio changes less than between two training seeds (Table 2).

Training setG2G3G3/G2
Without high-Re0.09120.38744.25
All trajectories0.08790.39044.44

(3) "How should users interpret these trajectories?" The high-Re trajectories are verified solutions of the 2D equations of their flow model, and learning such solutions is an accepted practice in operator learning. We understand your concern that turbulence in the standard sense is three-dimensional. However, our understanding is that these trajectories are still meaningful in three respects. First, 2D turbulence is an established subject of fluid dynamics, which describes thin-layer flows in the atmosphere and the ocean [6]. Second, the trajectories above Re 5,000 use the k-omega SST model, which is also used in 2D by AirfRANS [4]. Third, operator learning targets the verified solution of given equations, and many works learn 2D turbulent or chaotic flows, such as FNO [7]. Therefore, these trajectories are suitable for operator learning, and in the revised Appendix A.3, every trajectory is labelled with its Reynolds number and flow model.

[Q2] "Why doesn't the divergence excess improve with K?"

We would like to clarify that the divergence excess does improve with KK. It decreases from K=24K = 24 to 271271, although it does not follow the power law as strictly as the relative error. The table reports the excess (10−310^{-3}, mean ± std over three seeds) and the R2R^2 of each power law (Table 20).

ArchitectureK=24K=24K=128K=128K=271K=271Divergence R2R^2Relative error R2R^2
UNet-c4.0±1.63.0±0.51.1±0.10.780.98
HNO8.8±2.13.0±0.42.6±0.20.850.95
F-FNO9.2±0.15.4±0.14.0±0.30.890.95

This deviation from the power law is expected, because our training objective is the relative error of the velocity, while the divergence depends on its spatial derivatives, which this loss does not constrain (Appendix D.2). Language models show the same pattern: the training loss follows a power law [8], while metrics that are not optimized directly can deviate from it [9]. Therefore, data-driven scaling does improve physical consistency, but it does not enforce it. A constraint in the architecture or the loss can enforce it, which we leave to future work.

[Q3]

(1) "Why map the fields onto uniform grids?" The uniform grid enables a systematic and fair comparison of all major classes of neural operator architectures, because convolutional, spectral, and transformer architectures all operate on it (Appendix D).

(2) "Isn't that going to corrupt the continuity?" The mapping is designed to keep both the continuity and the fidelity of the verified solution at the resolution of the uniform grid. The verified solution satisfies mass conservation, checked for every trajectory by the cumulative continuity error of the solver (Appendix B.2). The mapping does not interpolate point values, which would break this conservation. Each uniform-grid value is the exact area-weighted average of the finite-volume solution over the fluid part of its grid cell, so the fluid-area integral of every field is preserved and every value remains within the range of the mesh solution (Appendix A.4).

(3) "Why not preserve the grids?" We retain the solutions on the original meshes and will release them to support future research.

References

[1] Poseidon: Efficient Foundation Models for PDEs

[2] Multiple Physics Pretraining for Spatiotemporal Surrogate Models

[3] Foam-Agent: Towards Automated Intelligent CFD Workflows

[4] AirfRANS: High Fidelity Computational Fluid Dynamics Dataset for Approximating Reynolds-Averaged Navier-Stokes Solutions

[5] Perspective: A Method for Uniform Reporting of Grid Refinement Studies

[6] Two-Dimensional Turbulence

[7] Fourier Neural Operator for Parametric Partial Differential Equations

[8] Scaling Laws for Neural Language Models

[9] Are Emergent Abilities of Large Language Models a Mirage?

Thanks for the answer. I will maintain my score for the following reasons:

  1. "current architectures generalize poorly" is a common issue, most researchers accept that, so it adds no value to quantify it. What is really added value is being able to solve it while identifying the mechanism behind.
  2. "cannot readily generate diverse and verified flow data at very large scale", in what application or situation does a user need to generate vast and diverse geometries? Like design optimisation, which usually requires a user to refine and optimise a geometry within a similar family.
  3. "engine judges every mesh strategy by a grid convergence test", this criterion is a very common practice in CFD, letting an LLM agent obey this convergence test would not add any value because it is a must-do for a valid solution.

Thus, I agree with the reviewer DucG that the novelty of this work is limited and should be more suitable for a dataset and benchmark track, for which I maintain my score for this paper.

Thank you for your reply. We respond to your points below and then discuss the choice of track.

(1) Regarding your first and second points, we wish to explain the broader context. In classical numerical simulation, we usually solve each problem with expert-designed ad hoc methods. Recently, a line of work [1, 2, 3, 4] pursues general PDE solvers that handle diverse problems with a single model. Such general solvers require diverse and scalable data on many different geometries and boundary conditions, but data with sufficiently diverse geometries are still lacking. As a result, existing work cannot evaluate or pretrain such solvers across a rich set of geometry families.

In this paradigm of general solvers, quantifying how neural operators generalize across such diverse geometries clearly adds value, rather than "it adds no value to quantify it" (Q1). Most current PDE benchmarks, such as PDEBench [5], PDEArena [6], and CFDBench [7], measure how well a model fits a single geometry family. In contrast, we quantify how current architectures generalize as the geometries become significantly more diverse. In addition, this work provides the first scaling law for neural operators across geometries: the error on new geometry families decreases as a power law in the number of training families. This law also clearly adds value, because it provides a scalable path towards such general solvers that generalize across geometries, as scaling laws have done in other domains [8, 9].

For the same reason, datasets of vast and diverse geometries are needed, which directly answers "in what application or situation does a user need to generate vast and diverse geometries" (Q2). A general solver must handle unseen geometries, which our results show requires many geometry families in training, and our engine provides such data systematically.

(2) "This criterion is a very common practice in CFD." (Q3) The grid convergence test is indeed a standard practice, but organizing it into an automated workflow that produces large-scale and diverse datasets in a standardized format has not been done before. In common practice, whether or not LLMs are used, an expert designs the mesh for each geometry and verifies it with this test. In contrast, this work designs and verifies meshes fully automatically across hundreds of diverse geometry families. In the engine, the agent iteratively refines the mesh strategy from structured diagnostics that identify the failed quantity and summarize all earlier attempts (Sec. 3.2 and Appendix A.2). At the same solver budget, this repair passes 70% of sampled families, versus 20% for a conventional mesh-size search (Appendix C.5). This workflow enables the scaling study above, and it allows future work to expand verified data to the same standard.

On the choice of track, we clarify why we believe this work fits its current track, applications to physical sciences, rather than a dataset and benchmark track. This work is not merely a fixed collection of data with an evaluation protocol, but also contributes an infrastructure and scaling-law findings beyond the dataset and benchmark. (i) An infrastructure: an autonomous engine that continuously produces flow data on new geometry families, and future work can use it to build larger datasets for its own problems under the same verification standard and data format. Methodologically, it is the first autonomous data engine for large-scale flow simulation, in which an LLM agent both proposes new geometry families and iteratively repairs their mesh strategies (see (2)). (ii) Scaling-law findings: the error on new families decreases approximately as a power law in the number of training families, a law not reported before for neural operators across geometries. Similar works have been published at ICLR in application areas rather than datasets and benchmarks: GenSim [10] (ICLR 2024, spotlight) synthesizes diverse simulation tasks with LLMs to improve robot generalization, and Lin et al. [11] (ICLR 2025, oral) report a power law between robot generalization and data diversity. Our work extends this paradigm to neural operator learning in physical simulation.

References

[1] PDEformer: Towards a Foundation Model for One-Dimensional Partial Differential Equations

[2] Multiple Physics Pretraining for Spatiotemporal Surrogate Models

[3] DPOT: Auto-Regressive Denoising Operator Transformer for Large-Scale PDE Pre-Training

[4] Poseidon: Efficient Foundation Models for PDEs

[5] PDEBench: An Extensive Benchmark for Scientific Machine Learning

[6] Towards Multi-spatiotemporal-scale Generalized PDE Modeling

[7] CFDBench: A Large-Scale Benchmark for Machine Learning Methods in Fluid Dynamics

[8] Scaling Laws for Neural Language Models

[9] Scaling Vision Transformers

[10] GenSim: Generating Robotic Simulation Tasks via Large Language Models

[11] Data Scaling Laws in Imitation Learning for Robotic Manipulation

Reviewer_tW2rOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

KaleidoFlow is an autonomous data engine that uses a language model to propose geometry families and iteratively repair mesh strategies before running OpenFOAM simulations. The dataset contains 459 families, 3,948 geometries, and 16,512 trajectories. Using a fixed release of 243 families, the authors construct a benchmark distinguishing Reynolds-number generalization, within-family geometric generalization, and cross-family generalization. They report a substantial increase in rollout error on unseen families and an approximate power-law relationship between training-family count and one-step prediction error.

Critical strengths
  1. The pipeline integrates geometry generation, mesh repair, convergence testing, and simulation into an automated workflow. The resulting collection provides a substantial resource for studying neural operators across diverse geometries.

  2. The G1/G2/G3 hierarchy distinguishes parameter generalization from within-family and cross-family geometric generalization. The fixed-total-trajectory comparison further supports the benefit of increasing geometric diversity.

Critical weaknesses
  1. Approximately 51% of repaired families pass through global mesh-size changes, yet the paper lacks a mesh-size search baseline with the same solver budget. Comparing iterative LLM repair against a fixed default strategy does not isolate the benefit of the language model from additional search.

  2. Coordinate modulation reduces UNet’s G3 error from 0.496 to 0.390, indicating sensitivity to geometry encoding. However, controlled comparisons of geometry encodings and one-step versus multistep training are missing. It remains unclear how robust the reported 3–6× generalization gap is to these choices.

Questions for authors
  1. Compared with mesh-size search under an equal solver budget, how much does LLM repair improve acceptance rate and computational cost?

  2. Does the 3–6× G2-to-G3 error increase persist when distance-field encoding and multistep training are evaluated separately?

  3. Is the fitted power-law exponent stable across repeated training-family selections? Do rollout error and divergence rates improve consistently with the one-step error?

4 comments

Thanks for your thoughtful reviews and insightful questions. They have significantly improved this work. We respond point-by-point below.

[W1, Q1] "How much does LLM repair improve over a mesh-size search under an equal solver budget?"

We thank you for this helpful suggestion. Following your suggestion, we compared the two methods on a stratified sample of about 100 families. Under the same solver budget, the mesh repair of our engine passes far more families than mesh-size search. The mesh-size search uses no LLM and scales all cell sizes of the default strategy by one global factor, which it searches by bracketing. Both methods use the same number of convergence tests per family, about 700 CPU hours in total, and the same pass rule (revised Sec. 3.2 and Appendix C.5).

MethodPass rate
Mesh repair in the KaleidoFlow engine70%
Mesh-size search20%

The results show that our LLM-based mesh repair raises the pass rate by 50 percentage points under the same budget (response to Q1), so its benefit does not come from additional search alone. A single global factor scales all cell sizes together, while our mesh repair refines the mesh where the failure report locates the error. We have added these results to the revised Appendix C.5.

[W2, Q2] "Does the 3–6× G2-to-G3 gap persist with distance-field encoding and multistep training?"

We thank you for this insightful suggestion. We agree that the geometry encoding can help an architecture generalize across geometries. Following your suggestion, we conducted systematic comparisons of geometry encodings and of one-step versus multistep training on UNet-c. We tested three geometry encodings and pushforward training [1] over one to four unrolled steps, on the same splits with 200,000 training steps (revised Sec. 4.3 and Appendix D.4). The results are as follows.

Geometry encodingG2 errorG3 errorG3/G2 error ratio
Binary fluid mask (default input)0.08740.42524.87
Binary fluid mask + signed distance0.08870.48445.46
Signed distance0.09450.55225.84
Fluid fraction0.08430.40954.85
TrainingG2 errorG3 errorG3/G2 error ratio
One-step (default)0.08740.42524.87
Multistep (pushforward, 1–4 unrolled steps)0.08090.32854.06

Our results show that a suitable geometry encoding and multistep training can improve generalization to unseen families, but a large G3/G2 error ratio persists in every case. The fluid fraction lowers the G3 error slightly, and pushforward training lowers it by 23%. However, the G3/G2 error ratio remains between 4 and 6 for every geometry encoding and for multistep training, within the 3–6× range of Sec. 4.3. Therefore, we believe that closing this gap requires better architectures and training methods, which is an important direction for future research. Our engine, dataset, and benchmark provide the infrastructure to develop and evaluate such methods.

[Q3 (1)] "Is the fitted exponent stable across repeated training-family selections?"

Yes, the exponent is stable across training-family selections. We trained UNet-c, F-FNO, and FNO with KK from 24 to 192 on three different random selections of the training families (revised Appendix E.4, Table 17). The table gives α\alpha in error∝K−α\text{error} \propto K^{-\alpha} for each selection. The range of α\alpha over the selections is at most 0.06 for each architecture, and the order of the three architectures is the same for every selection. Therefore, the exponent is stable across training-family selections.

Architectureα\alpha, selection 1α\alpha, selection 2α\alpha, selection 3
UNet-c0.320.310.32
F-FNO0.220.270.23
FNO0.150.200.14

[Q3 (2)] "Do rollout error and divergence improve consistently with the one-step error?"

Both the rollout relative error and the divergence excess decrease with the number of training families, although not exactly as the one-step error does, which is similar to the scaling laws of language models. We computed the rollout relative error and the one-step divergence excess on the runs of the extended scaling study, with three training seeds and KK from 24 to 271 (revised Appendix E.4, Tables 19 and 20; see also our reply to Reviewer rkVh, Q2). The two tables report each metric, together with the R2R^2 of its power law and the R2R^2 of the relative error for comparison. From K=24K = 24 to 271271, the rollout error decreases by about 31%, and the divergence excess decreases by a factor of 2 to 4.

Rollout relative error:

ArchitectureK=24K=24K=32K=32K=64K=64K=128K=128K=192K=192K=271K=271Rollout R2R^2One-Step R2R^2
UNet-c0.349±0.0060.369±0.0110.291±0.0090.280±0.0070.271±0.0100.239±0.0240.910.98
HNO0.343±0.0140.390±0.0270.275±0.0010.267±0.0040.247±0.0090.234±0.0040.860.95
F-FNO0.341±0.0090.353±0.0020.283±0.0020.270±0.0070.258±0.0050.236±0.0030.940.95

Divergence excess, in units of 10−310^{-3}:

ArchitectureK=24K=24K=32K=32K=64K=64K=128K=128K=192K=192K=271K=271Divergence R2R^2Relative error R2R^2
UNet-c4.0±1.64.2±1.13.9±0.43.0±0.51.8±0.41.1±0.10.780.98
HNO8.8±2.112.1±2.13.8±0.13.0±0.42.8±0.22.6±0.20.850.95
F-FNO9.2±0.19.9±0.45.6±0.65.4±0.15.2±0.34.0±0.30.890.95

Both metrics follow the power law less closely than the one-step error, as downstream metrics do in the scaling laws of language models. In language models, the training loss follows a power law [2], while metrics that are not optimized directly can deviate from it [3]. Similarly, our models are trained on the one-step relative error of the velocity. The rollout error also depends on the stability of the model under its own predictions, which one-step training does not control [1]. The divergence depends on the spatial derivatives of the predicted velocity, which the loss does not constrain. Therefore, both metrics decrease with the number of training families but follow the power law less closely.

References

[1] Message Passing Neural PDE Solvers

[2] Scaling Laws for Neural Language Models

[3] Are Emergent Abilities of Large Language Models a Mirage?

Thank you for thre rebuttal which has addressed my questions, and I have no new concerns now.

We sincerely thank you for your feedback and for acknowledging our work. Your suggestions have significantly improved this work, and we deeply appreciate the time you have devoted to reviewing it. If you have any further questions or concerns, please feel free to let us know, and we will be glad to respond.

Reviewer_DucGOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

An autonomous, LLM-agent-based framework for generating computational fluid dynamics datasets across diverse geometries.

The paper makes four primary contributions: an autonomous CFD data-generation pipeline, a geometrically diverse flow dataset, a benchmark for evaluating neural operator generalization across geometry families, and an empirical investigation of scaling laws for cross-geometry generalization.

Validation includes demonstrating successful automated mesh refinement to meet prescribed convergence criteria, quantifying geometric diversity, and benchmarking nine neural operator architectures. The authors find that prediction errors increase by approximately 3–6× when generalizing to previously unseen geometry families, compared with unseen geometries within known families.

The most interesting observation: They also observe an approximate power-law reduction in generalization error with increasing numbers of training geometry families across three representative neural operator architectures.

Critical strengths

A useful and scalable framework for autonomous CFD data generation: The paper demonstrates an end-to-end pipeline that automatically generates geometries, constructs and refines meshes, verifies mesh convergence, and performs CFD simulations. I particularly appreciate what this framework enables: reducing the human effort required to generate diverse simulation datasets. The integration of these capabilities into an autonomous workflow is valuable and could have considerable practical impact for computational science.

A potentially valuable benchmark for geometric generalization: The authors construct a benchmark that explicitly distinguishes generalization within a geometry family from generalization to previously unseen families. The preliminary scaling-law observations are also interesting and could motivate future investigations into foundation models for scientific computing.

Critical weaknesses

1. Limited methodological novelty for ICLR. While I appreciate the utility of the proposed framework, I am not convinced that it represents a sufficiently substantial methodological contribution for ICLR. Automated geometry generation, mesh construction and refinement, solver execution, and convergence verification are established capabilities in computational science, and their orchestration through LLM-based agents is becoming increasingly common. The primary contribution appears to be the successful integration and automation of these existing capabilities rather than a fundamentally new machine learning methodology or scientific insight. I can see significant value in this work as an enabling computational tool, but I am less convinced that it meets the novelty expectations of this venue. This is my primary concern.

2. Limited dataset complexity and insufficient depth in the scaling-law analysis. The entire dataset consists of 2D geometries and simulations. While the number of geometry families is impressive, generating and solving such 2D problems is relatively inexpensive and straightforward compared with realistic 3D CFD. Demonstrating the framework on diverse 3D geometries, where meshing, numerical stability, and computational costs present substantially greater challenges, would have made both the automation framework and the resulting dataset considerably more compelling.

Furthermore, the scaling-law observation is potentially one of the most interesting scientific contributions of the paper, but it receives relatively limited exploration. The reported approximate power-law behavior across three architectures is intriguing, yet a more systematic analysis of the scaling exponents, their robustness across architectures and flow regimes, and the limits of the observed trends would be necessary to establish a convincing generalizable result. Given that this is explicitly identified as one of the paper's four main contributions, I recommend substantially deeper investigation.

Overall, I like this work for what it enables, but I do not find the methodological novelty, dataset complexity, or depth of scientific analysis sufficiently compelling for acceptance at ICLR.

Questions for authors

none

2 comments

Thanks for your thoughtful reviews and insightful questions. They have significantly improved this work. We respond point-by-point below.

[W1] "Limited methodological novelty."

We understand your concern about novelty. We agree that each numerical component of the engine, such as the solver and the convergence test, is an established technique. Our main contribution is the first systematic study of how neural operators generalize across diverse geometry families, an important open problem in neural operator learning [1, 2, 3]. This study requires verified flow data on hundreds of geometry families, which existing tools and agents cannot readily produce, so we built an autonomous data engine to make it possible. It also provides important scientific insights into the generalization of neural operators across geometries. We respond to your comments point by point below.

(1) "Rather than a fundamentally new machine learning methodology or scientific insight." This work provides three quantitative insights on how neural operators generalize to unseen geometries. First, the error jumps at a new family. For all nine architectures, it stays within a factor of 1.4 on new geometries of trained families but rises by a factor of 3 to 6 on a new family (Sec. 4.3). Second, the error on new families follows a power law in the number of training families (Sec. 4.4), which you recognized as "potentially one of the most interesting scientific contributions of the paper". A fit on K≤128K \le 128 predicts the error at K=192K = 192 and 271271 within 6% for five of the six architectures (Appendix E.4). Third, the number of families is the main factor among those we tested. At 200,000 training steps, doubling the training families reduces the error of UNet-c by 20%, while doubling the model size or the trajectories per family reduces it by at most 4% (Table 21).

(2) "Their orchestration through LLM-based agents is becoming increasingly common." Our engine differs from both established CFD tools and existing LLM-based CFD agents. (a) Compared with established CFD tools, our LLM-based generation achieves higher geometric diversity. About 80% of our families differ clearly in shape from every family of a scripted generator of ten classic templates at the same size (Appendix C.7). Our LLM-based mesh repair significantly outperforms mesh-size search at the same solver budget, with a pass rate of 70% versus 20% (Appendix C.5). (b) Compared with existing LLM-based CFD agents, which start from a shape given by the user [4] and, to our knowledge, do not report a grid convergence test, our agent decides which new geometry to create, and a family is accepted only if its mesh passes the grid convergence test on the hardest trajectory (Appendix B.1).

In summary, we acknowledge that this work is only a first step towards foundation neural operators that generalize across diverse geometries. Its novelty is an empirical scientific finding, together with the infrastructure that makes it measurable. Prior scaling laws for neural operators are in the number of samples or PDE systems, whose samples share one geometry (Sec. 5). Our power law is the first in the number of geometry families. We believe that this work meets the "novelty expectations of this venue". We have revised the abstract and Sec. 1 accordingly.

[W2 (1)] "The entire dataset consists of 2D geometries. Generating such 2D problems is relatively inexpensive and straightforward."

First, we agree that solving one 2D case is simple, but generating 2D flow data at the scale of hundreds of diverse geometry families is not straightforward. An agent alone tends to repeat familiar shapes, and a simulation can run normally with a large discretization error. The engine therefore requires each proposal to differ from its closest families and repairs every mesh strategy that fails a convergence test (Appendices A.1 and A.2).

Second, our main contribution is a study of operator learning across geometries, and 2D is the standard setting for this study. The question of this work, whether a neural operator generalizes to new geometry families and how its error scales with their number, does not depend on the dimension, and recent foundation neural operators are also pretrained mainly on 2D problems [1, 2, 5]. Current architectures already fail to generalize to new families in 2D (Sec. 4.3), so this gap is not an artifact of a simple setting, and we expect that 3D geometries would make it even more challenging rather than close it.

In summary, we agree that 3D geometries may make this work more compelling (Sec. 6). However, 3D geometries are not required for the core question of this work. Our 2D study already contributes a valuable dataset and meaningful results, and reaching this scale requires a substantial infrastructure. Therefore, we consider 3D beyond the scope of this work and will explore it in future work.

[W2 (2)] "The scaling-law observation receives relatively limited exploration."

We thank you for this helpful suggestion. Following your suggestion, we extended the experiments with three training seeds, six architectures, a wider KK range (24–271), random G3 test splits, and more error metrics (revised Appendices E.4 and E.5). The results show that the scaling law is stable over training seeds and generalizes across architectures and flow regimes. We respond point by point below.

(a) "Robustness across architectures." The exponent of every architecture is stable over repeated training. The table reports the G3 error (10−210^{-2}, mean ± std over three seeds), the exponent α\alpha in error∝K−α\text{error} \propto K^{-\alpha}, and its R2R^2 (revised Fig. 10 and Table 16).

ArchitectureK=24K=24K=32K=32K=64K=64K=128K=128K=192K=192K=271K=271α\alphaR2R^2
UNet-c4.54±0.144.74±0.243.55±0.082.81±0.052.41±0.142.17±0.010.33±0.010.98
HNO4.30±0.204.70±0.203.22±0.032.80±0.052.40±0.042.31±0.010.30±0.020.95
CNO5.20±0.184.99±0.243.80±0.053.48±0.063.22±0.072.87±0.050.24±0.000.98
F-FNO5.05±0.125.30±0.053.94±0.083.69±0.083.33±0.052.96±0.030.23±0.000.95
DilRes4.30±0.214.36±0.353.61±0.173.40±0.162.95±0.362.62±0.110.20±0.050.96
FNO5.79±0.116.03±0.315.10±0.084.79±0.024.51±0.124.36±0.030.13±0.010.95

(b) "Robustness across flow regimes." The exponent is stable across Reynolds numbers and for unsteady flows. We computed α\alpha separately for the test trajectories in three Reynolds-number ranges and for the 44 steady and 150 unsteady test trajectories (revised Table 18). In each Reynolds-number range and for unsteady flows, α\alpha remains close to its value on all test trajectories.

ArchitectureAll test trajectoriesRe≤400\text{Re} \le 400400<Re≤800400 < \text{Re} \le 800Re>800\text{Re} > 800SteadyUnsteady
UNet-c0.33±0.010.34±0.010.35±0.020.35±0.020.27±0.020.36±0.01
HNO0.30±0.020.30±0.030.31±0.020.28±0.010.29±0.020.31±0.02
CNO0.24±0.000.27±0.000.24±0.010.23±0.010.22±0.010.25±0.00
F-FNO0.23±0.000.24±0.000.23±0.010.23±0.010.14±0.010.25±0.01
DilRes0.20±0.050.23±0.060.23±0.050.20±0.050.18±0.040.22±0.05
FNO0.13±0.010.17±0.000.13±0.000.11±0.010.09±0.020.15±0.01

(c) "The limits of the observed trends." As in the scaling laws of language models, some physical metrics do not follow the power law as strictly as the training objective. In language models, the next-token loss follows a power law [6], while downstream metrics that are not optimized directly can deviate from it, because they depend nonlinearly on the per-token error [7]. Similarly, our training objective and the one-step vorticity error follow the power law closely, while the rollout metrics and the divergence excess follow it less closely (revised Appendix E.5 and Table 22). As in language models, these deviations do not change the power law of the training objective, which remains a valid indicator of generalization to unseen families.

Metricsα\alphaR2R^2
One-step velocity error (training objective)0.330.98
One-step vorticity error0.310.97
Rollout kinetic-energy error0.230.93
Rollout high-frequency spectral error0.120.44

Further results are reported in the revised Appendix E.4.

[Response Summary]

We thank you for your review, and we believe the revision resolves your concerns about novelty, dataset complexity, and the scaling analysis. On novelty, the revised abstract and Sec. 1 state that our main contribution is the first systematic study of how neural operators generalize across geometry families. On dataset complexity, 2D is sufficient for our core question, since current architectures already fail to generalize to new families in 2D. On scaling, the scaling law is stable over training seeds and generalizes across architectures and flow regimes.

References

[1] Multiple Physics Pretraining for Spatiotemporal Surrogate Models

[2] Poseidon: Efficient Foundation Models for PDEs

[3] Operator Learning with Domain Decomposition for Geometry Generalization in PDE Solving

[4] Foam-Agent: Towards Automated Intelligent CFD Workflows

[5] DPOT: Auto-Regressive Denoising Operator Transformer for Large-Scale PDE Pre-Training

[6] Scaling Laws for Neural Language Models

[7] Are Emergent Abilities of Large Language Models a Mirage?

Reviewer_oa1WOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

KaleidoFlow is an autonomous fata engine that uses agent to create diverse geometry families, to build and to verify the corresponding meshes, then simulates all trajectories without human intervention. The resulting dataset is then used to train and test neural operators. It analyses how additional cases/geometries covers all possibilities in order to enhance predictions. The proposed neural operators generalize poorly, but could be replaced easily with other artchitectures.

Critical strengths

The pipeline builds varied CFD datasets requires substantial manual work. Mesh repair and convergence checks are useful parts of the approach. The benchmark separates different features such as new Reynolds numbers, new geometries within known families, and entirely new families. This makes the generalization results easier to understand. The evaluation includes additional physical measures such as divergence, kinetic energy, and vorticity.

Critical weaknesses

The full computational cost remain hard to assess. Data generation required about 54,000 CPU hours, but the main text does not give the total GPU training cost, agent cost, or energy use. The practical question is how much prediction accuracy improves for a given total budget. Removing difficult cases could orient the dataset toward easier situations. The treatment of time dependency needs clarification. Different intervals could make next-step prediction inconsistent across families. Spatial convergence also does not establish time-step convergence. The power-law result is promising but based on three fitted dataset sizes and one additional comparison. Repeated runs and uncertainty estimatation could enhance the framework. Building geometries in 3D will remain an important challenge.

Questions for authors

What happens when a solver keeps diverging or a mesh cannot pass the checks within the cell limit? Are failed individual trajectories removed while the rest of their family is retained? Could this systematically exclude difficult flow conditions? How is the hardest trajectory selected? Does the selection consider geometric parameters as well as Reynolds number? If output intervals differ, how does the neural operator know which interval to predict? How is temporal accuracy checked? What is the complete CPU, GPU, and agent budget, including failed attempts? At the same budget, how does this approach compare with a simpler scripted geometry and mesh-generation pipeline? How does the agent decide which geometry family to generate next? Is there an explicit criterion for diversity or physical relevance, or does the choice mainly depend on the LLM’s suggestions? How does this compare with random or scripted geometry generation under the same computational budget?

2 comments

Thanks for your thoughtful reviews and insightful questions. They have significantly improved this work. We respond point-by-point below.

[W1, Q7] "The full computational cost remains hard to assess." "What is the complete CPU, GPU, and agent budget, including failed attempts?"

Thank you for this suggestion. We further counted the complete computational cost, including the simulation, the convergence tests with all failed attempts, the agent calls, and the training. The results are as follows (revised Appendix A.6).

ItemScopeCost
Simulation16,512 released trajectories52K CPU hours
Convergence testsall 3,257 attempts, including failed ones5.5K CPU hours
Agent calls1,340 proposals and 4,671 repair calls3.1K USD (approximated)
Trainingone full-protocol run per architecture6 to 140 GPU hours

The failed attempts account for only a small fraction of the total cost, about 3.5K CPU hours or 6% of the total CPU budget. Energy use follows from these CPU and GPU hours.

We further compared the accuracy gained from different resources at the same training budget (UNet-c, revised Table 21). For a given budget, adding training families improves accuracy the most. A new family costs about 125 CPU hours, and the training cost at a fixed number of steps does not increase with the number of families.

Resource doubledRange testedError decrease per doubling
Training families24 to 27120%
Model size1.7M to 14.9M3%
Trajectories per family4 to 16at most 4%

[W2, Q1–Q3] "Removing difficult cases could orient the dataset toward easier situations."

Removing the failed cases does not orient the dataset toward easier flows. The released families and the families that did not pass have similar Reynolds numbers, numbers of boundary segments, and fluid fractions. The failures are caused mainly by the mesh strategy and the computing budget, which do not lower the difficulty of the released flows. We answer your questions point by point below.

[Q1] "What happens when a solver keeps diverging or a mesh cannot pass the checks?" The mesh strategy is repaired, and a family with no passing strategy is not included in the dataset. A diverging solve or a mesh above 400,000 cells fails the test and triggers a repair (Sec. 3.2).

[Q2] "Are failed individual trajectories removed while the rest of their family is retained?" Yes, only the failed trajectory is removed, which only affected three trajectories in the released families (revised Appendix C.6).

[Q3] "Could this systematically exclude difficult flow conditions?" No, the convergence test does not systematically exclude difficult flows. The failures are caused mainly by mesh generation, the solver time cap, or a convergence index above 5% within the cell limit (revised Appendix C.6). In addition, the released families are nearly as demanding as those that did not pass, as the medians of three measures of difficulty show.

MedianReleased familiesFamilies that did not pass
Highest Reynolds number1,2001,320
Boundary segments1214
Fluid fraction0.750.72

[W3, Q5, Q6] "The treatment of time dependency needs clarification."

Thank you for this helpful suggestion. We have clarified this point in the revised Sec. 2.3. The output interval is the same for every family, so the next-step prediction is consistent across families. Every trajectory is exported at the same physical interval of 0.1 seconds. The solver uses its own time step, which is much smaller than the output interval, so the interval only sets the sampling of a time-accurate solution. This setting is also standard in operator learning, where a neural operator learns the map between snapshots at a fixed time interval [2, 4, 5]. We answer your two questions in turn below.

[Q5] "How does the neural operator know which interval to predict?" The output interval does not differ between families. All trajectories are sampled every 0.1 seconds, so the neural operator always predicts the state 0.1 seconds later (Appendix A.1).

[Q6] "How is temporal accuracy checked?" The temporal accuracy is ensured together with the spatial accuracy. The solver uses an adaptive time step that keeps the Courant number below 0.5, so it halves when the mesh is refined by a factor of two (Appendix A.3). Therefore, the three meshes of the convergence test refine space and time together, and the grid convergence index [1] bounds the combined error.

[W4] "The power-law result is based on three fitted dataset sizes."

Following your suggestion, we extended the experiments to six architectures, three training seeds, and KK from 24 to 271. The table reports the G3 error (10−210^{-2}, mean ± std over three seeds), the exponent α\alpha in error∝K−α\text{error} \propto K^{-\alpha}, and its R2R^2 (revised Fig. 10 and Table 16). The error follows the power law approximately over this wider range for every architecture, and the uncertainty over repeated training is small, as the standard deviation over seeds is much smaller than the decrease of the error from K=24K = 24 to 271271.

ArchitectureK=24K=24K=32K=32K=64K=64K=128K=128K=192K=192K=271K=271α\alphaR2R^2
UNet-c4.54±0.144.74±0.243.55±0.082.81±0.052.41±0.142.17±0.010.33±0.010.98
HNO4.30±0.204.70±0.203.22±0.032.80±0.052.40±0.042.31±0.010.30±0.020.95
CNO5.20±0.184.99±0.243.80±0.053.48±0.063.22±0.072.87±0.050.24±0.000.98
F-FNO5.05±0.125.30±0.053.94±0.083.69±0.083.33±0.052.96±0.030.23±0.000.95
DilRes4.30±0.214.36±0.353.61±0.173.40±0.162.95±0.362.62±0.110.20±0.050.96
FNO5.79±0.116.03±0.315.10±0.084.79±0.024.51±0.124.36±0.030.13±0.010.95

[W5] "Building geometries in 3D will remain an important challenge."

We agree that 3D geometries are more challenging, and as we discuss in Sec. 6, they are beyond the core scope of this work. The core of this work is operator learning across diverse geometries, which is an important open problem for neural operators [2, 3, 6]. The question of this work, whether a neural operator generalizes to new geometry families and how its error scales with their number, does not depend on the dimension, and 2D is the standard setting used by most current datasets and pretrained neural operators [2, 3, 4, 5]. Current architectures already fail to generalize to new families in 2D (Sec. 4.3), so this gap is not an artifact of a simple setting, and we expect that 3D geometries would make it even more challenging rather than close it. The engine has not yet been tested in 3D.

[Q4] "How is the hardest trajectory selected? Does the selection consider geometric parameters?"

Yes, the hardest trajectory is selected by both the Reynolds number and the geometric parameters (Appendix B.1). The engine first takes the trajectories with the highest Reynolds number. If several trajectories have the same highest Reynolds number, the engine orders them by their geometric parameters and verifies the last one. On a second geometry in 40 randomly selected families, the verified mesh strategy gives a median velocity convergence index of 2.7%, below 10% in every family with a defined index (revised Appendix B.1). Therefore, the verified mesh strategy also gives an accurate solution on the other geometries of the family.

[Q8, Q10] "At the same budget, how does this approach compare with a simpler scripted pipeline?"

At the same budget, our engine produces more diverse geometries and passes more mesh tests than a scripted pipeline. For geometry, we built a scripted generator of ten classic templates with random parameters and compared it with our dataset at the same numbers of families and geometries (revised Appendix C.7). About 80% of our families differ clearly from every scripted family in shape, while about half of the scripted families are similar to one of our families. Because simulation accounts for most of the cost (52K of the 57.5K CPU hours), equal numbers of families and geometries mean nearly equal budgets. For mesh generation, our mesh repair significantly outperforms a mesh-size search under the same solver budget, with a pass rate of 70% versus 20% (Appendix C.5).

[Q9] "Is there an explicit criterion for diversity or physical relevance?"

Yes, during data synthesis in the engine, every proposed family is required to satisfy predefined requirements for both physical relevance and diversity (Appendix A.1). For physical relevance, each proposal must describe an actual engineering flow with physically justified dimensions and boundary conditions. For diversity, each proposal must target a combination of flow mechanism and application that the existing families cover sparsely. It must also name its three closest existing families and explain how it differs from them. The engine then checks each proposal before the family is added. Therefore, the choice does not depend only on the suggestions of the LLM.

References

[1] Perspective: A Method for Uniform Reporting of Grid Refinement Studies

[2] Multiple Physics Pretraining for Spatiotemporal Surrogate Models

[3] Poseidon: Efficient Foundation Models for PDEs

[4] Fourier Neural Operator for Parametric Partial Differential Equations

[5] PDEBench: An Extensive Benchmark for Scientific Machine Learning

[6] Operator Learning with Domain Decomposition for Geometry Generalization in PDE Solving

Comments on the paper

2 comments
AuthorsOpenReview ↗

General response

We thank all reviewers for their constructive comments. Below, we briefly respond to the main concerns of the reviewers, and we give our detailed responses in our reply to each reviewer.

  1. Contribution of this work (DucG, rkVh). We understand that Reviewers DucG and rkVh may see this work mainly as an LLM framework for dataset generation, since the engine is an important part of the paper. However, we would like to respectfully clarify that the core of this work is the first systematic study of how neural operators generalize across diverse geometry families, and the engine is the infrastructure that enables this study. Generalization across geometries is an important open problem for neural operators, but no existing flow dataset contains enough geometry families to study it. We therefore built an autonomous engine that produces verified flow data on 459 geometry families, 40 times more than any existing flow dataset. Compared with conventional pipelines, the engine generates more diverse geometries and repairs meshes more effectively: about 80% of its families differ clearly from those of a scripted generator, and its mesh repair passes 70% of sampled families at the same solver budget, compared with 20% for a mesh-size search (Appendices C.5 and C.7). On the resulting dataset, we find that current architectures generalize poorly to new families, and that their error decreases approximately as a power law in the number of training families. This work therefore contributes these scientific insights, together with the infrastructure that produces them. We have revised the abstract and Sec. 1 accordingly to make this point clear.

  2. Scaling law (all reviewers). Following the suggestions of all reviewers, we have substantially extended the scaling experiments, with six architectures, three training seeds, and KK from 24 to 271. The error of every architecture decreases approximately as a power law, with R2R^2 from 0.95 to 0.98, and the exponent is stable over training seeds, training-family selections, and Reynolds numbers.

  3. 2D scope (DucG, rkVh, oa1W). This work studies whether neural operators generalize to new geometry families, and this question does not depend on the dimension. 2D is also the standard setting for operator learning. Current architectures already fail to generalize to new families in 2D, so we expect that 3D geometries would make this generalization even more challenging rather than close this gap. The engine has not yet been tested in 3D, which is beyond the scope of this work, and we discuss this limitation in Sec. 6.

We summarize the main changes in the revised manuscript below, where all changes are marked in blue.

  • The abstract and Sec. 1 state that the core of this work is the first systematic study of how neural operators generalize across diverse geometry families, and that the engine is the infrastructure that enables this study.
  • Sec. 4.4 and Appendices E.3 to E.5 extend the scaling study to six architectures, three training seeds, and KK from 24 to 271 (Fig. 8, Figs. 10 to 12, Tables 16 to 22).
  • Appendix C adds a mesh-size search baseline (C.5, Table 6), statistics of the families that did not pass (C.6, Table 7), and a scripted geometry baseline (C.7, Table 8).
  • Sec. 2.3 and Appendix A.3 specify the output interval, the time-step refinement, and the flow models, and Appendix A.3 reports the results without high-Re trajectories (Tables 1 and 2). Appendix A.6 reports the complete cost (Table 3), and Appendix D.4 compares geometry encodings and multistep training (Table 10).
  • Sec. 6 states the scope of the dataset.

We hope that the revision and our replies address the main concerns, and we are happy to answer any further questions.

AuthorsOpenReview ↗

Summary of the Discussion

We thank all reviewers and Area Chairs for their time and effort. As the discussion period ends, we briefly summarize our contributions and the discussion.

Contributions and novelty. In classical numerical simulation, each problem is usually solved with expert-designed ad hoc methods. Recently, a line of work pursues general PDE solvers that handle diverse problems with a single model [1, 2, 3, 4]. Such solvers must handle unseen geometries, and they therefore require diverse and scalable data on many different geometries. However, such data are still lacking, and how current architectures generalize across geometries remains an open question. This work addresses both challenges. First, we build the first autonomous data engine for large-scale flow simulation, in which an LLM agent proposes new geometry families and iteratively repairs their mesh strategies from structured diagnostics. It automatically produces verified flow data on 459 geometry families, 40 times more than any existing flow dataset. Second, based on this data, we provide the first systematic study of how neural operators generalize across geometry families. Current architectures fail on new families, and the error decreases as a power law in the number of training families, consistently across six architectures and three training seeds. This scaling law across geometry diversity provides a scalable path towards general PDE solvers that generalize across geometries, as scaling laws have done in other domains [5, 6].

Discussion. We have responded to every point raised by the reviewers, and Reviewer tW2r confirmed that our responses addressed the concerns. We believe that the revision also addresses the remaining concerns. As we have not received further responses from the other reviewers, we respectfully hope that the revision and our replies will be carefully considered in the final decision.

Finally, we sincerely thank all reviewers for their time and constructive comments. We are also grateful to the Area Chairs for their time and effort in handling our submission and for carefully considering the discussion.

[1] PDEformer: Towards a Foundation Model for One-Dimensional Partial Differential Equations

[2] Multiple Physics Pretraining for Spatiotemporal Surrogate Models

[3] DPOT: Auto-Regressive Denoising Operator Transformer for Large-Scale PDE Pre-Training

[4] Poseidon: Efficient Foundation Models for PDEs

[5] Scaling Laws for Neural Language Models

[6] Scaling Vision Transformers

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.