CADENA: Stepwise CAD Reverse Engineering

arXiv:2608.00799 · cs.CV · Submitted 2026-08-01 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "CADENA: Stepwise CAD Reverse Engineering".

Title and authors: Tom: So we're looking at the paper "CADENA: Stepwise CAD Reverse Engineering," and it seems like they’re tackling a real headache in engineering. The core problem they’re pointing to is that most current AI systems generate the entire CAD program in a single pass, meaning they don't check their work as they go.

Jane: That means if the first step is wrong, the whole thing is probably wrong too because it never gets a chance to correct itself later on. The paper introduces CADENA as something that grows the sequence of operations one step at a time and compares what it’s building to the target shape at every stage.

Lu: It sounds like they are moving away from generating a finished program all at once and toward this incremental, iterative approach where the choice of operation depends on what's left to model rather than just the code written so far.

Meng: I'm curious about how practical that is for something like a complex mechanical part. If it’s checking after every step, that sounds computationally expensive, and I worry about how much time it takes to run this process compared to just getting a single pass result in seconds.

Lalam: The paper describes CADENA-Bench as a benchmark they created to measure performance across different categories of mechanical parts, which is important because existing datasets are mostly just simple sketch-extrude shapes or near duplicates.

Tom: Exactly, and the authors are saying that current evaluation methods aren't suited for this kind of reverse engineering task because they score the recovered shape instead of focusing on the actual reconstruction process.

Jane: They’re also introducing a concept where an operation can be applied at any point in the process because nothing about what to do next depends on how far along the program is, only on the geometry you are looking at right now.

Lu: That decoupling of operation choice from code length is a big idea, suggesting that if you condition on the residual—what the target still has that your build doesn't—you can remove both factors and let it be purely a function of geometry.

Title and authors: Meng: If you’re doing that, how do you train this model to make those decisions when it doesn't know exactly what the final program should look like? That seems like a huge gap in the training signal.

Tom: The paper addresses that by using reinforcement learning against executed geometry, where the reward is based on the volumetric intersection between what’s built so far and the target mesh. This is different from just looking at a single final score at the end of everything.

Jane: So it sounds like they are rewarding geometric fidelity step-by-step, which should help with both getting closer to the right shape and keeping that invalid rate down. They mention CADENA-RL reaches a volumetric intersection over one point nine ten, which they say is a good trade-off for reliability.

Lu: That specific result is interesting because the authors note that while CADENA-RL performs well on most parts families, there are exceptions like gears and bearings where other direct fitting methods perform better.

Meng: That exception matters for production because if it fails on critical components like gears, you can't just rely on a general reconstruction model; you need something more specialized for those specific geometries.

Lalam: The paper does point out some limitations they’ve found, specifically that countable features are often approximated instead of counted and that occluded geometry is invisible to the observation.

Tom: They also flag that early frame errors aren't recovered well, which suggests there are still some real-world failures in the step-by-step process they need to work on.

Jane: Overall, it sounds like CADENA is pushing the idea that for reverse engineering complex three dee shapes, you need a model that builds things incrementally and learns from the actual geometric errors along the way <ref:2608.00799#pg1>. This shifts how we think about turning raw scanned geometry into something editable by a human engineer.

Lu: It really forces us to consider what kind of representation learning is needed when the goal isn't just generating an image or text, but generating a valid, executable procedural program from scratch.

Title and authors: Meng: For deployment, the next question is scalability; if this step-by-step process takes too long for a complex assembly, it won't fit into our production pipeline.

Tom: The authors suggest that inference can be made more efficient by using sampling instead of greedy decoding, which means each step branches out into thirty-two candidate continuations at one point and they execute them.

Jane: That sounds like a smart way to manage the computational load during the actual reconstruction phase, allowing for a longer operation budget while keeping things manageable.

Lu: And they found that optimizing for geometric surface type agreement, measured by GMS, actually produced the largest gain in mean GMS across all three datasets, even though they admit that GMS isn't really a valid reinforcement learning training signal.

Meng: If it’s not a valid training signal, then relying on it for the RL loop might be risky because you could be optimizing for something that doesn't actually help the final reconstruction accuracy.

Lalam: The paper concludes by stating that CADENA-RL consistently achieves the best scores across CD8k, CD30k, IoU, and GMS in their overall comparison and in almost every single class on CADENA-Bench.

Tom: So to wrap up the discussion on "CADENA: Stepwise CAD Reverse Engineering," this work strongly suggests that for complex engineering tasks like reverse engineering shapes into editable models, an incremental approach guided by geometric feedback is significantly better than a single-pass generation method.

