0:14 Good morning, everyone. So, my name is Laurence. I actually started life as an academic. So, before this, I was doing research in the aerospace computational design lab in America over at MIT. And I left MIT because there was a huge gap between the methods we were developing there for doing generative engineering and what people were actually using in the design process in industry that we saw. And things have improved since then because CDFAM exists is for one.

0:43 So, I left because we wanted to make this thing essentially bring the barrier of entry for doing this right down. So, 2 and 1/2 years ago, we founded generative engineering and I became a product person to try and solve what we saw as the actual bottleneck to this. I want to talk to you today about what it looks like when you can actually do generative approaches in the design process and the bottleneck that we’ve actually seen to getting there and how we’re trying to solve them.

1:07 So, what you get if you do this is the ability to make data-driven decision making. And increasingly, this is enabled by engineering AI, which we’re seeing a lot in this talk. And the most important thing we want to talk about today is that for this to be actually useful, we think that AI have to evolve iteratively in the design process because engineering is fundamentally iterative. So, we have three parts, unsurprisingly.

1:29 And the first part I’ll be walking through in the platform that we’ve built to bring this into the design process using a few little IP sample pipeline examples. The first one is thematic in robotics. So, in this case we’re actually designing a quadruped and we’re trying to co-design the hardware and the software. So, this was designed in a CAD package that Onshape and we’re trying to answer as an engineer what sort of motors we’re going to need for the legs and the hips to make it perform well, make it more manufacturable and lightweight and everything else.

2:00 What we do in our platform is connect up the cat room pre to an automated workflow into the simulation. When this case the simulation is actually a full reinforcement training loop using the Doco of the gates. So to explain this, I’m going to pretend to be Joel, who is the computational engineer expert on this project. And so here he’s explaining how in our platform, once you set up the automated workflow, which I’ll explain a bit more about later, it’s very easy to go set up and the types of experiments that you can run computationally with all the generation and simulation happening in the background.

2:30 So here we’re setting constraints on the model of the car motor torque and velocity to try and answer questions about what that looks like. I want to be running experiments. Every single design here is a column and we pull out automatically the full geometry data, animation of the the gates, the bank rate of a as it’s walking and key numeric parameters like the motor torque and the velocity and the range, cuz the range is sort of the measure of performance.

2:54 And then we put everything in a 3D design space. So here each design is a separate each point is a separate design. And we go through and inspect in detail each one. And we have access to all that same data. But here we can very quickly inspect the results of doing this optimization. So on the right we can see in the blue box the constraint we were heading towards.

3:13 So on half torque it was actually quite an aggressive constraint and we ended up with a robot that was sort of stumbling cuz the legs ended up being too short. But using this we can very quickly answer those questions. And we’re going to skip forward a little bit. Then this is, you know, this is part of the Equator platform. So the first optimization we ran, we answered the question about the constraint on the motors.

3:35 We rerun and we get a we expand the box and we get a a longer range. So this is what we mean by data driven decision making. This is not trying to find one single optimal design. This is getting the ability to generate all the data to actually understand the problem you have the ability to do this automated workflow. So, the optimal design according to the experiment is in yellow if you want to look at it, but we have to do something that’s the most important thing.

3:59 Another really interesting case study I want to share quickly is a bioreactor. But this is a company working on a new cell manufacturing process. So, if you want to call the design space here, you have to be doing CFD because you need to have a minimal shear rate within the tank to not to let the cell not die. But you need to optimize for efficiency and make sure that you can manufacture the thing.

4:16 So the problem is if you’re a new company going to do this, setting up that sort of workflow, being able to run automated CFD in the first place is a massively time constraint. So, you need to like do it really quickly so as to make decisions here. So, instead of simulation of the gate and of the walking, we have full CFD. I want to highlight this because this requires us to run in parallel in the cloud lots of different CFD simulations.

4:39 Many of these take an hour. But you get it in the same platform and it grades and it’s a part of the design process. I could continue to talk about this but I’ll point you to our website where there’s a list of the case studies where we show how the platform is iterative. Everything is rigorously version controlled and traceable because if you’re trying to do this in product engineering design, that’s really important.

4:58 But today we want to show you how the bottom neck of getting to this state that we’ve actually seen and working across the industries is an empty, you know, automated workflow that like sets things up in the first place. So, we want to show you today how we’re using engineering AI to bring that barrier right down so you can do this sort of thing in industry that it’s sort of haven’t been applicable in before.

