Structural optimization is a fundamental and essential step in density functional theory (DFT) calculations [1,2], providing the equilibrium geometries required for accurate computations of energetics, electronic structures, and physical and chemical properties [3]. Among the optimization algorithms, quasi-Newton methods, particularly the Broyden–Fletcher–Goldfarb–Shanno (BFGS) method [4] have become the standard choice due to their favorable balance between efficiency and robustness. By iteratively updating an approximate Hessian or its inverse, BFGS circumvents the need for costly explicit second-derivative calculations while providing effective curvature information for guiding ionic relaxations [5].

Despite its popularity, the BFGS method is not immune to numerical instabilities. Improper definition of the search direction due to an inappropriate initial Hessian approximation or an ill-conditioned Hessian can hinder convergence [6]. Its formulation relies on an implicit assumption: the local potential energy surface (PES) [7] can be approximated by a quadratic function. In this idealized case, the gradient difference is strictly linear, meaning the secant condition perfectly captures the constant local curvature, and the update progressively converges to the true Hessian. However, real PESs encountered in DFT calculations are intrinsically highly non-quadratic, especially in surface and adsorption systems where strong anharmonicity and many-body couplings are present. As a result, the gradient difference vector yk inevitably incorporates higher-order contributions, which contaminate the Hessian approximation [8]. This “Hessian pollution” distorts the curvature estimate, producing ill-conditioned matrices and spurious couplings that slow down convergence.

Several approaches have been developed to mitigate stability issues in structural relaxation. Strategies such as preconditioning schemes [9], trust-region methods, and machine-learned surrogate models [10,11] have been widely employed to improve convergence and stability. Recently, the field has seen rapid advancements [12] with the introduction of universal machine learning interatomic potentials (MLIPs), such as MACE [13] and CHGNet [11], which offer near-quantum accuracy for geometry optimization at a fraction of the computational cost [14]. Furthermore, novel batched optimization frameworks and comprehensive benchmarking studies have been proposed to evaluate and accelerate MLIP-driven structural relaxation across diverse energy landscapes [15,16]. Nevertheless, these methods often impose constraints: surrogate models typically require extensive domain-specific training datasets or incur significant on-the-fly computational costs [10,11], while advanced optimization schemes may necessitate intricate parameter tuning to match specific system characteristics. In high-throughput computational workflows [17], where thousands of structural relaxations must be performed efficiently, a lightweight and transferable solution is particularly desirable.

Modern advancements that address these limitations include the FIRE algorithm [18] for robust dynamics-based minimization, the Universal Exponential Preconditioner [9] for low-overhead geometric scaling, the TRIC system [19] for parameter-free coordinate transformations, the FLARE [10] active learning framework for on-the-fly surrogate training, and CHGNet [11] as a pretrained universal potential for rapid pre-relaxation. However, these methods have specific trade-offs: the FIRE algorithm may require more iterations than quasi-Newton methods in harmonic regions [18], the exponential preconditioner is less effective for complex molecular systems without hybridization [9], and machine learning approaches like CHGNet or FLARE often still require final ab initio refinement to ensure high-precision accuracy in novel chemical spaces [10,11,20].

Herein, we propose a physics-inspired modification to the BFGS algorithm that systematically suppresses Hessian pollution in late optimization stages. The method exploits the block structure of the Hessian in atomistic systems: once the residual forces fall below a given threshold, all off-diagonal blocks are reset to either zero or a small positive constant. This block-diagonalization eliminates spurious inter-atomic couplings introduced by higher-order nonlinearities, restoring stability by physically decoupling the coordinates and purging the accumulated Hessian pollution. Furthermore, we introduce a dynamic structured Hessian preconditioning strategy by injecting an isotropic background stiffness (an empirical positive coupling constant) into the off-diagonal blocks to a small positive constant. This mitigates the conservative nature of a purely diagonal Hessian, balancing robustness with convergence speed. The result is a stabilized curvature approximation that accelerates convergence without compromising accuracy. This methodology is implemented in the Hessian-Engineered Relaxation Optimizer (HERO) package, which is openly available at https://github.com/herodft-2026/beta.