Jane: It changes the expectation for how we think about these reconstruction problems, moving toward a process that mimics how a human engineer actually builds something feature by feature.

Lu: It’s important to remember that even with this progress, the authors are transparent about where it stops working, like with occluded geometry or early frame errors.

Meng: For us in production, the focus will be on making those incremental steps faster and more robust when dealing with real-world complexities like gears and bearings.

Lalam: So we have CADENA as a promising direction for this kind of modeling, showing that step-by-step refinement can lead to much higher fidelity results.

The paper's summary: Tom: So, to recap, this paper is about CADENA, which is an AI system that rebuilds existing three dee shapes—like scanned parts—into editable parametric CAD models by building them up one operation at a time instead of trying to generate the whole thing at once.

Jane: Exactly. The big idea here is that instead of asking the AI to draw the whole bracket in one go, it asks it: "Okay, I have this target shape and this partial model; what's the next logical step?"

Lu: It shifts things from a code generation problem to a sequence of geometric decisions. It says you only need to condition on what you have built so far and the final target shape, not on how long the program is already.

Meng: That sounds like it should be way more robust for real-world parts, because if it’s checking its work at every step, it shouldn't just produce junk in the middle of a complex assembly.

Tom: Right. And they put this into practice with CADENA-Bench and showed that by using reinforcement learning against the actual geometry built during the process—not just a final score—it gets a much better result than previous methods.

Jane: They found that this step-by-step refinement actually helps them find improvements where single pass models fail, especially in those harder parts like gears and bearings, showing that the incremental approach isn't just a uniform improvement across the board.

Lu: The reward they use is volumetric intersection—it measures how much of what you’ve built overlaps with the target shape—which is a direct measure of geometric accuracy at every single step.

Meng: I see that focusing on those hard parts is smart for production because if you can get a reliable reconstruction for the toughest components, that’s where it matters most when you’re shipping something.

Tom: They also found some failure modes, though—things like approximating countable features or struggling with geometry that’s hidden from the AI's view during its look at the target.

Jane: So while CADENA is better at building, they admit there are still real-world blind spots in the observation process they need to work on.

Lu: The conclusion is pretty strong: CADENA outperforms all prior methods across every dataset they tested, even when you consider the gains from using reinforcement learning against the executed geometry.

Tom: So what this means for me as someone building models: it tells us that forcing a model to reason step-by-step based on visual feedback about its progress makes it much more reliable than just asking it for one final output.

Jane: It suggests that we need to think about how the AI builds things procedurally, where every decision is a response to what’s already there, rather than just guessing the whole finished picture.

Lu: This is definitely pointing toward a future where AI doesn't just generate static images or text, but actively constructs physical objects from scratch using iterative geometric validation.

The paper's improvements: Tom: So, we've talked about how CADENA works incrementally—building shape by shape rather than guessing the whole thing at once—and now we're looking at what they suggest as improvements to that core idea.

Jane: It seems like the authors are really pushing this idea that you can decouple operation choice from the length of your program, meaning nothing about what to do next depends on how far along you are in writing the code.

Lu: They're suggesting a way to make it even more geometry-driven, so a model only has to look at what it needs to build right now and the target shape.

Meng: That sounds like it should make deployment much smoother because we wouldn't have this massive program that has to be generated sequentially; we’d just be feeding it the next required step.

Tom: And they are using reinforcement learning against the actual geometry produced at each step as a reward, which they say makes the reconstruction more accurate while simultaneously lowering that invalid rate.

Jane: They call this learning validity rather than enforcing it later, which is a smart way to handle those kinds of errors you see in complex parts.

Lu: They found that this step-wise generation isn't just a uniform improvement; it targets the hardest parts of the dataset, rescuing the parts that single pass models get wrong by focusing on where they need the most help.

Meng: So if a model is struggling with a tricky feature, CADENA doesn't waste time trying to solve everything at once; it focuses its effort exactly where it’s needed.

Tom: They also looked at using the GMS reward—which measures surface type agreement—and found that optimizing for that actually gave them the biggest gains on all three datasets, even though they admit GMS isn't really a perfect training signal itself.

Jane: That means we can try to guide the AI toward matching surface types, not just volume overlap, which should give us a better sense of how the final object looks.

Lu: The authors also talked about inference speed, suggesting that instead of using greedy decoding—which picks one path and sticks with it—using sampling is actually better because each step branches out into thirty-two different candidates at one point.

