AutoDesign: Computational Design Generation and Optimization

• AutoDesign is the use of computational systems to generate, evaluate, optimize, or refine design alternatives under human-defined objectives and constraints, including CAD models, neural networks, materials, interfaces, and engineering topologies.
• Most AutoDesign systems use a closed loop of requirements, representation, candidate generation, validation, evaluation, and selection, combining methods such as evolutionary search, diffusion models, reinforcement learning, formal synthesis, and LLM-guided optimization.
• AutoDesign augments rather than replaces human expertise because representations can limit novelty, learned systems may inherit data bias, and generated outputs require domain-specific checks for validity, efficiency, safety, manufacturability, and human usefulness.

AutoDesign is the use of computational systems to generate, complete, optimize, or refine designs under human-defined objectives, constraints, and evaluation procedures. The term encompasses designer-in-the-loop evolutionary exploration, formal model transformation, materials discovery, neural architecture search, aesthetic product generation, UI and graphic-layout synthesis, CAD command generation, EDA-flow automation, LLM-guided optimization, and engineering design synthesis. Across these settings, AutoDesign is distinguished from ordinary automation by its focus on design alternatives and design-space navigation rather than merely executing a fixed workflow. Its systems may operate on sketches, images, hierarchical layouts, symbolic programs, CAD sequences, physical topologies, numerical parameters, or combinations of these representations.

1. Conceptual foundations and historical development

AutoDesign systems differ in their degree of autonomy. At one end, a designer explicitly evaluates generated alternatives, as in the interactive genetic algorithm for car silhouettes. At the other, a system autonomously selects architectures, generates executable artifacts, evaluates them, and iterates, as in neural architecture search, LLM-guided GPU optimization, and reinforcement-learning-based engineering synthesis. Most reported systems remain hybrid: humans define the design space, requirements, constraints, representations, or final approval criteria, while computational agents perform exploration, generation, validation, and ranking.

A recurring AutoDesign architecture is a closed loop:

$$\text{requirements} \rightarrow \text{representation} \rightarrow \text{candidate generation} \rightarrow \text{validation} \rightarrow \text{evaluation} \rightarrow \text{selection or refinement}.$$

The representation may be a Fourier genome, Event-B model, crystal structure, neural-network chromosome, UI tree, latent image vector, CAD Command Sequence, TCL workflow, source program, or engineering topology. Candidate generation may use evolutionary operators, Transformers, diffusion models, latent interpolation, templates, reinforcement learning, nonlinear programming, or LLM-mediated transformations.

Early work emphasized interactive exploration rather than autonomous replacement of designers. An interactive genetic algorithm represented 2D car silhouettes through Fourier coefficients and used designer-assigned fitness to evolve stylistic alternatives. In user tests, average within-population similarity increased from approximately 6.5% initially to between 60% and 90% by the tenth generation, while semantic interpretations differed substantially: “friendly” produced diverse shape families, whereas “sportive” produced a more conventional Porsche-like form (Cluzel et al., 2013).

Formal-methods research extended AutoDesign from visual concepts to symbolic system models. EDGE—Event-B DesiGn Exploration—combined ProB simulation, Automated Theory Formation, Automated Reasoning, and pattern-based model transformation to propose alternative abstractions, adaptations, invariants, and fault-handling mechanisms. The system used failure analysis to constrain design generation, reducing example alternatives from 12 to 2, 10 to 7, and 6 to 2 in different transformations (Grov et al., 2016).

Subsequent systems increasingly integrated learned representations and industrial execution environments. AFLOW connected standardized first-principles calculations, materials repositories, thermodynamic modeling, and machine learning for autonomous materials design (Oses et al., 2018). Genetic DCNN design encoded convolutional and fully connected architectures as integer chromosomes and evolved them through selection, crossover, and mutation (Ma et al., 2018). Later systems introduced controllable generative models, multi-agent orchestration, formal tool interfaces, and LLM-guided strategic search.

2. Design representations and search spaces

The design representation determines which alternatives can be expressed, how candidates can be modified, and what kinds of validity constraints can be enforced. AutoDesign systems generally use one of five representation classes: geometric, symbolic, architectural, latent, or hybrid.

Geometric and latent representations

The car-silhouette system models a closed contour as a complex-valued function:

$z(t)=x(t)+iy(t).$

