0:02 Good morning everyone. I am Lawrence and I’m here with Petrice. We are product people at generative engineering. But I originally started life as an academic. I was doing aerospace computational design research at MIT. But like yesterday from New Balance realized that no matter how good the methods were or the algorithms were that we were working on, they weren’t being used by engineers working on hard problems. So we set up a company three or four years ago to try and fix this and became essentially much more interested in how we bring these tools to real engineers.

0:34 Recorded at the CDFM computational design symposium in Tokyo October 2026. Learn more at CDFAM.com. So as products people, it is essentially our job to imagine a future for engineers that is more interesting, more powerful, and more useful and then to try and build tools for them in that future. And we’re essentially entering a new era of what kind of tools we can build with the advent of AI and agents and the things we’ve seen over the past few years.

1:08 So today we’re going to share a little bit of the future that we’ve built for that. To look forwards, it’s useful to go backwards first. It is a little bit cliche to show a picture like this now, but we use this for inspiration on what I’m going to show. So, I think it’s important. But this is a room of engineers designing on a drafting table where they can collaborate because they use the exact same language as each other.

1:30 Pen and paper, drawing marks, making annotations, and they’re all looking at a different view, a different part of the same system, and they iterate manually when new information comes in or they need to make a change. And we all know CAD digitized the drafting of these geometries with powerful computing and now being able to model in 3D. A single engineer could do the work of essentially a whole team because now you could rotate the part.

1:56 You could work on a part that’s part of an assembly. But you were still responsible as an engineer for every single detail yourself and it would have to be created manually essentially. So we’re now in this new quite exciting era. And you probably felt, especially over the past few months, if you’re like me, that we’re reaching this point where agents can drive this geometry creation exercise. So, some examples here.

2:20 So, OpenAI’s release of Astra had a gearbox. The top right one is us. But there’s other like really interesting examples now coming out, which means we sort of get to rethink this entire thing again. The most interesting thing I’ve heard to describe this and what’s happening is if we think of the industrial era as humans figuring out how to harness energy for work mainly through a steam engine and the computing era with software of us figuring out how to harness compute.

2:47 We’re now figuring out how to harness intelligence for work. Particular type of intelligence with LLMs, but it’s still something intelligent. But this harnessing exercise is sort of being pointed in many different directions right now and is a hard thing to figure out. So we’re product people. We ask this question. So what kind of tools are needed for humans and agents to collaborate in this new era of AI powered engineering?

3:10 And specifically because we’re working on computational design and computational tools for engineers. How can we build tools that enable two really important paradigms for computational design? So we talk a lot at this conference about rapid expiration and how physics AI implicit geometry optimization algorithms parametric modeling all of this stuff faster simulation lets us do really rapid exploration. We’re going to spend most of the talk on this but it always has to be complemented by rigorous experiment.

3:38 And so we see a place for both and if we’re building tools for this future we have to be able to support collaboration on both of these things. So if we ask the question of how do you do this harnessing exercise of this intelligence to enable rapid exploration on top of all the capabilities that we’ve built already and that us as a company have been building a platform for for years.

3:58 The first thing you might think is, well, let’s put this AI, which is essentially like a really fast, really capable robot colleague, in front of the same tools that we use. And you essentially then end up with either an MCP server that you drive from claude code or like a chatbot into your traditional package and it sort of drives the the CAD or the simulation for you.

4:20 But if you think back to the worktop and how you might collaborate with humans, this is essentially like putting that powerful robot colleague in front of your computer whilst you step back and try and explain what you want in 3D with words. And if you want them to do a different direction, you push them out the way. They sit and wait and you have to take over and do it yourself.

4:37 So for us, that doesn’t seem like the kind of future we should be building or and it means we haven’t built the right tools to enable the collaboration that we should. So instead of digitizing just the pen and paper, we are digitizing the entire worktop where there’s a fleet of people, multiple different agents, all working with the same language, but which can collaborate much more effectively. So today we want to show you this shared space where both humans and multiple different ages can explore collaboratively for this rapid exploration.

5:10 And to make this concrete, I’m going to pass over to Betrice, who works daily with engineers on problems across a wide variety of industries using this sort of approach to do this rapid exploration. Good morning everyone. Ohio, that’s me flexing my little Japanese. Okay. So, kind of picking up what Lawrence has been talking about, we built what we call this worktop. And the worktop is our attempt to basically make agentic interaction more human.

