The research, led by senior author Navid Azizan, the Alfred H. and Jean M. Hayes Career Development Associate Professor in MIT’s Department of Mechanical Engineering and the Institute for Data, Systems, and Society, appears in the journal IEEE Transactions on Pattern Analysis and Machine Intelligence. Azizan, who is also a principal investigator in the Laboratory for Information and Decision Systems, worked with lead author Zeyang Li, a graduate student in mechanical engineering and LIDS, and Kaveh Alim, a graduate student in IDSS and LIDS. Their central insight is deceptively simple: when it comes to satisfying hard constraints, what matters is the model’s final output, not the intermediate steps along the way. Yet most existing methods do exactly the opposite, clamping the model at every step of generation and, in doing so, strangling its ability to find good solutions.

To understand why this matters, it helps to look at how pretrained generative models actually work. Models such as Stable Diffusion and FLUX learn to create new data by transforming random noise into structured output through a sequence of denoising steps. This iterative process is what gives them their creative power: they explore a rich space of possibilities before settling on an answer. When users need those answers to obey strict requirements — safety rules, physical laws, task-specific limits known as hard constraints — the standard approach is a technique called projection-based sampling. At each intermediate step, the partial solution is forcibly projected onto the set of constraint-satisfying values, dragging the sample back into the feasible region over and over again.

The problem, as the MIT team recognized, is that constraining the entire generation process is both wasteful and counterproductive. The internal trajectory of a generative model is discarded once the final output is produced, so there is no reason every intermediate sample must be feasible. Forcing feasibility at every step removes degrees of freedom the model could otherwise use to explore, and it can prevent the sampler from ever reaching a better final solution. Worse, projection-based methods typically focus solely on constraint satisfaction, ignoring the opportunity to improve other qualities of the answer — for instance, shortening a robot’s trajectory while keeping it collision-free. An answer that merely avoids crashing is not the same as a good answer.

HardFlow flips the logic. Instead of enforcing constraints at every intermediate step, the algorithm gives the model freedom to roam during generation and enforces the hard constraints only on the final output. The trick is in how it steers the process. The researchers reformulated hard-constrained sampling as a trajectory-optimization problem, borrowing tools from optimal control theory. This framing treats the sequence of denoising steps as a controlled trajectory that can be nudged toward a goal, with subtle corrections applied along the way and the constraints imposed at the destination. Control theory, Azizan notes, provides a powerful framework for formalizing the optimal way to make those corrections — turning what might otherwise be ad hoc clamping into a principled steering problem.

Of course, formulating the problem is easier than solving it. The trajectory-optimization problem wraps around an enormous neural network, potentially hundreds of interconnected layers deep, and optimizing over such a structure directly would be computationally intractable at deployment time. The MIT team’s solution was to exploit the mathematical structure of flow-matching models, which allowed them to decompose the global trajectory problem into a sequence of smaller, single-step subproblems. Through systematic transformations and carefully chosen approximations, they derived an efficient, scalable algorithm that preserves the key properties of the original optimization problem while remaining fast enough to run when the model is actually being used. Essentially, as Azizan describes it, the team transformed the trajectory-optimization problem into something that can be solved very efficiently at deployment time.

This deployment-time operation is one of HardFlow’s most practical advantages. The technique is plug-and-play: it can be applied to any pretrained generative model without retraining, fine-tuning, or modifying the network’s weights. In an era when powerful foundation models are widely available and constantly being updated, a method that layers constraint satisfaction on top of existing models — rather than baking it in through expensive retraining — dramatically lowers the barrier to deploying generative AI in safety-critical contexts. Hospitals, factories, and autonomous systems do not need to rebuild their models; they simply need a smarter sampler.

The reformulation as an optimization problem also buys something projection methods cannot offer: the ability to jointly optimize for quality. Because HardFlow treats constrained generation as an optimization, additional objectives can be folded directly into the framework. A robotic path planner using HardFlow, for example, does not merely find any collision-free route from one machine to another — it can find the shortest or quickest collision-free route. Li emphasizes that this joint handling of feasibility and quality is what allows the framework to perform substantially better than existing methods, which typically treat constraint satisfaction as the sole goal and leave solution quality to chance.