The contour is expanded in a Fourier series, with low-order harmonics describing broad body form and higher-order harmonics representing local curvature and detail. A fixed-length genome makes corresponding genes available across individuals, enabling gene-wise crossover. Weighted averaging of Fourier coefficients produces continuous interpolations between plausible parent silhouettes, while mutation expands the search beyond the convex combinations of existing designs (Cluzel et al., 2013).

Learned latent representations provide a higher-dimensional but semantically richer alternative. In product aesthetic design, a probabilistic VAE maps images into a 512-dimensional latent embedding. The generator reconstructs images and product masks, while a supervised predictor maps latent embeddings to consumer aesthetic scores. Spherical linear interpolation enables smooth transitions between generated designs (Burnap et al., 2019).

For 3D vehicle geometry, a modified DeepSDF model represents each normalized vehicle with a 16-dimensional latent vector. An eight-layer MLP with 512 neurons per fully connected layer predicts signed distance values, and Marching Cubes recovers meshes from the implicit field. A CNN can infer a latent code from a sketch, after which nearest-neighbor retrieval or latent interpolation produces candidate vehicle geometries (Elrefaie et al., 30 Mar 2025).

Symbolic and structured representations

Formal-model AutoDesign represents Event-B systems through variables, invariants, events, guards, actions, and refinement relations. Atomic operators such as deleteVariable, mergeEvents, deleteGuard, insertAbstractLayer, and moveVariableToAbstractLayer compose into higher-level transformations. The representation makes requirements and proof obligations explicit, but the resulting search space is bounded by the available operator vocabulary (Grov et al., 2016).

UI layout systems represent interfaces as rooted trees. Each node contains a component type, depth, terminal status, parent index, and rectangular bounding box. Pointer Transformers predict parent indices directly, while Recursive Transformers generate sibling sequences recursively and recover hierarchy through the decoding call structure (Li et al., 2020). Desigen uses a flatter autoregressive representation in which each layout element is encoded by a category and discretized position and size tokens (Weng et al., 2024).

CADLLM and TCADGen represent models as CAD Command Sequences:

$$\mathbf{M}=\{(c_1,\mathbf{p}_1),\ldots,(c_N,\mathbf{p}_N)\}.$$

The command vocabulary includes <SOL>, Line, Arc, Circle, Extrude, and <EOS>. This representation produces editable parametric construction procedures rather than static meshes, but it is primarily restricted to sketch–extrusion sequences (2505.19490).

Architectural, programmatic, and engineering representations

Genetic DCNN Designer encodes a network as stacked meta convolutional and fully connected blocks. A convolutional block contains filter count, kernel size, pooling, batch normalization, activation, and dropout loci; a fully connected block contains neuron count, batch normalization, activation, and dropout. The resulting chromosome can vary depth, width, operations, and optimizer (Ma et al., 2018).

AutoADR uses a directed acyclic graph with convolution, pooling, bidirectional GRU, multi-head self-attention, and skip connections. Its one-shot supernet shares weights among candidate architectures, allowing approximately 3,000 sampled architectures to be evaluated after supernet training (Chen et al., 2020).

AUTO treats CUDA source code as the design artifact. Its Implementor can modify algorithms, memory layout, precision, tiling, loop unrolling, thread organization, and specialized instructions. The design space is therefore syntactic and algorithmic rather than a fixed numerical vector (Carreon et al., 27 Nov 2025).

In engineering synthesis, topology is represented as a graph of components and connections. Discrete variables select layouts, stages, gearsets, or interconnections, while continuous variables determine dimensions, ratios, masses, and other parameters. Computational design synthesis combines topology generation with continuous optimization and physics-based evaluation (Oerlemans et al., 26 Jun 2026).

3. Generation and optimization methodologies

Interactive evolutionary design

Interactive genetic algorithms are appropriate when the objective is subjective, semantic, or difficult to formalize numerically. In the car-silhouette system, the designer assigns fitness between 0 and 6 to six displayed individuals, while a larger population contains 100 individuals per generation. A turnover rate of 0.7 retains 30 individuals and generates 70 children. Selection, crossover, mutation, and killing progressively concentrate the population around the designer’s evolving preference.

The method demonstrates the division of labor characteristic of human-centered AutoDesign: the algorithm explores a continuous design space, while the designer evaluates stylistic relevance. Its limitation is that user preferences can reinforce conventional prototypes. “Sportive” produced more homogeneous results than “friendly,” suggesting that the evolutionary process amplifies shared cultural associations as efficiently as individual preferences (Cluzel et al., 2013).