5:21 And the example I want to use is a quite a simple one. So, this is a pedal but in this case it’s a collaboration between a computational designer who’s producing a grasshopper script to generate lots of different pedals. And an industrial designer who’s going to make sure that the design language of this is high-end. And here I’m scrolling up through the results of doing an optimization to minimize the mass subject to a stress constraint.

5:39 And then as usual we put all of this in our free design space and we can see all the different experiments we run and iterate through. But this is the type of thing that would get the awards. So, if we put this of the design process here, and we want to ask the author in a conversation with the industrial designer and the engineer, where do you reckon it’s going to go in?

5:57 We want to be able to simulate crazy designs as well as these more simple ones, but much quicker than we can today. So what’s actually required to get this? Obviously, you’ve got to generate geometry, and you’ve got to simulate it. And we’ve had many, many talks about how you can speed up some of these things. But the hard part is actually the rest of it. So if you’re trying to get through this sort of workflow and automate it on a brand new problem, you have to first figure out the rest of those steps.

6:20 You’ve got to parameterize it, and we all know Grasshopper and so it’s really powerful. You can use many different tools for this in order to be able to get the geometry. But then to simulate, you’ve got to defeat the You’ve got to set boundary conditions, mesh it, configure the simulation in the proper way, run the simulation, hopefully in the cloud and faster, and post-process. So if we want to try and bring the barriers to getting through this down, we have to accelerate this entire pipeline.

6:44 So there are some obvious candidates, and we’ve heard a lot about simulation and generation. But we actually have experienced them not being the real bottleneck. Like if you’ve got to the point where you can run a single simulation, you’ve done the majority of the work. Like SimScale talked about this quite a lot. Like the simulation lead time is not the bottleneck. It’s actually the bottleneck. Three months of that and then running a fast physics model, maybe it’s in the wrong place.

7:04 So we’re looking at the rest of this. So we’re looking at it by using engineering AI. And we want to tell you like you’ll probably get everyone else because we’re a software provider. We produce agents. Agents are really powerful. And here what we’re going to show is our generative agents running the platform. There we go. They’re driving the platform as if it was a human. So it is looking through the results of doing a parallel optimization, the first one that we did, and it’s trying to find interesting things to look at.

7:34 So this is basically off-the-shelf using what AI is already really good at, summarizing information, using using visual language models together to say, “Hey, go look at my design.” Populate it straight away. Go pick it out. This is something useful to look at. And then go through and look through everything else for you cuz lots of thoughts and find this one. So, once this gets the end, it’s sort of going to say, “I’ve been through all the geometries, looked at them all, and there’s a particular one that’s giving quite a weird behavior.” And if you’re doing this manually, like you probably will get there, but then you’re immediately going to say, “Hey, what’s going on there?” and the issue is not that the simulation blew over or that the geometry didn’t generate.

8:10 The geometry was fine. But, like it would have happened if you used CAD or implicit or whatever. What happened is the parameterization on the issue have gave rise to quite a questionable data. So, the struts of the pedal didn’t even connect to the outer body even though you sort of wanted them to and then you got a really thin top and bottom surface. So, if you actually try to say, “Hey, complex model, go generate something like a pedal.” It’s harder than you think.

8:32 So, this sort of information coming out really usefully to do the post-processing automatically and the parameterizations to help you along with it, we find incredibly valuable. Both of have the problems we’ve looked at. Just to highlight this again, it’s just saying, “Hey, go look at that new parameterization.” And it is instantly a way that you can use AI when you have a platform and an agent combining to be useful stuff to accelerate that whole pipeline.

8:54 But, this is the grasshopper model. So, I said the pedal was a simple example. This is half of the screen. So, if you’re trying to go back and say, “I need to iterate on this to produce a better parameterization. But, I need to explore different designs.” Essentially, only the person who made this model can do that. Like even with the help of you know, Fraven, which is super exciting, another AI, at the moment this is sort of a bottleneck.

9:14 And what we see is that because of this, the sort of workflows you end up with in generative engineering end up monolithic. So, one person can do the generation and the simulation and post-processing, and then they become a bottleneck. So, you sort of get the fall-in-one sort of direction that the people are heading in. And we think this is not quite the right approach when you want to scale this to be part of the design process for a whole team, which is what we’re trying to do.

9:38 So these are the parts of things. And not only that, most of the crying you want to make a design thing, but you learn, hey, the paddle design of it was like the strategy of this will be like this, but the design the industrial designer comes along with a new idea, but in this format we have a sketch. The designer gives off a render, or we’re in a design review.

9:57 I’m sure many of you have seen a screen like this, but you’re looking at the CAD, and you’re just drawing it directly. So ideally these are the changes you want to make, not slightly tweak the graphical model a little bit. This is why the title of the talk is beyond parametric, because we think that to get these automated workflows to be actually useful in the majority of engineering problems, we’ve got to follow this.