To maximize accessibility and facilitate seamless integration into established computational workflows, the HERO architecture is strictly designed within the framework of the Atomic Simulation Environment (ASE). By directly inheriting from the standard ASE Atoms and Optimizer classes, the package functions as a plug-and-play extension. This ensures a near-zero learning curve: any researcher familiar with the ASE ecosystem can deploy HERO immediately, utilizing it as a drop-in replacement for standard optimizers without the need to restructure their simulation scripts or data structures.

We implemented this strategy within the ASE [21]—a Python library for working with atoms as a modular add-on, ensuring compatibility with widely used DFT codes. Benchmark tests on oxygen adsorption on Pt(111) surface demonstrate a substantial reduction in the number of ionic steps compared to standard BFGS. Additional tests on other adsorbates on Pt(111) and WO_x surfaces confirm the broad transferability of the method. By providing this scheme as an ASE extension, we aim to offer a practical and general solution for accelerating DFT structural optimization, with direct benefits for high-throughput studies in surface science and catalysis.

The flowchart in Fig. 1 delineates a robust and widely-used computational workflow for geometry optimization, a fundamental task in computational chemistry and materials science aimed at locating stable structures corresponding to local minima on the PES. The process is a synergistic combination of a high-accuracy quantum mechanical method (e.g., DFT) and an efficient numerical optimization algorithm (BFGS). The optimization process is iterative, beginning with an initial guess for the atomic structure, x0. Each iteration, indexed by k, proceeds as follows: 1.

Energy and Force Calculation: The energy E(xk) and the forces on each atom are computed for the current structure xk. The forces are equivalent to the negative gradient of the energy with respect to the atomic coordinates, −∇E(xk). As indicated, DFT is employed for this step, as it provides a good balance between accuracy and computational cost for a wide range of systems.

As delineated in Schlegel’s review, the efficacy of geometry optimization—particularly within the framework of quasi-Newton schemes like BFGS—rests fundamentally on the validity of the local quadratic approximation of the potential energy surface [22]. However, challenges persist due to the numerical instability of Hessian updates in standard schemes, and the difficulty in handling the varying stiffness of molecular vibrational modes, which can degrade optimization efficiency [23]. In such regimes, standard update formulas tend to propagate gradient noise across all degrees of freedom [24], resulting in an Hessian that contains exaggerated off-diagonal elements and consequently overestimates the spurious inter-atomic couplings and local stiffness of the molecular system.

Addressing this limitation, our proposed strategy of uniform mean-field coupling (specifically the replacement of off-diagonal atomic blocks with a uniform damped constant) serves as a robust countermeasure to these instabilities. By strictly limiting the magnitude of these uncertain inter-atomic coupling terms in the iteration matrix, we effectively implement a dynamic spectral conditioning that acts as an intrinsic structural regularization. This operation aligns conceptually with the trust radius and rational function optimization (RFO) techniques discussed by Schlegel [22], as it prevents the optimizer from taking excessive steps driven by spurious “soft modes.” However, unlike extrinsic step-size constraints, our approach enforces stability directly through the spatial decorrelation of the update operator, filtering out unreliable long-range noise while preserving the essential local topological information required for efficient convergence.

In essence, this represents a progression from a simple but stable “reset” of inter-atomic couplings to a more sophisticated isotropic background stiffness strategy that can accelerate convergence. On rugged potential energy surfaces, the strict decoupling of the ‘reset’ operation acts as a safety brake, preventing divergence but potentially stalling momentum in shallow valleys. The background stiffness strategy acts as a navigation aid: by enforcing a uniform, non-zero coupling, it smoothens the perceived local topology. This allows the optimizer to bypass minor corrugations that would otherwise trigger erratic Hessian updates, effectively guiding the system toward the local minimum with a trajectory that is both stable against anharmonic noise and dynamic enough to traverse flat regions of the PES efficiently.