Analysis-guided formal synthesis

EDGE uses analysis not merely to verify generated models but to guide synthesis. ProB generates traces and identifies invariant failures. HR constructs concepts and conjectures from state and event data, including relationships of the forms:

$$failure \Rightarrow event,\qquad failure \Leftrightarrow variable.$$

The generator then applies patterns such as abstraction of problematic intermediate behavior or addition of error-handling events. In the bank-transfer example, removing intermediate transaction state produced an abstract transfer operation, while a separate error event handled insufficient funds by removing the pending transaction and clearing the active status (Grov et al., 2016).

This approach combines formal constraints with heuristic synthesis. It can produce structurally meaningful alternatives, but operator selection and integration remain manual, and discovered relations may require human interpretation. A gluing invariant found for an abstract transfer model related aggregate totals but did not fully establish the required individual-balance correspondence.

Neural architecture search

Genetic DCNN Designer uses variable-length chromosomes and evolutionary operators. Candidate fitness is validation accuracy after training. The best reported results reached 99.72% on MNIST, 94.60% on Fashion-MNIST, 95.58% on EMNIST-Letters, 99.75% on EMNIST-Digits, 89.23% on CIFAR-10 in the main table, and 66.70% on CIFAR-100. The paper also reports a prose value of 89.32% for CIFAR-10, creating an internal discrepancy (Ma et al., 2018).

The search was computationally expensive, requiring approximately 3, 5, 18, 12, 11, and 11 GPU-days per generation for the six datasets. The study did not directly optimize complexity, parameter count, FLOPs, or memory. Its evidence therefore supports automated architecture discovery, but not a general claim that evolutionary search produces more efficient networks.

AutoADR combines one-shot NAS with knowledge distillation and hard efficiency constraints. A BERT-large teacher scores query-ad pairs, and a shared-weight supernet is trained using teacher-derived targets. Approximately 3,000 architectures are sampled and ranked after rejecting candidates whose normalized size and time score exceeds the serving budget. The selected architecture contains three convolutional layers, two average-pooling layers, and one self-attention layer, with no recurrent layer. It achieved PR AUC 84.60 with 15.28 million parameters and 23.25 seconds of reported inference time, compared with 83.73 PR AUC and 24.73 seconds for the CNN baseline (Chen et al., 2020).

Generative and diffusion-based design

Generative systems learn distributions of plausible designs and allow sampling, interpolation, or conditional generation. The product-aesthetic system combines a probabilistic VAE, adversarial latent-space training, image reconstruction, attribute prediction, and supervised aesthetic prediction. On 203 rated SUV/CUV designs and 180,000 unlabeled images, its test MAE was 0.350, a 43.5% improvement over the median-rating baseline of 0.620. Consumer evaluations agreed with high-versus-low predicted appeal for 74.0% of generated designs (Burnap et al., 2019).

Desigen combines diffusion-based background generation with Transformer-based layout generation. Its central constraint is preservation of low-saliency space for text and other elements. Training uses a saliency constraint, while inference-time cross-attention reduction applies a factor of $\beta=0.01$ in specified regions. Iterative refinement regenerates the background using a mask derived from the current layout. The reported salient ratio decreases from 16.87 at the first iteration to 15.27 at the third, while occlusion decreases from 11.66 to 8.69 (Weng et al., 2024).

MAxPrototyper applies a theme-first, multi-agent architecture to UI prototypes. A Theme Design Agent retrieves UI examples, generates a global theme description and image, and routes components to specialized text, image, and icon agents. The final output can be saved as SVG or JSON. Its reported FID is 23.76, compared with 69.48 for Stable Diffusion 1.5 without ControlNet, while its generation-diversity score is 13.98 (Yuan et al., 2024).

LLM-mediated strategic search

AUTO treats design optimization as gradient-free search in spaces where transformations are difficult to parameterize. A Strategist chooses among refine, combine, and innovate; an Implementor generates or modifies the artifact. Valid designs are evaluated, and the complete design history is stored for future context curation.

The system achieved approximately 50–70% search efficiency under an alignment measure comparing its exploration–exploitation behavior with Bayesian optimization. In GPU experiments, it generated competitive CUDA implementations for chemical kinetics and dense matrix multiplication. Compilation success was 44.87% for kinetics and 56.94% for matrix multiplication, demonstrating that LLM-generated candidates can be invalid, particularly when specialized CUDA APIs are used (Carreon et al., 27 Nov 2025).

