Written by: Shahroz Khan - CEO at Compute Maritime

I spent two days at CDFAM - Computational Design Symposium - Barcelona last week, an event that Duann Scott and his team continue to make one of the most technically honest gatherings in computational design. The room was sharp: NVIDIA, PhysicsX, Emmi AI, BeyondMath, Generative Engineering, SimScale, ToffeeX, Pasteur Labs & ISI, Siemens Digital Industries Software, nTop, Quix, Synera, and more. The presentations were excellent. The technical depth was real.

But as I sat through talk after talk, a pattern emerged that I think the engineering AI community needs to confront honestly.

Two conversations are happening. Neither is complete.

The first conversation is about foundation models for physics. Emmi AI has NeuralMould for injection moulding. PhysicsX is building Large Physics Models for automotive aerodynamics. BeyondMath is training on self-generated first-principles data for CFD. Pasteur Labs is building differentiable simulation infrastructure. These are serious efforts backed by serious funding. Emmi AI alone raised EUR 15M in the largest seed round in Austrian startup history. PhysicsX is using Siemens simcenter on high-fidelity training data. The technical work is real and the progress is meaningful.

The second conversation is about AI for CAD. Moritz Rietschel from Raven is building an LLM agent for Grasshopper. Cognitive Design by CDS is working on generative design with manufacturability intelligence. Synera is automating Body-in-White workflows at SEAT-CUPRA. SimScale is developing agentic workflows that orchestrate simulation tasks. The common thread here is using large language models, increasingly with agentic architectures and MCP protocols, to streamline the human-to-CAD interaction. The LLM becomes the code generator. The CAD kernel becomes the renderer. It is, in essence, vibe coding for design.

Physics models inherit the limits of the designs they are trained on

Consider what the physics foundation models are actually trained on. NeuralMould learns from millions of injection moulding simulations, but those simulations are run on geometries that were created parametrically: a base mould design with systematic parameter sweeps across wall thickness, gate placement, injection pressure, and material properties. PhysicsX's PXNetCar dataset contains 20,000+ CFD simulations, but the geometric corpus is built from approximately 250 baseline vehicle designs with morphological variations. Emmi AI's NeuralWing dataset consists of 30,000 simulations varying four geometry parameters and two inflow conditions on a single 3D wing.

This is not a criticism of the technical work. These are well-engineered datasets that serve their purpose. But there is a structural constraint that is rarely discussed: these models are trained on the design space that traditional engineering already knows how to explore. The geometries are parametric variations of existing designs. The innovation space is, by construction, conservative.

A physics foundation model trained on 250 car shapes with morphological perturbations will learn to predict drag and lift exceptionally well within that morphological family. What it will not do is generate a fundamentally different aerodynamic concept. The model knows how existing cars behave. It does not know what other shapes could exist.

This matters because if all we needed was faster evaluation of known design spaces, we would already be well-served. GPU-accelerated solvers are making traditional CFD and FEA naturally faster. Neural operator approaches like Fourier Neural Operators and DeepONet are providing mesh-free approximations with increasing accuracy. Hardware is catching up to the simulation bottleneck. 

There are companies moving in a more promising direction. Secondmind, whom I met at Michael Finocchiaro's Threaded Live event in Warwick, uses Bayesian optimisation and active learning to navigate complex design trade-offs with up to 80% fewer simulations. That is a meaningful step: instead of exhaustively sweeping a parameter space, the model learns where to look next. It is intelligent exploration, and it matters.

But even intelligent exploration still requires a human to define the design space in the first place. The parameters, the bounds, the topology, all of that is set before the model begins. 

LLMs cannot represent design intent

Now consider the CAD-side conversation. The premise of LLM-driven design tools is that a designer's intent can be expressed linguistically, translated into code by a language model, and executed by a CAD kernel. This works remarkably well for automating repetitive modelling tasks, connecting plugins, generating Grasshopper definitions, or scripting parametric sweeps.

The shape of a ship has intrinsic geometric features, contextual relationships between curvature, displacement, stability, and resistance, interdependencies that emerge from physics and manufacturing constraints, and a design intent that is never written down because it lives in the spatial reasoning of the naval architect. The same is true of an aircraft wing, a turbine blade, or a Formula One front wing endplate.