Meng: Sampling sounds like it’s a way to manage the computational cost during reconstruction; if we can afford more steps because we're branching out instead of just committing to one operation, that could help keep the runtime down for complex models.

Tom: The paper also pointed out that occluded geometry is still invisible to the observation, so they acknowledge that this incremental method isn't perfect and still has those failure modes we saw earlier.

Jane: So while the step-wise approach is powerful for improving accuracy on known parts, they’re honest about where it stops working with things hidden from view.

Lu: It’s a solid direction, though; it shows that for complex reverse engineering, building iteratively based on visual feedback is a much more effective path than trying to get everything right in one go.

Conclusion: Tom: So, to wrap up, CADENA is an AI that reconstructs existing shapes into editable CAD models by building them step by step using reinforcement learning against the actual geometry produced at every stage of the process.

Jane: It’s a system that learns how to build something correctly through trial and error guided by geometric feedback rather than just guessing the final shape.

Lu: The implication is that we can move away from single-pass generation for complex engineering tasks, letting AI model construction like a human engineer does, incrementally.

Meng: For deployment, this means a model that builds thing by thing might be slower initially but produce a much more reliable output on the hardest parts of an assembly.

Lalam: I'm confident in my answer here; CADENA consistently achieved the best scores across every dataset they tested when we looked at CD8k, CD30k, IoU, and GMS.

Tom: It’s clear that reinforcement learning against the actual built geometry makes both the accuracy and reliability much better than previous methods.

Jane: So what does this mean for the world? It suggests a new way for AI to handle physical design tasks where precision and manufacturability matter more than just generating a plausible picture.

Lu: It’s about building a procedural understanding of geometry, which is definitely ambitious and points toward more sophisticated representation learning.

Meng: I still see the caveat that it struggles with things hidden from view or features we can't easily count, so we need to keep those limitations in mind for real production use.

Lalam: I'm sure the authors are aware of those gaps, but based on what they showed, this is a very strong direction for CAD reverse engineering.

Tom: It was a really clean ablation study showing how much better the results got just by adding that geometric reward signal during reinforcement learning.

Jane: It’s a big step forward because it moves AI modeling closer to actual engineering workflows where you need control over the construction history.

Lu: We should keep watching how they tackle those failure modes, like those early frame errors, because that's where the real robustness of the system will be tested.

Meng: My main thought is on deployment cost; if this iterative process keeps getting slower at scale, it won't fit our needs for high-throughput generation.

Lalam: I’m sure they have plans for efficiency, but what they showed in CADENA is a very solid foundation for moving beyond simple reconstruction toward actual generative modeling of physical objects.

Lomonosov Moscow State University · DAIMLD Institute of Advanced Industrial Modeling and Design Laboratory · Δ Independent Researcher Institute of Advanced Industrial Modeling and Design Laboratory · Innopolis University · FusionBrain Lab

cs.CV

Submitted: 2026-08-01

Updated: 2026-11-18

Comments: Code: https://github.com/zhemdi/cadena Model: https://huggingface.co/kulibinai/cadena Benchmark: https://huggingface.co/datasets/kulibinai/cadena-bench

Code: https://github.com/zhemdi/cadena

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 82/100

The gist: Computer-Aided Design (CAD) underpins modern engineering, yet converting existing shapes into editable models still demands substantial expert effort<ref:2608.00799#pg2> CADENA…

Key concepts

CADENA
CADENA is a model that reconstructs a 3D mesh into an editable parametric CAD program. It grows its sequence of operations one step at a time, constantly comparing the predicted geometry with the actual target shape to guide its next move.
Stepwise Generation Mechanism
This mechanism involves generating one operation at a time. The system observes a combined image of the target and current build, along with a hint point. It then chooses an operation based on this observation, executing it before deciding the next step, making the policy dependent on geometry rather than just code.
Reinforcement Learning against Executed Geometry
Training uses reinforcement learning where rewards are calculated directly from the geometry produced by running the predicted program. This ensures that validity is learned through geometric fidelity (volumetric IoU) rather than relying on external filtering, leading to better accuracy and a lower rate of invalid models.
Targeted Improvement
The system shows targeted improvement by focusing its gains on the hardest parts of a dataset—those where single-pass models fail. This means the stepwise approach is most effective at rescuing difficult reconstructions, proving that stepping is not a uniform benefit but a strategic one.

Terminology

Summary