4. Domain-specific AutoDesign systems

AutoDesign is not a single algorithmic field. Its methods and validity criteria vary substantially by domain.

Materials discovery

AFLOW integrates automated DFT calculations, AFLOWLIB repositories, RESTful access, the AFLUX search API, thermodynamic modules, and machine-learning services. Its database contained more than 1.8 million compounds associated with approximately 100 properties. The framework calculates electronic, magnetic, chemical, crystallographic, thermodynamic, thermomechanical, vibrational, and phonon-related quantities (Oses et al., 2018).

Convex-hull analysis identifies stable and metastable phases by comparing calculated energies across competing compositions. For disordered materials, AFLOW enumerates ordered supercells generated through Hermite Normal Form matrices, filters degeneracies using approximate energies, performs ab initio calculations on unique configurations, and combines properties with temperature-dependent Boltzmann weights. A glass-forming-ability descriptor based on competition among structurally distinct, energetically similar phases correctly predicted 73% of glass-forming compositions across 16 alloy systems and estimated that approximately 17% of binary systems could form glasses.

Automotive design

Automotive AutoDesign spans silhouette ideation, aesthetic generation, 3D geometry retrieval, CAD generation, meshing, CFD, and aerodynamic surrogate modeling. The multi-agent framework in (Elrefaie et al., 30 Mar 2025) uses Styling, CAD, Meshing, and Simulation Agents. Styling uses SDXL, ControlNet, Canny edges, and CLIPasso. CAD uses DeepSDF, latent retrieval, ResNet-based similarity, and Marching Cubes. Meshing uses OpenFOAM, while Simulation uses retrieval from DrivAerNet++ or TripNet surrogate prediction.

The framework includes 8,000 industry-standard automotive designs, 8,000 sketches or rendered designs, and an unseen test set of 1,200 designs for aerodynamic prediction. TripNet reproduced drag-difference trends with displayed discrepancies ranging from exact agreement to 0.00023 absolute error. However, the paper does not demonstrate a closed-loop multi-objective optimizer, provide full CFD timing results, or establish manufacturability and experimental aerodynamic validity.

UI and graphic design

UI AutoDesign systems emphasize hierarchy, geometry, component semantics, editability, and interaction. Pointer and Recursive Transformers complete partial UI trees by predicting component types, terminal status, coordinates, and hierarchy. Their evaluation uses Layout Tree Edit Distance, parent-child pair F1, and next-element accuracy rather than only sequence accuracy [(Nagaj et al., 2020)?].

Desigen generates background-layout templates, while MAxPrototyper uses retrieval, theme planning, specialized agents, cache-based coordination, and iterative human interaction. A later design method, Gradual Generation of User Interfaces, proposes intermediate layers such as Categories, Layout, Content, and Style. Users can revise an earlier layer and “wind back” the generation process, treating interface synthesis as a reversible sequence of semantic design decisions (Min et al., 25 Jan 2026).

CAD and engineering systems

TCADGen and CADLLM generate and correct sketch–extrusion command sequences. TCADGen uses separate appearance and parameter channels, a dual-channel feature aggregator, Transformer decoding, and command-level confidence values. CADLLM focuses on low-confidence commands and arguments rather than regenerating all operations. On the reported benchmark, TCADGen plus CADLLM achieved command accuracy 0.966, F1 0.947, and AUC 0.962; its table-reported Chamfer Distance was 3.12 (2505.19490).

Computational design synthesis addresses system-level engineering. In the e-drive case, reinforcement learning selects gearbox topologies and nonlinear programming sizes continuous parameters under physical constraints. The AI-generated designs were within approximately 2% of the brute-force optimum, and evaluation time was reportedly reduced by approximately three orders of magnitude, although the wording and supporting timing data are incomplete (Oerlemans et al., 26 Jun 2026).

EDA and software optimization

AutoEDA uses Model Context Protocol-based microservices to connect LLM agents with synthesis, placement, clock-tree synthesis, routing, and artifact collection. Typed request schemas, version-aware templates, parameter validation, TCL generation, subprocess execution, checkpoints, and structured reports constrain LLM behavior. The complete workflow achieved CodeBLEU 88.47, compared with 30.65 for the in-context baseline in the displayed table, and reported execution times of approximately 0.69–5.70 seconds versus 7.32–47.71 seconds for baselines (Lu et al., 1 Aug 2025).

