
A letter from Marc Jacobs, CTO, nTop
Most AI demos in our industry show a shape appearing from a prompt. That’s only a small part of what’s possible.
I don't say that to dismiss those demos. I watch them too, and some of them are genuinely impressive. A few years ago, describing a part in plain English and getting usable geometry back would have sounded like science fiction. Now people do it over a weekend.
But a 3D model is one step in a long chain that runs from requirements to a signed-off design, and engineers still carry almost every step of that chain by hand. They translate requirements into a system model, choose the parameters, build the geometry, set up the analysis, evaluate the results, and compile the report. They also carry the reasoning that connects those steps: which tool fits, which analysis answers the question, which variants are worth running, and which data should drive the decision.
That connective reasoning is where I think AI belongs. An agent that only produces a shape speeds up one step. An agent that can reason across the whole chain, from requirements to recommendation, changes how fast a team gets from an idea to a decision it can defend.
Agents reason, code computes, humans decide
Inside nTop, we keep coming back to one line to describe how this should work: agents reason, code computes, and humans decide. The first part is much bigger than it sounds, because reasoning covers far more than making some geometry.
Agents reason. An AI agent is good at the questions that connect one engineering step to the next. What should be parameterized? Which analysis answers this question, and at what fidelity? Is a quick screening pass enough, or does this need a detailed solver? Which variants are worth running? Does this result mean we're done, or should we loop again? Who needs to weigh in?
Code computes. Language models are probabilistic, and engineering results can't be. So once the agent has made those calls, it doesn't do the math itself. It drives deterministic tools that engineers already trust. Geometry comes from robust parametric models that produce the same shape from the same inputs every time. Analysis runs on the team's own proven solvers. Where it makes sense, the agent can build a surrogate model to speed up a search, trained on and checked against those same solvers. Keeping the computation in established tools means the same inputs give the same outputs, and anyone can inspect how an answer was reached.
Almost by accident, the technology we've spent the last decade building turned out to be extraordinarily adept at this. In nTop, geometry is defined as code, and notebooks interleave that code with text, so the engineering intent sits right next to the logic. The models also stay fast and robust under sweeping changes. Those are the properties an agent needs from the tools it drives.
Humans decide. The engineer frames the problem, defines what good looks like, and makes the call. The agent's job is to bring back the evidence and a recommendation. The engineer's job is to judge whether that evidence holds up.
If this sounds familiar, it's because software development has gone through the same shift. Many software teams now hand a large share of their coding to agents and agent teams. Nobody ships that code on faith, though. Skilled developers collaborate extensively with their agent teams on requirements, options, guardrails, goals, and plans before their agent teams start implementation. Agents work within well-defined and iteratively hardened guardrails, like automated tests and adversarial reviews, and a developer makes the call whether the change meets the risk, strategy, and aesthetic goals of the organization before it merges. The agent does the reasoning and the writing, the tests do the checking, and a person approves. Physical engineering is heading down the same path, and the same division of labor is what will make it trustworthy.
What that looks like, start to finish
Here's a concrete version. An engineer has an idea for an aircraft concept. It might be a written description, a mesh from an earlier study, or a photograph or a sketch on a napkin. From any of those, an agent builds a static implicit model in nTop. That's one design point, with no parameters yet.
Next, the engineer asks the agent to turn that one design into a design space and optimize the parameterization. Not the parameters yet, the parameterization. This step matters more than any other, because it decides what the rest of the study can explore and find. The agent works out which parameters to expose and how they relate, so the wing, the fuselage, and the payload can change in the ways that matter for the mission. A poorly parameterized model covers a small corner of the possibilities. A well-parameterized one can represent thousands of viable designs. That's how a napkin sketch becomes something you can actually search.
Then the engineer asks the question that matters: which design in this space best meets the requirements? The agent reasons about what physics it needs. It also reasons about how to run the study: which parameters to vary, how to sample the space, and where to refine as results come in. For the physics, that might be a fast, low-fidelity pass to screen the whole space, followed by a higher-fidelity solver on the most promising candidates. It connects those solvers, the same ones the team already relies on, to the workflow and runs the variants in parallel on whatever compute is available.
When the results come back, the agent reads them, compiles a report, lays out the tradeoffs, and recommends a design. If the results suggest the question was framed wrong, it proposes another loop or checks with the engineer before going further.
None of this is science fiction, and that's the part that still knocks me off my chair. Every piece of it has already been done at nTop: models built from text, meshes, and images, agents setting up and optimizing parameterizations, and distributed trade studies at scale. In one study, we ran 12,000 aerodynamic simulations across 2,400 geometric variants in 36 hours. What's new is connecting the pieces, so an engineer can go from an idea to a defensible decision quickly and with confidence. nTop has already helped engineering programs compress their design loops from quarters or months to weeks or days. With agentic nTop, we’re now addressing more of the engineering workflow on either side of the nTop design loop and helping compress them further to hours and minutes.
Studies like this have always been possible, and we've helped customers run them for years. When agents take on the reasoning between steps, the speed at which they can be conducted increases dramatically. Studies that weren't worth setting up become routine, and far more of the engineers on a team can ask questions of the design space directly.
Where this is going
What I've described so far is one engineer working one problem. The bigger opportunity is a whole team, each engineer working with their own agent team, on a shared design at the same time – versioned, branching, and collaboratively multiplayer by default.
Software gives us a model for this too. Developers don't pass files back and forth. They work on branches of a shared codebase, every change runs its own checks, and the team merges the best work back into the main line. Trade studies can work the same way. An engineer creates branches of a design to compare three approaches, agents run the analysis on each one, and the chief engineer promotes the winner. Nobody has to wait for anyone else to get started.
The harder part is that a change in an engineering design rarely stays in one place. Move one component and it can touch structures, thermal, wiring, and weight, each owned by a different engineer. Parametric models handle part of this by updating the geometry downstream. They can’t tell you whether the change is acceptable or who needs to approve it. That knowledge lives in people’s heads, and tracking it down can take longer than the engineering itself.
Here's a story that has stuck with me. Earlier this year I met a junior engineer at a conference who works on wiring harnesses. He described a requirement to add one more wire to a bundle. The bigger bundle needed a bigger hole in a bulkhead. The bigger hole meant moving a box mounted next to it, and moving that box affected several other systems. He didn't know who owned those decisions or how to get them made.
In the system we're working toward, an agent traces the impact of that change. If nothing downstream is affected, the change goes ahead. If something is, the agent proposes a trade study and asks the chief engineer whether to run it. The study comes back showing what the impact of the change is. The change request becomes a negotiation backed by evidence, checked against the requirements and constraints. The chief engineer decides, and the engineer who asked is unblocked, possibly within a day.
Making that work takes more than a capable LLM or a fast geometry tool. The agent in that story has to know how the systems connect, who owns each decision, which tools to run, and how this team does trade studies. So engineers need one place to work with agents, connected to the LLM of their choice, to the tools they already use, to their organization's engineering knowledge, and to the skills that capture how their team does things.
To be clear, this is a vision rather than a roadmap. We're building toward it, and we'll show progress as each piece becomes committed.
The loop runs through the real world
Everything I’ve described so far, whether it’s one engineer or a whole team, happens on a screen. But no design is finished until it’s been built and tested, and what you learn from testing has to flow back into the loop.
We had an experience recently that shows why. We asked an AI agent to design and optimize a jet engine, and along the way it derived an equation for the engine's performance. We sent it to our friends at a leading aerospace company, and they recognized it right away, because it was the same equation they use. The difference was in the coefficients. They had tuned theirs over time by running real engines on a test stand and fitting the model to the data.
That’s how we’ve come to think about AI in engineering. Agents can reason their way to the equations and the right analysis. Test data is what makes the model accurate. So the loop has to include the physical world. At the right moment, the agent should be able to say that simulation has done what it can, recommend building a scale model, and propose the test plan – fire it up on the test bench, place it in the wind tunnel, fly or float it out in the elements. When the test data comes back, it tunes the coefficients for the next round.
Keeping pace
The frontier models are improving faster than any technology I've worked with. Things that seemed out of reach six months ago are routine now, and I expect the next six months to look the same. So we're rewiring how we work at nTop, starting in R&D. We already ship a release every two weeks. The goal now is for more of those releases to improve how you work and take bigger leaps toward our mission: to compress the journey from idea to finished product. You’ll hear from us often as we learn and build.
If you're working out where AI fits in your own engineering process, we'd like to talk. We're especially interested in problems where you need to explore a large design space, run the analysis your team trusts, and get to a decision you can defend.
Talk to our team
Message sent. We will get back to you soon.
Marc Jacobs Chief Technology Officer, nTop