Computer-Aided Design (CAD) underpins modern engineering, yet converting existing shapes into editable models still demands substantial expert effort<ref:2608. p. 0

Where the paper says it

CADENA: STEPWISE CAD REVERSE ENGINEERING A PREPRINT Soslan Kabisov1* Gennadiy Savrasov1* Maksim Elistratov 1 Antonio Rodriguez 2 Daniil Ignatiev 2 Nikita Gavrilov 1 Rustam Uzdenov 1 Alexey I. Boyko 3 Igor Pasechnik 2 Anton Konushin 1 Andrey Kuznetsov 45 Dmitrii Zhemchuzhnikov1† 1 Lomonosov Moscow State University; 2 DAIMLD; 3 Independent Researcher; 4 Innopolis University; 5 FusionBrain Lab August 4, 2026 ABSTRACT Computer-Aided Design (CAD) underpins modern engineering, yet converting existing shapes into editable models still demands substantial expert effort.

00799#pg2> CADENA, a model that reconstructs a 3D mesh as a parametric CAD program, growing its sequence of operations one at a time and comparing the target with the currently predicted geometry at every step<ref:2608. p. 0
Where the paper says it

In contrast, human engineers build a part feature by feature, checking after each operation what remains to be modeled. We introduce CADENA (Spanish for “chain”), a model that reconstructs a 3D mesh as a parametric CAD program, growing its sequence of operations one at a time and comparing the target with the currently predicted geometry at every step.

00799#pg3> It introduces CADENA-Bench, a benchmark that measures performance across categories of mechanical parts<ref:2608. p. 0
Where the paper says it

We introduce CADENA (Spanish for “chain”), a model that reconstructs a 3D mesh as a parametric CAD program, growing its sequence of operations one at a time and comparing the target with the currently predicted geometry at every step. We also address the lack of benchmarks for evaluating reverse-engineering methods on mechanical parts, introducing CADENA-Bench, a benchmark that measures performance across categories of mechanical parts.

00799#pg4> CADENA outperforms prior methods on CADENA-Bench and on the DeepCAD, Fusion 360, and MCB datasets<ref:2608. p. 0
Where the paper says it

We also address the lack of benchmarks for evaluating reverse-engineering methods on mechanical parts, introducing CADENA-Bench, a benchmark that measures performance across categories of mechanical parts. CADENA outperforms prior methods on CADENA-Bench and on the DeepCAD, Fusion 360, and MCB datasets.

00799#pg5>

The Core Concept

Editable parametric CAD models are the working currency of mechanical engineering, yet most existing 3D assets — scanned parts, legacy archives, models exported without history — exist only as raw geometry<ref:2608.00799#pg2> A mesh can be rendered and printed but not changed: it has no notion of a bore, a fillet or a wall, only triangles, so there is no handle by which to widen a hole or lengthen a bracket<ref:2608. p. 0

Where the paper says it

Keywords CAD reverse engineering · parametric CAD · vision-language models 1 Introduction Editable parametric CAD models are the working currency of mechanical engineering, yet most existing 3D assets — scanned parts, legacy archives, models exported without history — exist only as raw geometry. A mesh can be rendered and printed but not changed: it has no notion of a bore, a fillet or a wall, only triangles, so there is no handle by which to widen a hole or lengthen a bracket.

00799#pg2> CADENA closes this loop, emitting one operation at a time and executing it before deciding the next<ref:2608. p. 1
Where the paper says it