10:17 It’s a challenge. So we’re going to apply engineering AI again, but I just want to want to introduce the framing that we use that will help us like figure out what we want to do here. So any automation that we do, whether that’s a parametric graphical model or physical AI’s, we have some kind of time, because we’ve got to get training data, or someone who’s an expert at what this is and then or we have to build an agent that understands our platform.

10:38 There is some kind of time. And what we hope is that at the end of that, we’re going to explore some design space automatically. That’s what I showed you in the beginning. This is the power. This is what we want to get to. But to do that, you have to predict the future. You have to start this saying, where is the design going to go? What sort of pedals am I going to need?

10:53 And what sort of pedals are going to be in my design process by the time that we’re done? And if that’s true, I can explore within them, and awesome. And this is, you know, in some cases this is applicable. Like if you’re designing a heat exchanger, and like the next iteration on it, you sort of know what that’s going to look like. But in this case, we just don’t.

11:09 And in many problems, especially if they’re new problems, frontier engineering problems, it’s hard to predict the future. So all the other ideas that you didn’t think of actually end up outside the scope of what you can run an automated simulation on. So with our style, and you take the graphical person, hey, can I explore this pedal over here? They say, no. Maybe you can do it faster now, but it’s still a massive challenge.

11:29 So one approach to fulfilling this would be can we make the circle bigger? Can we make a foundational model like we’ve just seen Beyond Math approaching and you know, that could be promising. But we think it’s more important to get the setup right lower. So to get this into a real design problem that you can use this to make decisions in time, reduce the setup time. And then importantly, because like I said at the beginning, once you have set it up and used it, you learn something, you’re going to iterate.

11:55 So you have to be able to adjust this and make new design spaces that could be quite small. But this has to be iterative as we go along. So this is the challenge. This is what we’re trying to approach and how we’re trying to speed it up with engineering AI. So the final piece of work is for the bold and the brave. So this is what we’re trying to do.

12:12 How do we get to something that can run that entire pipeline to generate data to make decisions that is fit for the new world there. So we observe this and I think this is important that they enable the the thing we’re saying, which is that this whole pipeline have to be automated, but the rate at which we want to change the geometry and the design is much faster in almost all cases for the simulation.

12:34 Every single pedal we generate, we know we want to minimize mass, we want to measure the stress and the displacement under impact and we care about the manufacturing costs and we’re going to look at it with an industrial designer and play with this by design language. So we look at this, we split apart the pipeline. So setting up the simulation and the post-processing and the configuring of the problem, we want this to be done by a human.

12:53 That human will should be assisted by AI agents like we saw with SimFA earlier, but if you want to make design decisions with this, there ultimately have to be someone accountable and we don’t think AI yet is at the point where it can do this autonomously and we can’t put this in front of engineers and they say, “I don’t trust AI.” which we think is valid. So let a human set this up once for that particular problem and focus all of our attention here.

13:13 Specifically on the things that nobody wants to do, which is defuturing, boundary conditions and then measure. So the engineers want to be generating ideas and geometry and parameterizing. What does this look like? So, back in the platform here, I’ve uploaded a step file. So, this is just like a single pedal example. So, what happens when you do this? Because one thing I didn’t mention is we connect up with the geometry tools that the designer is already trying to use.

13:40 So, I made a drop off of a with a lot uploaded in here, but step file and then we plug in the VR as well. So, this is a new Grasshopper script. So, we upload this and then start running in the cloud, which is what we do. And it pulls out the inputs. And then you select from an analysis that has been set up. So, that’s not being automatically.

13:56 That’s being set up by the expert because we know we’re going to run ship analysis. But what does happen automatically is this feature detection and feature removal. And then back in the back end we upload the boundary conditions. What’s going on here isn’t the agent doing it. The agent operates like a human. Like it’s writing automations using deterministic geometric processing to apply the pedals. So, there’s no AI in the loop.

14:21 The agent got offline. That’s the right logic that goes in between. And because we started with a Grasshopper script, we had hundreds of examples of pedals that essentially are test cases for that AI which we used. So, we can we can automate this. Now, the next step, like I said, is boundary conditions. This is going to look through the deep feature pedal and try and find what we could we review this before we do it.

14:43 And then it’s going to cycle through all the boundary conditions it needs to find. In this case, two volumes. This is a small assembly, spindle and pedal, and then contact surfaces between them and where we need to apply the load. But it does that again by using the deterministic logic that uses a geometry library underneath and pulls what we set up. What we can do here is we see that it actually made a mistake.