Mechanism of Hessian Reset (Fig. 2a–d): Panels (a) and (b) visualize the approximate Hessian matrix at intermediate steps of a geometry optimization. The significant non-zero off-diagonal elements (shown in red and blue) represent the learned couplings between different atomic coordinates. Over many iterations, particularly on a rugged energy landscape, these off-diagonal terms can accumulate numerical noise or represent non-local curvatures inaccurately, a phenomenon we term “Hessian pollution.” This can lead to inefficient or unstable optimization steps. The core of the HERO(0) method is a periodic “reset” of this matrix. As shown in the transition from (a) to (c) and (b) to (d), the algorithm identifies moments of stagnation or instability and sets the off-diagonal blocks to zero. This operation effectively purges the accumulated pollution, decoupling the coordinates and simplifying the local optimization problem to a set of independent blocks. Physically, this operation enforces a ‘locality constraint’ that the standard BFGS update lacks. In real materials, second-derivative couplings naturally decay with inter-atomic distance. However, numerical noise in the gradient approximation often smears across the entire matrix, creating artificial long-range correlations. By pruning these off-diagonal blocks, HERO explicitly aligns the mathematical model with the physical reality of short-range chemical interactions, effectively removing the ‘false memory’ of non-existent couplings. The resulting block-diagonal matrix in (c) and (d) provides a more robust, albeit less detailed, model of the local curvature, allowing the optimizer to escape from regions where the full Hessian approximation is problematic.

Performance and Convergence (Fig. 2e–f): The convergence curves demonstrate the practical benefit of this strategy. Panel (e) shows a challenging optimization scenario where the standard BFGS algorithm (blue line) suffers from significantly slower convergence, struggling to efficiently reduce the force below approximately 0.1 eV/Å. This asymptotic stagnation is characteristic of an ill-conditioned Hessian, where the optimizer is misled by accumulated curvature errors into taking vanishingly small steps along shallow, non-productive search directions. In contrast, the HERO(0) algorithm (orange line) successfully navigates the complex energy landscape. The visible oscillations in the trajectory correspond to the algorithm actively resetting the Hessian to overcome optimization barriers. These transient spikes in force are not signs of numerical instability, but rather evidence of necessary ‘forgetting’. When the Hessian is reset, the optimizer discards the corrupted curvature history and momentarily reverts to a steeper descent direction (akin to a localized Gradient Descent restart). While this may cause a temporary increase in the projected force, it crucially breaks the inertia of the stagnation, allowing the system to re-orient towards the true local minimum. Crucially, this reset mechanism is triggered once the residual force falls into the activation window (below the threshold F = 0.5 eV/Å). Instead of the sluggish convergence observed in the standard method, this intervention actively purges Hessian pollution, enabling the optimizer to drive the forces down to the final convergence criterion (0.05 eV/Å). Panel (f) exhibits a similar trend with a stricter activation threshold (F = 0.1 eV/Å), indicating that this parameter can be tuned to delay the intervention until a deeper convergence stage is reached.

The HERO(0) method provides a powerful enhancement to standard BFGS by dynamically simplifying the Hessian approximation. By periodically removing potentially erroneous coupling information, it prevents the optimizer from getting trapped in difficult regions of the potential energy surface, proving particularly effective for systems where standard quasi-Newton methods struggle to converge.

The plots on the left (a, c, e, g) in Fig. 3 use a force threshold of F = 0.5 eV/Å for Hessian resets, while those on the right (b, d, f, h) use a stricter threshold of F = 0.1 eV/Å. The “Hessian Engine” variants differ in the value added to the off-diagonal blocks during a reset (Engine0 adds 0, Engine4 adds 4, etc.). For each system, the insets show the initial and final atomic structures, confirming that all successfully converged methods yield the same final geometry. The x-axis represents the number of DFT force calls, a proxy for computational cost.