The experimental evidence spans three domains: robotic manipulation, maze navigation, and text-guided image editing. Across all of them, HardFlow achieved perfect constraint satisfaction — every single output met the required constraints — while consistently outperforming baseline methods on measures of solution quality. In the robotics experiments, the algorithm enabled a robotic manipulator to avoid collisions with obstacles while simultaneously finding the quickest path to a target object. Most competing methods, by contrast, either produced collisions outright or found paths that took significantly more time to execute. Notably, HardFlow’s computational cost was comparable to or lower than that of most rival techniques, meaning the gains in quality and safety did not come at the price of impractical runtimes.

The implications reach well beyond the lab. Generative models are increasingly being proposed for roles in which their outputs must obey nonnegotiable rules: robots sharing space with human co-workers, controllers governing physical infrastructure, and vision systems whose errors carry real consequences. HardFlow offers a way to preserve the exploratory power that makes generative AI valuable while guaranteeing that the final answers respect the boundaries the real world imposes. As Azizan puts it, the promise of generative AI lies in its ability to explore a rich space of possibilities, but the real world places limits on which possibilities are acceptable — and his team’s approach is designed to preserve that generative power while enforcing the nonnegotiable requirements of high-stakes applications. The researchers note that future work could extend the framework to settings where the AI model itself is also updated during use, allowing constraint satisfaction and sample quality to improve in a more adaptive, closed-loop manner. For now, HardFlow stands as a demonstration that the path to trustworthy generative AI may not run through bigger models or more training data, but through smarter control of the generation process itself.

Subject of Research: Hard-constrained sampling for pretrained generative AI models via trajectory optimization

Article Title: New method enables AI for safety-critical situations

Article References: New method enables AI for safety-critical situations. (n.d.). Original publication

Image Credits: AI Generated

DOI: Not provided

Keywords: HardFlow, generative AI, diffusion models, flow-matching models, hard constraints, trajectory optimization, optimal control, robotics, constraint satisfaction, MIT, safety-critical AI, sampling algorithms

The research team, led by Alexander Felfernig of Graz University of Technology together with Viet-Man Le, Damian Garber, Sebastian Lubos, and Thi Ngoc Trang Tran, presents MSSDirect, a direct diagnosis approach for the automated testing and debugging of configuration knowledge bases. Configuration knowledge bases encode the commonality and variability properties of physical products and software artifacts, and they can grow to extraordinary sizes and complexity. The study’s experimental benchmarks ranged from compact knowledge bases of 64 constraints to industrial-scale models containing 13,972 constraints, including feature models drawn from real software ecosystems. As these artifacts grow, maintaining them becomes increasingly error-prone, driven by cognitive overload among knowledge engineers, gaps in product domain knowledge, and constraints that quietly become outdated as products evolve.

The core idea behind the new approach is elegantly simple in conception but technically demanding in execution. Engineers test knowledge bases using suites of test cases, some positive and some negative. Positive test cases specify configurations that the knowledge base must accept; negative test cases specify configurations that must be rejected. When a positive test case turns out to be inconsistent with the knowledge base, or a negative test case is unexpectedly accepted, something in the constraint set is wrong. The debugging task is to identify the minimal set of faulty constraints responsible for the observed misbehavior, since these constraints must be deleted or adapted to restore agreement between the knowledge base and its intended behavior.

Traditional methods follow a two-phase process rooted in the classical theory of model-based diagnosis introduced by Raymond Reiter in 1987. First, a conflict detection algorithm such as QuickXPlain identifies minimal conflict sets, which are groups of constraints that cannot all be satisfied together with a given test case. Second, a hitting set directed acyclic graph, or HSDAG, enumerates diagnoses as minimal sets of constraints that resolve all detected conflicts. This two-phase architecture has served the field for decades, but it carries a structural cost: the algorithm must repeatedly invoke conflict detection, and the coordination of sequential QuickXPlain calls and HSDAG navigation introduces overhead that grows painfully as knowledge bases and test suites expand. In the study’s benchmarks, this overhead frequently pushed the baseline approach past a 400-second timeout limit.

MSSDirect eliminates the intermediate conflict detection step entirely. Building on the concept of direct diagnosis, which the same research community pioneered in earlier work, the algorithm determines diagnoses directly using a divide-and-conquer strategy. It partitions the consideration set of constraints, checks which positive test cases remain inconsistent with each partition combined with background knowledge, and recursively narrows down the search. The output is a maximal satisfiable subset of the knowledge base, a set of constraints that cannot be extended without violating a test case. The diagnosis is simply the complement of this subset: the constraints excluded from the maximal satisfiable subset are exactly those held responsible for the faulty behavior. Because the method never constructs explicit conflict sets, it sidesteps the sequential bottleneck that plagues the classical approach.