AUTO differs by treating the source program itself as a design artifact. Its search history includes successful and failed implementations, and its Strategist selects exploration or exploitation strategies. The framework is particularly suited to design spaces involving algorithmic transformations, memory layouts, and implementation patterns that are difficult to encode as fixed numerical variables (Carreon et al., 27 Nov 2025).

5. Human control, constraints, and evaluation

Human involvement remains central to most AutoDesign systems. It appears in at least four forms: specification, supervision, interpretation, and approval.

Specification: humans define prompts, sketches, wireframes, requirements, technology libraries, target attributes, design constraints, or search spaces. In AutoADR, online serving constraints determine the architecture budget. In AutoEDA, users specify design names, technology nodes, fanout limits, effort levels, and stage ordering. In engineering synthesis, engineers define feasible components, physical requirements, and objective priorities.

Supervision: humans may assign fitness, provide aesthetic ratings, annotate keyword-image associations, label design alternatives, or correct invalid outputs. The interactive car-silhouette system uses repeated 0–6 fitness ratings. The product-aesthetic model uses consumer ratings. The automotive concept system collected expert annotations linking design keywords such as “modern,” “dynamic,” and “bold” to wheel images (Wang et al., 2024).

Interpretation: generated alternatives often require human assessment because automated metrics are incomplete. A CAD sequence may be syntactically valid but produce an invalid solid. A UI may have correct hierarchy but poor visual alignment. A design may score highly for predicted appeal but violate brand strategy or manufacturing constraints. A formal model may satisfy observed traces while failing universal proof obligations.

Approval: humans commonly retain final authority, particularly in safety-critical, regulated, aesthetic, or manufacturing contexts. The multi-agent automotive framework explicitly assigns visual selection to designers and mesh, simulation, and engineering validation to engineers. AutoDesign therefore generally augments professional judgment rather than eliminating it.

Evaluation is correspondingly multidimensional. Typical measures include:

Evaluation dimension	Representative measures
Predictive quality	Accuracy, MAE, PR AUC, FID, CLIP score
Structural validity	Proof obligations, invariant satisfaction, tree F1, CodeBLEU
Geometric quality	Chamfer Distance, MMD, JSD, overlap, occlusion
Search behavior	Convergence, diversity, exploration–exploitation alignment
Efficiency	Inference time, token usage, GPU-days, memory, latency
Human utility	Edit distance, preference ratings, designer feedback, workflow integration

No single metric captures AutoDesign quality. High image fidelity may coexist with poor editability. High CodeBLEU may not imply optimal physical QoR. A high LCS ratio may hide a numerically important CAD error. Passing checkMesh does not establish CFD validity. Similarity metrics fitted to one user population may not generalize across cultures, vehicle classes, or design organizations.

6. Limitations, failure modes, and controversies

Representation constraints

Every representation excludes some design dimensions. Fourier silhouettes omit three-dimensional surfaces, interiors, lighting, stance, wheel engineering, and packaging. UI tree models omit typography, style tokens, responsive behavior, interaction logic, and accessibility. Sketch–extrusion CAD sequences omit fillets, lofts, sweeps, tolerances, assemblies, and feature-history dependencies. Sequential neural architectures omit many modern operations, including residual connections, dense connections, attention variants, and depthwise separable convolutions.

A representation can also create misleading validity assumptions. Fourier interpolation may preserve plausible contours but cannot guarantee wheel-ground contact, aerodynamic feasibility, or manufacturability. A parent pointer in a UI tree does not ensure legal containment. A valid TCL script does not guarantee timing closure or routability. A syntactically valid CAD sequence does not guarantee a valid solid.

Search-space bias and premature convergence

Evolutionary crossover, weight-sharing NAS, retrieval, templates, and curated context all constrain search. Weighted Fourier crossover remains close to known parent profiles. Genetic DCNN search is sensitive to initial populations, duplicate handling, mutation settings, and low-fidelity performance estimates. AUTO’s context curation may omit rare but important designs. Retrieval-based systems can reproduce the biases of their knowledge bases. Diffusion models can exhibit dominant style biases.

Search can also reinforce conventions. The “sportive” car-silhouette experiments show that preference optimization may efficiently reproduce a familiar cultural prototype rather than promote shape renewal (Cluzel et al., 2013). Novelty and plausibility are therefore competing objectives rather than interchangeable properties.

Data and generalization