Conditioning on the residual — what the target still has that the build does not — removes both, and any operation may be applied at any point, because nothing about the choice depends on how far along the program is. CADENA closes this loop, emitting one operation at a time and executing it before deciding the next (Fig.

00799#pg3> The observation is derived entirely from the target and the current build, making the policy a function of geometry rather than of code<ref:2608. p. 3
Where the paper says it

Crucially π is not conditioned on the program text written so far: the observation is derived entirely from the target and the current build. The partial build St is the sole carrier of history, which makes the policy a function of geometry rather than of code.

00799#pg4>

Stepwise Generation Mechanism

The observation R(M, St) is a single multi-view image that superimposes target and current build in separate color channels<ref:2608.00799#pg5> The eight views are tiled into one 504 × 1008 image (252 × 252 per view, a multiple of the vision encoder’s patch size; rendered at twice that resolution and downsampled)<ref:2608. p. 3

Where the paper says it

The target is rendered as a green-channel overlay and the partial prediction as a red-channel overlay. The eight views are tiled into one 504 × 1008 image (252 × 252 per view, a multiple of the vision encoder’s patch size; rendered at twice that resolution and downsampled).

00799#pg5> Alongside the rendered image, the policy receives a hint point: a 3D coordinate provided as text<ref:2608. p. 3
Where the paper says it

This representation makes the difference between the two meshes directly readable: yellow indicates regions where the projections overlap (with the relative green/red intensity encoding depth mismatches), predominantly green regions mark missing geometry, and predominantly red regions indicate excess material (Fig. Alongside the rendered image, the policy receives a hint point: a 3D coordinate provided as text.

00799#pg5> During training, the ground-truth program and the intermediate shape after step t + 1 are available<ref:2608. p. 4
Where the paper says it

Whenever possible, the hint is placed near the boundary between the existing and missing geometry, biasing the policy to extend the already constructed shape rather than begin a disconnected component. During training, the ground-truth program and the intermediate shape after step t + 1 are available.

00799#pg6> The reward is the volumetric IoU between the solid built so far and the target mesh, computed directly on the meshes<ref:2608. p. 5
Where the paper says it

The policy generates trajectories step by step, executing each operation in the loop, but because execution dominates the cost of a rollout we do not optimise whole trajectories: training uses one-step signals, optimising the choice of the next operation relative to a reference trajectory that the policy generates itself. The reward is the volumetric IoU between the solid built so far and the target mesh, computed directly on the meshes; a candidate whose program fails to execute receives zero.

p. 5
Where the paper says it

The policy generates trajectories step by step, executing each operation in the loop, but because execution dominates the cost of a rollout we do not optimise whole trajectories: training uses one-step signals, optimising the choice of the next operation relative to a reference trajectory that the policy generates itself. The reward is the volumetric IoU between the solid built so far and the target mesh, computed directly on the meshes; a candidate whose program fails to execute receives zero.

00799#pg6>

Training and Reinforcement Learning

The training procedure combines supervised fine-tuning with online reinforcement learning, where rewards are computed from the geometry produced by executing the predicted program instead of offline sequence modeling<ref:2608.00799#pg6> The policy is a Qwen2-VL vision–language model, and is trained using teacher-forced next-operation prediction for 2 epochs per stage, with a batch size of 64<ref:2608. p. 5

Where the paper says it

The main-stage model is initialized from the weights learned during the warm-up stage. The policy is a Qwen2-VL vision–language model, and is trained using teacher-forced next-operation prediction for 2 epochs per stage, with a batch size of 64, an initial learning rate of 1.

00799#pg6> The reward is the volumetric IoU between the solid built so far and the target mesh, computed directly on the meshes<ref:2608.00799#pg6>

Evaluation and Results

CADENA-RL reaches 0.910 voxel IoU at 0. p. 2

Where the paper says it

CADFit [Nehme et al. , 2026] is at the other extreme, but is not a learned generator: it reconstructs by optimisation, incrementally fitting and validating parametric operations against the target under an IoU objective and pruning the candidate set with a learned sketch prior, so its search cost grows with part complexity — a trade-off its results make visible (Section 5).

9% invalid CADENA-RL consistently achieves the best trade-off between reconstruction quality and reliability The degradation is uneven across part families CADENA-RL leads five of the six; the exception is gears & bearings, where CADFit’s direct fitting reaches 61. p. 7
Where the paper says it

Each surviving part carries one of six family labels — shafts & bushings, gears & bearings, housings & frames, flat & levers, springs & fasteners, tooling & gauges — coarse classes corresponding to the standard engineering parts classification. The taxonomy is deliberately coarse so that it can be applied consistently across three heterogeneous sources.

3 against our 58. p. 2
Where the paper says it

CADFit [Nehme et al. , 2026] is at the other extreme, but is not a learned generator: it reconstructs by optimisation, incrementally fitting and validating parametric operations against the target under an IoU objective and pruning the candidate set with a learned sketch prior, so its search cost grows with part complexity — a trade-off its results make visible (Section 5).

1

Limitations and Failure Modes

Four failure modes recur (Fig. 5), and they are worth separating because only the first is a failure of the loop rather than of its inputs or its vocabulary Countable features are approximated rather than counted Occluded geometry is invisible to the observation Out-of-vocabulary features are approximated by what the DSL has Early frame errors are not recovered

Conclusion

CADENA outperforms prior methods on every dataset we evaluate, though the margin is far from uniform Reinforcement learning against executed geometry strengthens both halves of that result, improving reconstruction accuracy while reducing the invalid rate CADENA-RL consistently achieves the best CD8k, CD30k, IoU, and GMS both in the overall comparison (Table 12) and in nearly every individual class The gains of CADENA-RL are not an artifact of evaluating on an easier subset of samples, but reflect genuinely more accurate and more reliable reconstructions across the full range of part complexities represented in CADENA-Bench

Pruning redundant reasoning tokens

CADENA outperforms prior methods on every dataset we evaluate, though the margin is far from uniform Reinforcement learning against executed geometry strengthens both halves of that result, improving reconstruction accuracy while reducing the invalid rate CADENA-RL consistently achieves the best CD8k, CD30k, IoU, and GMS both in the overall comparison (Table 12) and in nearly every individual class

How the training signal is built

Supervision comes from a rule-based procedural generator that samples valid CAD programs together with the meshes they produce, covering extrude, revolve, loft, sweep, shell, hole, gear, spring, and edge operations Because the generator owns the construction history, it can emit stepwise supervision directly: a program is cut at a checkpoint Each training sample is therefore a single step — the target shape, the partial build produced by the prefix, and the code of the next operation — in exactly the form the policy consumes at inference

Where the gains come from

The gain is concentrated in the hardest quartile of each dataset — parts whose first operation scores worst Stepwise generation is thus not a uniform improvement but a targeted one: it rescues the parts a single-pass model gets wrong, and leaves the easy ones alone Comparing the first operation against the selected prefix per part, 14% of DeepCAD parts, 17% of Fusion360 parts, and 15% of MCB parts improve by at least 0.10 IoU

The gain is concentrated in the hardest quartile of each dataset — parts whose first operation scores worst Stepwise generation is thus not a uniform improvement but a targeted one: it rescues the parts a single-pass model gets wrong, and leaves the easy ones alone

The gain is concentrated in the hardest quartile of each dataset — parts whose first operation scores worst Stepwise generation is thus not a uniform improvement but a targeted one: it rescues the parts a single-pass model gets wrong, and leaves the easy ones alone

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Stepwise generation with visual feedback allows for an operation choice that is not conditioned on the program text written so far, meaning any operation may be applied at any point, because nothing about the choice depends on how far along the program is. This enables a policy to observe only the target and current build, making it a function of geometry rather than code.

  2. Reinforcement learning against executed geometry strengthens both halves of that result by rewarding volumetric IoU between the solid built so far and the target mesh, ensuring that validity is learned rather than enforced by post-hoc filtering. This optimizes for geometric fidelity while simultaneously reducing the invalid rate, as seen with CADENA-RL achieving a low invalid rate.

  3. The system can perform targeted improvements by concentrating its gains on difficult parts: Stepwise generation is thus not a uniform improvement but a targeted one: it rescues the parts a single-pass model gets wrong, and leaves the easy ones alone. This demonstrates that stepping is effective where single-pass methods fail, as shown by gains concentrated in the hardest quartile of each dataset.

  4. Inference can be made more efficient by using sampling instead of greedy decoding: Sampling is in fact the better decoding rule, and it costs less computation per operation because each step branches into 32 candidate continuations at T=1.0, execute them. This allows for a longer operation budget at inference time while maintaining tractability.

  5. The system can be made more robust to geometric complexity by using GMS as a reward: the GMS reward produces the largest gain in mean GMS on all three datasets, though it is noted that GMS is not a valid RL training signal. This shows that optimizing for surface type agreement, rather than just volume overlap, can guide the reconstruction process.

Abstract

Computer-Aided Design (CAD) underpins modern engineering, yet converting existing shapes into editable models still demands substantial expert effort. Most AI systems emit the entire CAD program in a single pass, never inspecting the intermediate geometry. In contrast, human engineers build a part feature by feature, checking after each operation what remains to be modeled. We introduce CADENA (Spanish for "chain"), a model that reconstructs a 3D mesh as a parametric CAD program, growing its sequence of operations one at a time and comparing the target with the currently predicted geometry at every step. We also address the lack of benchmarks for evaluating reverse-engineering methods on mechanical parts, introducing CADENA-Bench, a benchmark that measures performance across categories of mechanical parts. CADENA outperforms prior methods on CADENA-Bench and on the DeepCAD, Fusion 360, and MCB datasets. Code is available at https://github.com/zhemdi/cadena, model weights at https://huggingface.co/kulibinai/cadena, and CADENA-Bench at https://huggingface.co/datasets/kulibinai/cadena-bench.

Sources

Related papers