And we’ve been lucky enough to actually be able to use the worktop with some of our clients and this is what we’re going to actually show you today. So, I’m going to start with Alarus. Just for a little bit of context, Alarus is a Denver-based startup. They’re focusing on lunar infrastructure mainly on robotics and we actually worked with them to create Scout which is a very aptly and cutely named surface mobility rover to basically explore the lunar surface and there are two elements here that we had to really take into account in terms of actually making sure we could find an app geometry for them.

6:26 One is that they wanted to maximize freight height, meaning the space between the surface and the underbelly of the rover just to make sure that it wouldn’t get clipped or ruined by any harsh surfaces. And then also that this rover has two states. So one when it’s actually deployed and exploring the moon and the other stowed when it’s being transported with the lander. So these were elements that we had to consider and so we are now going to actually move to how this looks like in the workshop.

7:00 So this is actually everything the worktop created. We’re going to go through it in quite a bit of detail, but we’re going to actually just rewind all the way back first to how we started which was just giving it a very simple prompt. No geometry examples whatsoever. Just asking it create a lunar rover geometry model that would then be able to survive the mujuko simulation of lunar terrain.

7:25 And so when we did that the agent actually started to create some very simple geometries. And one of the most important things to note here is that when you see this you might say okay these are just like simple shapes it’s dumb geometry. No, these are parametric models. And that’s really really important because it actually then allows the worktop to continue developing and iterating and moving quite fast into something that you would expect looks a little bit more like a lunar rover.

7:57 In this case, you’re able to actually then look at all these tiles of different iterations and if you see a geometry that is interesting, you can select it. You can interact with it, you can clip it. You can actually just start investigating a little bit more. Select any of the bodies that you’re interested. Basically, the basic types of interactions that you would expect from a CAT system.

8:21 Here, for example, we’re actually drawing on this hinge mechanism and asking it to investigate a little bit further. So what you see here is that we start actually building a really clear repository of conversations, requirement changes with the agent and yourself. And I wanted to pause here specifically and use the laser cuz I’ve always wanted to use one of these to actually show you this which is the mini map.

8:49 Specifically this is actually how you interact with the worktop. We wanted to make it really playful, a little bit of an ode to like video games if there’s gamers in the room. But specifically because the blue boxes indicate anything that the human produced. So those are the human tiles on the worktop and the gray ones are what the agent produced. So literally your results, your decisions are on equal playing ground.

9:14 This is like working with a colleague. Another thing that the agent can do is actually select a geometry and say hey this is actually not robust enough for simulation. It identified a gap between the body and the leg and it calls it out and specifically creates what we call a check or a rule. So it starts identifying what geometry isn’t robust enough. It accepts it and it starts building a repository to understand later on what are the things that will actually pass simulation or not.

9:46 Again, we want to give the worktop the space to go into like really exploratory design, but we always want to bring it back into making sure that these are things that will survive simulation because if not, you can go completely on another tangent and then never be able to pull it back. We want to make sure that this will be useful. In terms of visualizations, you can also push the agent to actually just start experimenting.

10:10 So here we literally asked it, okay, start working on some of the different stowing mechanisms, be a little bit playful, look on the different sizes of the body. It’ll also start actually post-processing some visualizations on how it actually acts on lunar terrain. And you might say, okay, this is just a lot a lot of information. But that’s actually how we found it to be most useful. You want to actually let it, especially in conceptual design, give you as much information as possible within those guardrails.

10:40 Talking about guardrails, obviously one of the most important things and principles we want to highlight across all of this is that we want to make sure that the agent has full space to explore the design. But in terms of how that design is judged, that always goes back to the human. We’ve heard in different talks, the human in the loop. What does that mean? We know that for rapid iteration simulation needs to be set up by a human.

11:05 The lunar conditions that it needs to abide by are very strict. What actual good design looks like that is all based on intellect coming from the human interacting with the agent and then you give it full space. But however that design is judged goes back to the principles that you set it with. Okay. So because we’ve gone through a lot of things especially in concept design, we wanted to highlight three main kind of UX properties in the worktop.

One being just quite simply you have all these tiles in the worktop. You want to be able to actually select a geometry that is interesting, pull it up, hide everything else, and just make sure that you’re able to concentrate on that one thing without losing any of the context. You should be able to interact with it not just through a chat box preferably even though that’s a very important and useful interaction being able to draw on it actually let’s select certain bodies and then also have a way to quickly review all the iterations so this toolbar that you have on top this geometry toolbar all of these are their individual geometry models they exist as their own models nothing is overlaid on each other nothing is lost and you can always go back to an later geometry and continue experimentation from there.