Machine-learning AutoDesign systems depend on training-data coverage and consistency. AFLOW requires standardized calculations and sufficiently sampled competing phases. Product-aesthetic models depend on consumer ratings, image quality, metadata, and temporal relevance. Automotive aerodynamic surrogates trained on DrivAerNet++ may not generalize to radically novel body architectures, different turbulence models, yaw angles, or ride heights. CAD sequence models inherit command imbalance and may underperform on rare operations.

Many studies use narrow benchmarks. The CAD system focuses on DeepCAD-derived sketch–extrusion models. The AutoDesign thesis evaluates fully connected networks on MNIST. The UI completion system uses Android layouts. The automotive aerodynamic system uses DrivAerNet++. These results establish feasibility within the reported distributions but do not establish broad industrial generalization.

Objective incompleteness

Many systems do not optimize all relevant objectives explicitly. The genetic DCNN system reports complexity after architecture search rather than incorporating it into the objective. Desigen evaluates saliency, FID, CLIP score, alignment, overlap, and occlusion separately rather than optimizing a joint harmony function. Engineering design synthesis discusses efficiency, mass, and feasibility but does not always provide complete scalar objective definitions. AutoEDA optimizes script generation and flow execution rather than fully reported power, performance, and area outcomes.

This creates a distinction between design generation and design optimization. A system may generate useful alternatives without proving that it has found an optimum. Conversely, a system may optimize a measurable proxy while neglecting human, physical, or organizational requirements.

Reliability and safety

LLM-mediated systems introduce invalid or unsafe outputs. AUTO produced compilation success rates of 44.87% and 56.94% in its two GPU applications. AutoEDA must protect EDA tools from invalid commands, incompatible versions, and destructive operations. OpenFOAM agents require sandboxed execution, command validation, resource limits, and solver-log monitoring. CAD systems require kernel-level geometric validation. Surrogate models require uncertainty quantification and out-of-distribution detection.

In safety-critical engineering, generation should therefore be separated from approval. Candidate designs should pass formal, geometric, simulation, manufacturing, and human review gates before deployment or fabrication.

Reproducibility and reporting

Several reported papers contain incomplete protocols or internal inconsistencies. Examples include discrepancies in CIFAR-10 accuracy, malformed equations, unspecified stopping criteria, unclear dataset splits, undocumented prompts, absent random seeds, missing timing breakdowns, and conflicting metric values. The absence of formal completeness theorems, benchmark-wide confidence intervals, or independent replication limits the strength of general conclusions.

7. Future directions and research agenda

A mature AutoDesign system would integrate the most effective elements of current approaches rather than rely on a single generation method. A plausible architecture would contain:

1. Intent and requirements interpretation: convert natural language, sketches, examples, and documents into structured design variables, requirements, and constraints.
2. Multi-representation modeling: combine symbolic structure, learned latent variables, geometric parameters, and executable artifacts rather than forcing every design into one representation.
3. Constraint-aware generation: incorporate grammars, typed schemas, CAD-kernel checks, formal verification, geometric solvers, simulation validators, and manufacturing rules during candidate generation rather than only after it.
4. Multi-objective search: optimize preference, novelty, validity, performance, cost, complexity, robustness, manufacturability, and sustainability through Pareto-front exploration or explicitly constrained objectives.
5. Active human preference learning: use pairwise comparisons, selections, sketch edits, and natural-language feedback to infer designer preferences while preserving interpretability and control.
6. Diversity-aware search: maintain multiple stylistic, architectural, or engineering branches to avoid premature convergence and conventionality.
7. Uncertainty-aware surrogates: use predictive uncertainty and out-of-distribution detection to determine when a candidate requires high-fidelity simulation or expert review.
8. Persistent provenance: record prompts, retrieved examples, latent codes, model versions, tool versions, constraints, simulation settings, generated artifacts, validation results, and human approvals.
9. Reversible and staged interaction: expose intermediate design layers, support local regeneration, preserve persistent entities, and allow users to wind back to earlier decisions.
10. Closed computational–experimental loops: feed synthesis results, consumer judgments, physical tests, and engineering measurements back into the design system.

The central unresolved issue is the boundary between automation and agency. More autonomy can reduce manual effort, but it can also obscure assumptions, amplify historical bias, and produce designs that optimize measurable proxies while violating unmodeled requirements. The most defensible conception of AutoDesign is therefore not unrestricted autonomous invention. It is a structured human–machine system in which computational agents explore, synthesize, validate, explain, and refine design alternatives while humans retain authority over requirements, interpretation, risk, and final adoption.