Born for the Task: Rethinking Quantum Chemistry with Foresighted Agentic Computing

Haozhi Han, Junjie Yang, Ruge Zhang, Zihe Huang, Pengyi Xu, Bo Zhang, Yunquan Zhang, Ting Cao, Yunxin Liu, Yifeng Chen, Kun Li

This paper introduces BORN, a framework that shifts the paradigm of scientific computing from "adapting problems to existing programs" to "building programs born for each task." By combining predictive modeling with AI coding agents, BORN synthesizes specialized, high-performance quantum chemistry programs on demand, achieving massive speedups over general-purpose software.

TL;DR

BORN is a "foresighted agentic computing" framework that automatically generates task-specific quantum chemistry code by predicting the error and runtime of different algorithms before they are even run. This approach allows it to find highly efficient strategies that general-purpose software misses, delivering up to 173$\times$ speedups on large-scale molecular simulations.

What Problem Does This Paper Address?

Quantum chemistry (QC) is essential for understanding matter at the electronic level, but large-scale calculations are often prohibitively expensive. Most researchers rely on general-purpose software packages (like PySCF or ORCA) that use "one-size-fits-all" preset schemes. While reliable, these presets are rarely optimal for a specific molecule, basis set, or hardware configuration.

Recent AI "coding agents" can write task-specific code, but they face a "blind optimization" problem: you can't tell if a complex computational strategy is both accurate and fast enough until you actually run it at full scale. For massive systems, these trial runs are too costly, leaving researchers stuck with inefficient but "safe" general-purpose defaults.

Methods

BORN addresses this through a three-stage process:

  1. Component-Wise Unfolding: It breaks down standard QC "schemes" into independent, interchangeable algorithmic components (e.g., different ways to calculate Coulomb or Exchange interactions). This creates a vast "strategy space" far larger than what standard packages offer.
  2. Target-Scale Foresight: This is the "aha" moment. BORN predicts the numerical error and runtime of every possible strategy at the target scale without actually running them.
  3. Error Prediction: It uses small "proxy" molecules to fit a local-error model, extrapolating how error grows with system size.
  4. Runtime Prediction: It counts the "workload" (operations) for the target molecule and multiplies it by measured hardware "throughput" (from microbenchmarks).
  5. Agent-Driven Compilation: Once the best strategy is selected from a predicted Pareto frontier, LLM-based coding agents compile it into a specialized program. The agents use the component-level predictions to focus their optimization efforts on the actual bottlenecks.
Figure 2. Overview of BORN. Given a task, BORN (a) unfolds package schemes into a strategy space S, where one strategy θ ∈S is one pairing per SCF stage; (b) predicts the target-scale error and runtime of every strategy from proxies and microbenchmarks and selects the fastest θ∗within ε; and (c) has coding agents compile θ∗into a task-specific program.

Datasets

The authors evaluated BORN on several challenging tasks:

  • Linear Alkanes: A series from $C_2H_6$ to $C_{862}H_{1726}$ (up to 50,024 basis functions) used to test scaling and extrapolation.
  • Ubiquitin (PDB 1UBQ): A globular protein with 1,231 atoms.
  • B-DNA Duplex: A large, double-helix structure with nearly 50,000 atomic orbitals.

Key Insights and Ideas

  • Predictability of Error: Numerical errors in many QC approximations accumulate locally. This means they grow linearly with system size, making them surprisingly predictable through extrapolation from small systems.
  • Separation of Workload and Throughput: You don't need to run a full simulation to know how long it will take. By counting the mathematical operations required (workload) and knowing how fast the hardware can do those specific operations (throughput), you can accurately forecast runtime.
  • Task-Specific Dominance: The "best" algorithm changes depending on the task. For example, a strategy that works best for a long, chain-like alkane on a CPU might be terrible for a globular protein on a GPU. BORN's ability to "re-pair" algorithms for each task is its secret weapon.

Key Results

BORN demonstrated dramatic performance gains over state-of-the-art general-purpose baselines:

  • Alkane (50k basis functions): Finished in 1.41 hours on a single CPU node—77$\times$ faster than the estimated baseline runtime. Even when including the time spent by the AI agents to develop the code, it was still 9.8$\times$ faster.
  • Ubiquitin: Ran on 1 GPU in 2.1 hours, achieving the same order of performance as the specialized package Mako running on 64 GPUs.
  • B-DNA Duplex: Reduced the calculation time from an estimated two months (baseline) to just 8.1 hours (a 173$\times$ speedup).
Figure 1. Comparison of general-purpose packages vs. BORN's task-specific approach.

Limitations and Future Work

While impressive, the authors note several areas for growth:

  • Physical Models: The current work focuses on Hartree-Fock (HF) calculations. Extending BORN to more complex models like Density Functional Theory (DFT) or post-HF methods is a logical next step.
  • Uncertainty: Foresight relies on predictable error and cost. Further research into uncertainty propagation through the self-consistent field (SCF) iterations would make the framework more robust.
  • Hardware Topologies: Future work could explore mapping these specialized algorithms onto more complex, distributed hardware setups beyond single-node CPU/GPU systems.

Summary updated

Abstract

Quantum chemistry relies on general-purpose software, whose generality leaves many large-scale calculations beyond practical resource budgets. Coding agents make task-specific programs cheap to write, but not efficient ones easy to find: whether a computational strategy is accurate and fast enough becomes clear only after it actually runs at the target scale. We introduce BORN, a foresighted agentic computing framework that synthesizes high performance quantum chemistry programs on demand. BORN anticipates the behavior of each strategy before execution, extrapolating its error from representative small systems and predicting its runtime from the target-scale workload and measured hardware throughputs. Building on these predictions, BORN unfolds the preset schemes of existing packages into independently configurable algorithmic components, selects the fastest strategy within the error tolerance from the predicted accuracy-runtime Pareto frontier, and guides coding agents to compile it with component-level performance predictions. For a Hartree-Fock calculation with 50,024 basis functions, BORN finishes in 1.41h on a single CPU node, 77$\times$ faster than the estimated runtime of a general-purpose baseline and still 9.8$\times$ faster with development time included. On a single GPU, BORN completes the ubiquitin calculation in 2.1,h, the same order of runtime as the GPU-accelerated package Mako on 64 GPUs, and shortens the B-DNA duplex calculation from an estimated two months to 8.1,h (173$\times$).
BibTeX
@misc{han2026born,
  author = {Haozhi Han and Junjie Yang and Ruge Zhang and Zihe Huang and Pengyi Xu and Bo Zhang and Yunquan Zhang and Ting Cao and Yunxin Liu and Yifeng Chen and Kun Li},
  title = {{Born for the Task: Rethinking Quantum Chemistry with Foresighted Agentic Computing}},
  year = {2026},
  eprint = {2611.22897},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.22897},
}
Figure