So we’ve covered concept and now we kind of want to say okay how does the agent work with assemblies where there’s you know a little bit more complexity and here we gave it the prompt to start thinking about the internals of the body so thinking about where to place the PCB where the radiator would actually maximize cooling and also start thinking about how to maximize solar absorption because now we actually have the solar panel right at the top just to make it more powerful but also affects the actual sizing of the robot body in the sense that before we were only considering freight height now it actually becomes more stable there’s other elements so again this idea of iterating and continuing to build on the requirements so it goes back to the ageel question cool these are all cool geometries but how do we know that this is a good design how do we know that this will survive simulation and we go back to the checks.

13:26 So these are literal X’s and ticks in terms of the agent calling out a certain geometry that just will not pass. So in this example it’s going into a stowed version of the lunar rover. It’s actually come up with something that’s quite interesting. What if the wheels actually went in underneath it? But it immediately assessed actually the wheels are overlapping with each other so that’s not going to pass.

13:53 So this idea of actually being able to again build a repository, understand from each other’s mistakes, very much how you work with your colleagues. You try things, things fail, but instead of actually then repeating your mistakes or having to documenting them manually, everything just becomes something that the agent can learn from. Here’s the experiment rig. I won’t go too much into detail cuz I’m actually going to cover it a little bit later.

14:17 So the experiment rig basically holds all the information in terms of what you set for a certain experiment, what the experiment wants to find, what it’s actually looking at and if it’s actually diverted from the things that you’ve set it and also what is coming up next. So it gives you a good understanding of where it’s actually thinking and you can deviate it. Here we actually clicked on one of the experiments.

14:42 We can actually see one of the runs that has concluded. And again, it gives you a good ability to then start pulling in. Okay, this is an interesting geometry. Again, base it with more visualizations. Give me an understanding that this is something that we’ll be able to simulate. And as such, we have a few actual examples of the lunar rover actually moving across lunar terrain supported by this idea that okay, we got an assembly, it’s well packaged, and it can actually survive pretty good.

15:11 The Mjugo simulation. Okay, so checks. This is one of the most important things when we add complexity. We want to ground everything back into what is the judgment. Again, going back to what I said, we want to make sure that you’re able to iterate, that you can explore. However, you want to bring it back to something that we know will successfully be able to simulate. So, the checks being you’re able to actually steer it.

15:37 So in the case that it actually doesn’t identify that something went wrong, you can say, “Hey, you actually put the PCB right here in the back. Please learn from this, the designs then are judged mostly by things that it picks up. It gives you the context and then the work gets corrected.” So again, you get these iterations of when it went wrong, how it got corrected. So you have different phasing.

Cool. I’ve gone through concept, gone through assembly. I’m going to quickly go through optimization and how we deal with in the worktop. For this case, the client that we worked on is a bit more data sensitive. So, we’ve obscured some data, made it a little bit more generalized. But what you kind of need to know is that they work on data cooling. They do edge servers and obviously they want to put as many GPUs in it just for higher compute, but they heat up, they throttle, so there’s a cooling limit factor.

16:28 In this case, unlike Alarus, we have a geometry that we start with. Alarus, we had nothing. So this we actually have a heat sink that works. We just want to make sure that we explore how we can make it better. And in this case the UI doesn’t really change. You might expect it changed. We still give it a brief. We just add the geometry. And what it does it actually starts computing makes it into a parametric model and then starts h kicking off certain experiments and actually starts documenting its findings of the experiments.

17:01 So again, you go back to the rig. The rig gives you all the information in terms of the experiments that are running. But also something to note here is that because this is a multi-purpose, you can run many experiments at the same time. It also gives you the ability to make sure that the experiments that are running will be successful in the sense of are the servers up technically is everything set up correctly.

17:24 You can actually make sure that if they’re small experiments that are running beforehand, you know, you can time them accordingly. So in that case we look at an experiment some designs that came out on a plot. You see the parita front and this is where it kind of gets interesting because you can say hey I’m very curious about these points. We want more of these and that automatically hits off another experiment.

17:46 So again something that for us made it a little bit more human made it a little bit easier for you to interact with the visuals that are coming up and continue exploration. Cool. So we’ve gone through concept assembly optimization. And hopefully it was clear and effective in terms of how the worktop has been used in different examples for this rapid exploration, something that allows us to move quickly, iterate, but then always bring it back into something that we have high confidence that we can simulate and we can enter the next phase which Lawrence will be talking about in terms of actually how do we back this all up and go into more rigorous experiment exploration.