15:01 So, the spindle fixed point shouldn’t have been put in the vertical face. And I’ve been a few times today. But you have to review exactly what an engineering AI does. It’s super important. Like no one likes a black box. And what’s important about these steps is that they can be visual visually tested. Like you can see whether it’s actually found the right faces if you You what you’re looking for.

15:20 And designers, even if you’re not a simulation expert, can do that. What we do with this is we say, “Okay, this is now a correction we gave. We reviewed it.” So, there’s basically human and AI collaborating. And we think it’s really important to build this into any product that you’re doing that uses AI at all. But this isn’t perfect. It made a mistake. It didn’t nail this first time cuz this was a new block of the script.

15:42 And that’s because, as we put a little bit in there already, AI isn’t really great at doing that kind of reasoning yet. Like, they can be really good at processing language and semantic reasoning and this sort of thing, but in geometry they they struggle a little bit. But at the same time, you will see in the news AI can do AI is able to do solely end-to-end autonomous computer chip design and solve new math problems and or code helps us write a lot of this software.

16:06 So, we have this sort of dichotomy between this not quite working and incredibly hard problems. And the gap that we see is that the verifiable environment on the key. So, if you have an AI agents, even if it’s not necessarily super good at doing that kind of reasoning, if you can give it a problem where it knows the answer and can iterate until it finds that answer, then you can solve really complex engineering problems.

16:26 So, this is what we take advantage of. So, what you have that I’ve just shown you is a way of generating data that it simulates correctly. And when it goes wrong, you correct it, you generate another test case. That becomes part of a continuously growing set of cases that becomes the verifiable environment the verifiable environment that the agent worked within to try and write the simulation correctly.

16:46 And again, that’s all offline. And then once it goes online, it’s deterministic and you can be completely flexible. So, it would be completely transparent if you gave it this new geometry on the left and said, “Find me the replacement clip for this puddle.” It actually completely misses where the spindle and the puddle are meant to connect. It does it at the back surface. If you give it one example, it gets a little bit better.

17:07 But then if you give it all the examples we’ve shown so far, it produces something correct. So, this is going to continuously evolve as we go through the design process. So, this for us is the key. Like, we’re applying engineering AI in this way that it produces something that doesn’t make sense, and in a way that it evolves as you give it new designs, because you can always review it and correct it with a growing set of verifiable examples.

17:26 And so, we think this is really promising for getting the barrier of entry for generating the data that we showed at the beginning right now. But to finish, I want to show you what happens if you apply the same thinking to one of the steps we mentioned earlier that didn’t look at, which is generation. We’ve just seen in quite a few people actually that like simulating is great, but you want to be able to go back to the design.

17:49 And the way we approach this is saying, “Well, what we said earlier was like the ultimate design language for engineers, which is sketching and annotating. What if we can use all this information we’ve stored in the platform to go straight from annotation to geometry?” so, this is a little bit more experimental everything I’ve shown you so far is still working on the platform as and is fully working.

18:06 But this is something we’re doing right now, but wanted to show you a little bit. So, if we go back to the platform this time and we upload a new geometry, and then this time rather than giving it a whole new file, we see what sort of simulation we want to run, and then we select annotation mode. Here, we just draw directly on it. So, we say, “This is where I want to add material.” and in a in a second, we’ll show you see where you want to remove material, because this is like naturally how you would expect it if you’re working with industrial designers think about this.

18:36 You say, “Add over here, maybe remove over here.” And then because image processing has got really good in the past year or two, it can actually understand semantics. Going from an annotation to a render of what the pedal would look like is actually quite straightforward. So, we do this first, and we say, “Given all the pedal examples you have, it should look like this.” And then this is obviously sped up, but we run a diffusion model to say, “This This is what it should look like.” And the diffusion model is incredibly viable, so you can use all the examples we’ve thought of the pedals already simulated to get something that can go here.

19:09 And so, this is not a beer up ads. It’s actually just a mesh. But the problem we’ve solved is we want to go from something to simulation with so you can use really powerful remeshes but I can get it for you to simulate and we don’t need to end up with a beer up ads. The question I’ll bring here is what is this going to behave like because of the new design direction we want to get the bags and answer really quickly so we can include this in exactly the same data driven design process that we’ve enabled for parametric models.

19:34 But a lot of time I will discuss this if you want to find out afterwards because we think this is really interesting and this is all context. Thank you for listening. To learn more about the CD fan computational design symposium, access the archive of previous presentations, interviews with speakers, and information about future events around the world, visit CDFAM.com. Yeah.