Fig. 3 presents a comprehensive benchmark of our “Hessian Engine” optimization framework against a standard BFGS implementation. The tests span a range of materials, from surface-adsorbate systems to complex oxides, demonstrating the method’s broad applicability and robustness. Two key conclusions can be drawn from these results. These results demonstrate two key findings: first, that HERO accelerates convergence purely kinetically without introducing thermodynamic bias, consistently locating the identical final geometries; and second, that this degree of acceleration correlates strongly with the underlying complexity of the potential energy surface.

Crucially, the insets illustrate that all “Hessian Engine” variants converge to identical final geometries despite differing optimization trajectories, confirming that the method accelerates convergence without introducing artifacts or biasing the search. This confirms that the HERO modification is purely kinetic: it alters the trajectory through the potential energy landscape to bypass numerical traps, but it consistently converges to the identical local minimum without introducing thermodynamic bias to the final optimized geometry defined by the underlying DFT convergence criteria. This robustness is driven by an isotropic background stiffness injection strategy, wherein small positive values are added to off-diagonal blocks during truncation events. By mitigating the diagonal dominance typical of standard quasi-Newton initializations (which often enforces overly conservative step sizes), this approach improves Hessian conditioning and facilitates more aggressive optimization. Physically, a strictly diagonal Hessian (Engine0) implicitly assumes that atoms move independently, which is a poor approximation for condensed matter where collective motion is ubiquitous. By uniformly repopulating the off-diagonal blocks (e.g., Engine32), we effectively introduce a ‘mean-field’ background coupling. This heuristic restores a baseline level of inter-atomic connectivity, preventing the optimizer from underestimating the system’s collective response. This improves the conditioning of the approximate Hessian, effectively structuring the Hessian to enable more optimal and structurally consistent step sizes compared to the disconnected limit of Engine0. It is worth noting that the degree of acceleration provided by HERO correlates strongly with the complexity of the local PES. In systems where the local topology is already highly quadratic, standard BFGS performs near-optimally, and the HERO modifications naturally yield more marginal improvements. The true strength of the algorithm emerges in highly non-quadratic, rugged landscapes, where standard methods succumb to asymptotic stagnation. Indeed, increasing the off-diagonal addition (e.g., from Engine0 to Engine32) systematically reduces the required force calls, demonstrating that applying this structural preconditioning significantly expedites the optimization process compared to the default BFGS.

Fig. 4 provides a schematic of the software architecture for our custom BFGS optimization engine, which is built upon the widely-used ASE Library. The architecture is designed for modularity, extensibility, and separation of concerns, which are crucial for developing and testing novel optimization strategies.

The system is organized into four primary layers connected by a central Computation Bus. The Application/Runtime layer, represented by the Optimization Runner, is responsible for initiating and managing the overall optimization task and injecting the necessary components. The Domain/Compute layer encapsulates the physics of the system, containing the ASE Atoms object and the Calculator interface that connects to external DFT codes. By strictly adhering to this standardized Calculator interface, the optimization core achieves code-agnostic versatility. It interacts with the underlying physics engine, supporting it be like VASP and Quantum ESPRESSO, or grid-based codes like GPAW including over 40 supported quantum chemistry and solid-state packages such as VASP, Quantum ESPRESSO, GPAW, CP2K, and Gaussian solely through abstract energy and force calls. Therefore, HERO is immediately adaptable to any DFT code supported by the broader ASE ecosystem without requiring user-side modifications. Finally, the Persistence/Logging layer, with its State Manager, handles the saving and loading of the optimizer’s state, which is vital for restarting long calculations.