18:33 Good morning again. So like B was saying, we think this is really powerful for enabling rapid expiration. And just for a little bit more context, the experiments we were running on the worktop with the heat sink were done using physics AI because that gets you to something much faster. But it’s not actually something that we see right now you making concrete engineering decisions based on. So once you get to this point, you still need to do sort of a final maybe not final but like you still need to do rigorous experiments with simulations that you can trust on designs that you trust to make some decisions.

19:03 So the last bit of the talk we want to focus back on this for a second. So to illustrate this I can open the rover in now the human centered interface where this is a parametric model that we got out of the worktop. And just for comparison we can look at the model that the humans created. So this is the original model made in on shape given to us by the customer.

19:25 Both are available here as resources in the final experiments we want to do. And for context as well we could also have explored other options. This is six wheels with a folding solar panel. But to to show this in more detail let’s go back to the heat sink because to get more information on this we’re not going to run like a physics simulation using mojo code. Is running full CFD in high fidelity with a conjugate heat transfer simulation here in simc scale but could have been anything.

19:50 But what we got from the worktop was the ability to be extremely sure that this geometry model is going to be exploring the area of design space we’re most interested in. We’re focusing in on the input parameters are most promising and that if we see results for we would understand as engineers. And then we run these experiments overnight. And takes hours because it’s, you know, full CFD.

20:12 And we have inputs that we want to vary. And on the right, the outputs that we’re interested in here, the thermal cooling mass of all of the heat system and the max temperature of the two components that we think are going to overheat. And we here see all the algorithm settings and the workflow and the setup of getting to this. And this is all deterministic, which means the agent created something useful, but we now want to sort of make sure that what we get we can always recreate and we know where every single piece of information came from as a human making the decision.

20:40 So once we do this, we then can investigate the results to make some decisions. So here I’m hovering these design points in this 3D space of the temperatures and the mass. And I can compare any of the experiments we did against this same space. This one being a different family of heat sinks to get to the same sort of plot. But this is the one we’re looking at right now.

20:57 And for each of these designs, we have the full geometry, full simulation. And if we hover over any of the points on the right, then we can see exactly what constraints were met and which weren’t. Which designs are on the PTO front. And if we open the plot with the inputs as well, we can see where in that input space those best designs are and where the ones that were failing the constraints are, which are in brown.

21:16 And then because this is a simulation I want to make a decision on, I can also open a plot where we see for all of the designs an automatically post-processed simulation visualization here of the fluid streamlines to make sure that what I’m getting is results that I can use. And if I click on any design in particular and dive into the detail again, I can see not only the streamlines but slices we pulled out of the simulation results and every single numeric parameter that was there residual plots for the convergence again just to make sure that we can actually use this going forwards.

21:48 So this is the rigorous experiment I’m talking about that complements the ability to get to a parametric model that will run with simulation that you have confidence is in the right direction extremely quickly on the worktop. So I am a product person but I’m also a founder. So I have to sell for a second. And we can get to this point of this rigorous experiment in a new customer within a couple of days from nothing using this approach which we think is really exciting because it means that this sort of experimenting is now available and possible in industries and domains that before just would not have had the time or the capability or the expertise to do it which is what we find exciting.

22:27 And to finish, I just want to highlight what this sort of means for the process. Because when we’re working with this on real problems, you essentially end up working in this two-phase paradigm where during the day, you’re doing rapid exploration. You’re looking at the data you generated before. You’re looking at the results, you’re trying to make some decisions, and then you really quickly with colleagues and agents come up with the next sort of design direction to look at so that by the end of the day when you run longer simulations, you are confident you’re going to get the right answer that you will inform the decision.

22:54 And then overnight you run them. It’s longer simulation. If you’re working on a genuinely new problem, the physics AI models you were using during the day won’t give you like exactly the right answer. But if you run overnight and then automatically train the model again to give you something to experiment with the next day faster, you have this useful cycle and you can use these sorts of techniques even in brand new problems.

23:15 And we see this sort of two-phase approach working even as intelligence gets better and better. And so finally, I think, you know, we started this by saying we’re in this new era and we’re in an era where intelligence is sort of increasing exponentially. We’re sort of confronted with what we do as people in engineering and people building tools. And if you believe sort of some of the Silicon Valley LLM hype people, we should be reducing all of our tools to conversations and everything should be driven by a chatbot into into one of their models.

23:45 But we sort of see a different future where the tools themselves improve exponentially with the intelligence. So hopefully it was clear from this talk that we believe the latter one and we’re trying to work with engineers across all different domains to make this reality and to build these sort of tools. So if you believe in this too and want to help work with us, please come and chat. Thank you. Recorded at the CDFAM computational design symposium in Tokyo, October 2026. Learn more at CDFAM.com.