These properties are not captured in text. They are not captured in code. They are not captured in parametric definitions. They exist in the geometry itself, in the continuous surface, in the relationship between local curvature and global performance, in the reasons why a particular shape works for a cargo vessel but fails as a patrol boat.

An LLM can generate a script that creates a ship hull or propeller. It cannot understand why that hull is a good hull. It has no representation of what makes a ship a ship, what makes a car a car, or what distinguishes a high-performance geometry from an arbitrary one. 

The missing layer: design-native intelligence

What is absent from both conversations is a foundation model that understands geometry at its intrinsic level. Not as a parametric model to be scripted. Not as a mesh to be simulated. But as a continuous, high-dimensional object with embedded physical meaning, manufacturing constraints, and design intent.

This is what I mean by design-native intelligence: models that have learned, from the geometry itself, what defines a vessel, what distinguishes a fast hull from an efficient one, what makes a design manufacturable, and what the space of possible designs looks like beyond what any parametric model could enumerate.

Such a model does not start from parameters and generate shapes. It starts from shapes and understands parameters. It does not accelerate simulation. It precedes simulation by generating designs worth simulating. It does not script CAD. It operates in a geometric representation that is richer than anything CAD was built to express.

Why design generation is more fundamental than simulation acceleration

The argument is simple and, I believe, difficult to refute.

Every physics model, every surrogate, every neural solver still requires a geometry as input. Someone has to decide what to simulate. In automotive, that decision is constrained by morphological variation of existing platforms. In aerospace, it is constrained by parametric CAD models with hundreds of design variables but a fixed topological structure. In maritime, it is constrained by a legacy library of parent hulls that have been incrementally modified for decades.

The design space that physics models explore is bounded by the design space that humans have already imagined.

If a foundation model for physics is trained on parametric variations of 250 cars, it cannot discover the 251st fundamentally different concept. If a neural CFD surrogate is trained on four geometric parameters of a wing, it cannot suggest a fifth parameter that would improve performance. The evaluation is fast, but the imagination is fixed.

Foundation models for design generation invert this relationship. They learn the full distribution of feasible geometries across an entire design domain, not from parametric sweeps, but from the raw geometric data itself. They can then sample, interpolate, extrapolate, and optimise in a continuous latent space that represents design intent rather than design parameters.

This means the design space is no longer bounded by what a human engineer thought to parameterise. It is bounded by what the geometry of the domain allows.

At Compute Maritime, this is the problem we set out to solve. #NeuralShipper's Large Geometric Foundation Model is trained on over 100,000 ship hull designs spanning virtually every vessel type, shape, and category. It does not learn from parametric variations of a few parent hulls. It learns the full geometric distribution of what a ship can be. When it generates a design, it outputs a NURBS surface, not a mesh, not a point cloud, not a voxel grid. A continuous, smooth, CAD-ready representation that preserves the surface quality required for reliable hydrodynamic analysis and manufacturing.

The result is that an engineer can specify constraints, displacement, beam, speed requirements, stability targets, and receive thousands of feasible hull concepts in minutes. Not parametric tweaks of a known design. Novel geometries that the model has synthesised from its understanding of the design domain.

The hierarchy that matters

After two days at CDFAM, my conviction is stronger than before: the engineering AI stack needs to be built from the design layer up, not from the simulation layer down.

The hierarchy looks like this:

• Design generation produces the geometries.

• Physics evaluation assesses their performance. 

• Agentic workflows orchestrate the iteration loop. 

• CAD integration delivers the output to engineers.

Today, most investment and attention flows to layers two, three, and four. Layer one, the generative design foundation, remains the least explored and the most impactful.

Better simulation of the wrong geometry is still the wrong geometry. Faster workflows around a narrow design space still produce narrow results. What engineering AI needs is not just speed. It needs imagination, grounded in physics, constrained by manufacturing, and operating at a geometric resolution that no linguistic model can match.

That is the missing layer. And that is what we are building.