The empirical results are striking. Across six real-world configuration knowledge bases, MSSDirect substantially outperformed the hitting-set baseline in the majority of evaluated scenarios. At a 20 percent rate of inconsistency-inducing test cases, speedups reached up to three orders of magnitude, and at higher inconsistency rates of 30 and 50 percent, they climbed to four orders of magnitude. In one representative scenario on a 233-constraint knowledge base with 500 test cases, the baseline required roughly 370 seconds while MSSDirect completed the same diagnosis in 179 milliseconds, a speedup exceeding 2,000 times. On larger models such as a CNN architecture with 1,637 constraints and a Linux kernel feature model with 13,972 constraints, the baseline timed out entirely for test suites of 250 or more cases, while MSSDirect returned results within milliseconds to seconds. Across 72 evaluated configurations, MSSDirect never exceeded the timeout, whereas the baseline did so in 15.

Importantly, the study also documents where the classical method retains an edge. For very large knowledge bases combined with small test suites, the baseline remains competitive, because its targeted conflict detection can resolve conflicts with fewer and more focused solver invocations when per-check costs dominate. The authors are candid about this complementary strength, noting that the advantage of direct diagnosis scales with the number of violated test cases: as more tests fail, joint divide-and-conquer diagnosis becomes increasingly efficient compared with sequential conflict resolution. This nuanced picture gives practitioners a practical decision rule rather than a blanket replacement recommendation.

Beyond raw speed, the researchers introduced a tunable parameter, lambda, that lets engineers explicitly trade off diagnosis minimality against computational efficiency. When lambda equals one, the algorithm returns subset-minimal diagnoses, the smallest possible explanations of the faulty behavior. Larger values of lambda cut runtime further by relaxing minimality guarantees. The team quantified this trade-off with a cognitive-load analysis measuring minimality, accuracy, and relevance of the extra constraints introduced. Their findings are reassuring on one front: the extra constraints almost never omit anything from the true minimal diagnosis, with accuracy values between 0.976 and 1.000. However, roughly three quarters of the added constraints appear in no subset-minimal diagnosis at all, meaning they are largely irrelevant noise. The authors therefore recommend lambda equal to one as the safe default, reserving lambda equal to two for interactive, time-critical debugging sessions on large knowledge bases where rapid feedback matters more than strict minimality, and advising against values above two.

Correctness was verified by cross-checking the diagnoses produced by MSSDirect against the enumeration of minimal diagnoses generated by the baseline. In 30 of 37 comparable scenarios, the two methods agreed on the first diagnosis, and in all remaining cases the MSSDirect diagnosis appeared later in the baseline’s enumeration, confirming that every answer was a valid minimal diagnosis rather than an approximation. The small divergence reflects a deliberate design choice: MSSDirect ranks diagnoses lexicographically by input constraint ordering, a preference previously validated in user studies where engineers favored diagnoses biased toward constraints they perceived as less essential to the product.

The implications extend well beyond constraint-based configuration. The authors emphasize that their approach is not tied to any single knowledge representation and is equally applicable to answer set programming, Boolean satisfiability solving, and description logic reasoning, formalisms that underpin feature models in software product lines, ontology debugging, and industrial configuration systems in domains ranging from telecommunications and automotive engineering to railway interlocking. Future research directions include learning-based constraint ordering, automated repair suggestions that go beyond fault localization, direct SAT and CSP encodings, and evaluation on test suites collected from real industrial projects. With source code and datasets publicly available, the work lowers a long-standing barrier in knowledge engineering: the diagnosis of large, complex knowledge bases that was once measured in minutes or hours, or simply abandoned as intractable, can now be accomplished in a fraction of a second.

Subject of Research: Automated testing and debugging of configuration knowledge bases using direct diagnosis algorithms

Article Title: Automated testing and debugging of configuration knowledge bases with direct diagnosis

Article References: Felfernig, A., Le, V.-M., Garber, D., Lubos, S., & Tran, T. N. T. (2026). Automated testing and debugging of configuration knowledge bases with direct diagnosis. Journal of Intelligent Information Systems. https://doi.org/10.1007/s10844-026-01090-3

Image Credits: AI Generated

DOI: 10.1007/s10844-026-01090-3

Keywords: configuration knowledge bases, direct diagnosis, automated testing, knowledge base debugging, model-based diagnosis, constraint satisfaction, software product lines, feature models, MSSDirect, QuickXPlain, fault localization, knowledge engineering