The key innovation lies within the modular Optimization Core. Instead of a monolithic optimizer, we have decomposed the logic using established software design patterns. The CustomBFGS class serves as the main driver, inheriting from ASE’s standard BFGS but overriding key methods to introduce our custom logic. The decision-making process for Hessian modification is decoupled into two distinct components: a Condition Engine (Trigger) that determines “if” and “when” a Hessian adjustment is needed based on criteria like force thresholds, and a Hessian Adjuster (Strategy) that implements the specific logic for “how” the Hessian should be modified, such as performing a block-diagonalization.

This decoupled design allows researchers to easily experiment with new optimization techniques by simply implementing new Condition Engine or Hessian Adjuster classes without altering the core optimization loop. This abstraction effectively ‘hot-swaps’ the standard BFGS logic with our Hessian-engineered approach. For the end-user, this implies seamless integration: HERO can be deployed in existing production scripts with minimal changes—often requiring only the modification of a single import statement—while retaining full compatibility with the broader ASE ecosystem. This flexibility is fundamental to the rapid prototyping and validation of the advanced optimization algorithms presented in this work.

In this work, we have addressed the persistent challenge of “Hessian pollution” in geometry optimization, a phenomenon that significantly degrades the performance of quasi-Newton methods on non-quadratic potential energy surfaces. By identifying that high-order anharmonicities introduce spurious off-diagonal couplings into the approximate Hessian, we developed a physics-inspired modification to the standard BFGS algorithm that systematically filters this numerical noise.

The proposed strategy, implemented as the HERO package, relies on a conditional block-diagonalization scheme. Our benchmarks across diverse chemical systems (ranging from surface adsorbates on Pt(111) to defective bulk oxides) demonstrate that this approach effectively stabilizes the optimization trajectory. Crucially, we found that an isotropic background stiffness injection, which repopulates off-diagonal blocks with small positive constants rather than zeroing them completely, mitigates the excessive conservatism of diagonal dominance and further accelerates convergence.

Designed with a modular architecture within the ASE Library, this method offers a lightweight and transferable solution compatible with existing codes. Unlike black-box machine learning potentials that face transferability issues outside their training domain, HERO operates entirely on ab initio principles, requiring no prior data generation. By eliminating the need for complex parameter tuning or domain-specific training, HERO provides a robust tool for high-throughput computational workflows where autonomous stability is paramount.

Looking forward, the success of HERO confirms that algorithmic intervention at specific force thresholds is a critical “control knob” for stabilizing DFT calculations. Building on this, we envision a transition from the current uniform mean-field coupling to a more physically informed strategy. Future iterations could integrate physical priors such as bond-stiffness estimates derived from inter-atomic distances or coordination environments to construct a structured preconditioning matrix rather than a uniform diagonal one. Furthermore, there is significant potential in hybridizing this approach with advanced machine learning surrogate models (such as CHGNet or MACE) or empirical universal simple potentials (e.g., Morse or Lennard-Jones variants). By utilizing the analytical Hessians from these lightweight potentials as a baseline reference during the reset phase, we can inject robust physical intuition into the optimization process, effectively guiding the ab initio search with a “reasonable guess” that is computationally negligible yet topologically accurate.

Additionally, while our discussion has primarily framed “Hessian pollution” in the context of smooth, higher-order anharmonicities, it is crucial to note that real DFT potential energy surfaces are not strictly continuous. Phenomena such as spin-state transitions (e.g., in transition metal complexes) introduce genuine discontinuities and stochastic force jumps during ionic relaxation. From an algorithmic perspective, both smooth anharmonicity and true discontinuities represent severe violations of the local quadratic approximation. Standard BFGS struggles to recover from the non-reproducible gradient shocks caused by spin-state crossings. However, the block-diagonalization reset in HERO is intrinsically suited to address these discontinuous events. By periodically purging the iteration history, HERO effectively discards the corrupted, pre-transition curvature information, allowing the optimizer to rapidly re-adapt to the new PES branch. Thus, the HERO methodology generalizes beyond continuous anharmonicity to suppress pollution originating from non-differentiable PES features.

To facilitate community adoption and further development, the source code for this method is openly available at https://github.com/herodft-2026/beta.