betaFeedback

WorksComputer Science

El Agente Forjador: Task-Driven Agent Generation for Quantum Simulation

Abstract

AI for science promises to accelerate the discovery process. The advent of large language models (LLMs) and agentic workflows enables the expediting of a growing range of scientific tasks. However, most of the current generation of agentic systems depend on static, hand-curated toolsets that hinder adaptation to new domains and evolving libraries. We present El Agente Forjador, a multi-agent framework in which universal coding agents autonomously forge, validate, and reuse computational tools through a four-stage workflow of tool analysis, tool generation, task execution, and iterative solution evaluation. Evaluated across 24 tasks spanning quantum chemistry and quantum dynamics on five coding agent setups, we compare three operating modes: zero-shot generation of tools per task, reuse of a curriculum-built toolset, and direct problem-solving with the coding agents as the baseline. We find that our tool generation and reuse framework consistently improves accuracy over the baseline. We also show that reusing a toolset built by a stronger coding agent can reduce API cost and substantially raises the solution quality for weaker coding agents. Case studies further demonstrate that tools forged for different domains can be combined to solve hybrid tasks. Taken together, these results show that LLM-based agents can use their scientific knowledge and coding capabilities to autonomously build reusable scientific tools, pointing toward a paradigm in which agent capabilities are defined by the tasks they are designed to solve rather than by explicitly engineered implementations.

Introduction

Automating scientific research has long been a central aspiration of the scientific community. Large language models (LLMs) ([12, 1, 31] (Anthropic 2024)) and LLM-based agents ([28, 69] (Anthropic 2024)) have brought this vision closer to reality, demonstrating emergent physical and chemical reasoning ([46, 44]), autonomous scientific research capabilities ([11, 43, 52]), and sophisticated reasoning about experiment execution ([13, 76 Darvish et al.,]) 2024; [60]. Building on these advances, domain-specific scientific agents now achieve strong performance on specialized tasks through expert-designed tools and workflows [70, 54] (Zou et al. 2025). Our group has developed several agents of this type under the EL AGENTE umbrella which span quantum chemistry [52, 9] (Zou et al. 2025), quantum dynamics simulations [23], solid-state simulations [40], and molecular structure manipulation and editing [15]. However, these systems require substantial human effort to design, configure, and maintain: each new domain or computational method necessitates significant engineering to adapt existing systems or build new ones from scratch.

The root cause is that traditional agent architectures treat their toolsets as static components. Tools must be manually implemented and integrated before deployment, and when new techniques emerge, software libraries evolve, or research questions shift to adjacent domains, human developers must intervene. This rigid paradigm creates a critical bottleneck: the pace of scientific agent development cannot keep up with the diversity and evolution of scientific research needs. What is needed is an architecture in which agents can autonomously generate, validate, organize, and compose tools, so that the toolset co-evolves with the research problems it serves.

We introduce EL AGENTE FORJADOR (“The Forging Agent”), a multi-agent system that automates not only scientific problem-solving but also the generation of the specialized tools it requires (see Figure 1). Rather than relying on a fixed toolkit, EL AGENTE FORJADOR dynamically creates, tests, refines, and composes tools in response to task requirements, adapting to new challenges without human intervention in tool generation. The system is organized around a four-stage agentic workflow, namely (tool analysis, tool generation, task execution, and solution evaluation), which iterates until all task criteria are satisfied.

Overview of El Agente Forjador

Figure 1. Overview of EL AGENTE FORJADOR. (A) We evaluate our system on quantum chemistry and quantum dynamics tasks, which span molecular structure optimization, thermochemistry & reactivity, many-body quantum dynamics, and quantum state preparation & control. (B) The FORJADOR workflow comprises four stages: tool analysis (decompose tasks and search existing toolset), tool generation (synthesize missing tools), task execution (compose tools and run pipelines), and solution evaluation (iteratively assess results). Tasks produce reports and reusable toolsets. (C) Software backend: coding agents and scientific software used in this work.

Our approach builds on the inherent power of coding agents [65, 5] (OpenAI 2025), which, designed for code development, have several features that can aid scientific discovery. The framework introduces several key architectural choices. All subagents are universal: every agent can generate scripts, execute computations, debug errors, and refine existing tools, enabling robust error recovery through mutual correction. A progressive disclosure mechanism and a dedicated toolset optimizer keep the growing library navigable by exposing only task-relevant tools and reorganizing tools into hierarchical categories. Finally, an automated solution evaluator drives iterative refinement by verifying bug-free execution, script completeness, simulation adequacy, and result completeness after each run.

We evaluate El Agente Forjador on two diverse benchmarks: (i) 13 undergraduate-level quantum chemistry tasks ([9] (Zou et al. 2025)) covering molecular structure optimization and thermochemistry & reactivity, and (ii) 11 quantum dynamics tasks ([23]) spanning many-body quantum dynamics and quantum state preparation & control.

Key Contributions.

  • We present El Agente Forjador, a multi-agent framework that autonomously solves undergraduate-level quantum chemistry ([9] (Zou et al. 2025)) and quantum dynamics ([23]) tasks by generating tools for these domains. We show that autonomous tool generation maintains or increases task accuracy relative to tool-free baselines, but incurs higher API cost due to the overhead of tool creation and refinement.

  • We show that curriculum learning and tool reuse effectively mitigate this cost: reusing curriculum-built tools, underpinned by progressive disclosure, reduces API cost by 33% to 78% and wall-clock time by up to 88% relative to zero-shot tool generation, while maintaining or improving accuracy. Because the toolset is built on a stronger model (Claude Opus 4.6) and reused by weaker ones, this constitutes a form of strong-to-weak knowledge transfer through tool interfaces: weaker models achieve up to 16.5 percentage points higher task success rate by composing well-tested tools that encode correct domain methodology.

  • We demonstrate cross-domain composability through two case studies: tools originally forged for quantum chemistry and quantum dynamics are composed to solve hybrid quantum-chemistry/quantum-dynamics tasks. This points toward a future in which scientific agents with broad, multi-domain capabilities can be assembled by composing tools forged across disciplines by El Agente Forjador.

Related Work

Scientific Agents Recent benchmarks confirm that frontier LLMs already possess strong scientific knowledge. For example, Claude Opus 4.6 ([7]) achieves 53.0% accuracy on the Humanity’s Last Exam (HLE) ([55]), which is a collection of expert-level questions spanning science, mathematics, and engineering that were deemed very hard for LLMs to solve. LLM-based scientific agents have been built on this foundation to automate scientific tasks. In quantum chemistry, El Agente Q ((Zou et al., 2025)) and El Agente Quntur ([52]) use a hierarchical memory framework to decompose natural language prompts into executable simulation tasks. In quantum dynamics, El Agente Cuántico ([23]) extends this paradigm to quantum simulation workflows spanning open-system dynamics and tensor-network methods. For solid-state simulations, El Agente Sólido ([40]) translates high-level scientific objectives into Quantum ESPRESSO ([21]) pipelines integrating density functional theory (DFT), phonon calculations, and machine-learning potentials, while DREAMS ([70]) pairs a central LLM planner with specialized subagents for structure generation, DFT convergence testing, and high-performance computing (HPC) scheduling. El Agente Gráfico ([9]) takes a complementary approach by encoding scientific workflows as type-safe execution graphs backed by dynamic knowledge graphs, separating the execution layer from LLM reasoning to reduce token cost and hallucination. Beyond chemistry, kk-agents ([13]) automates quantum computing laboratory experiments, and Lu et al. [43] demonstrates automation of machine learning research: the system generates research ideas, writes and executes experiments, and produces full papers that can pass peer-review by humans. Despite their success, most of these systems share a common constraint: their toolsets must be updated manually whenever new tasks, methods, or software versions arise.

Coding Agents Frontier LLMs have demonstrated strong software engineering capability, with mid-70% resolution rates on SWE-bench Verified ([33]) (e.g., Claude Opus 4.6: 75.60%, Gemini 3 Pro ([22]): 69.60%, GPT-5.2 ([58]): 72.8%, Kimi K2.5 ([64]): 70.80%). This capability has been composed into coding agents—systems that pair an LLM with terminal access and file-system interaction to autonomously write, execute, and debug code ([18]). Multiple coding-agent frameworks have emerged: Claude Code ([5]), Codex ((OpenAI, 2025)), Cursor ((Anysphere, 2023)), and OpenCode ([50]). Given the scientific knowledge of LLMs, coding agents are well-suited for scientific automation. They can reason about domain-specific computations while retaining their general-purpose coding and debugging capabilities.

Evolving Agents and Tool Creation A parallel line of research investigates agents that can extend their own capabilities by modifying themselves to achieve self-evolution. The self-evolving agent paradigm reframes agents as systems that iteratively update their memories, toolset, and architectures based on trajectory feedback to maximize long-term utility ([20]). Early tool-creation systems such as CRAFT and CREATOR used LLM prompting to synthesize new tools, with CRAFT discarding broken tools via execution feedback ([77]) and CREATOR enabling iterative refinement through manual execution ([56]). More recent systems, Alita ([57]) and ATLASS ([24]), perform need-based tool generation with capability checking against an existing toolset, augmented by web search and code-execution feedback loops.

Methods

EL AGENTE FORJADOR is a task-driven agent framework in which each task is solved with a toolset that can be generated and modified one the fly to meet the requirement of the task (see Figure 2). Rather than relying on a fixed toolset, the system expands its capabilities on demand. The system operates through a four-stage workflow (tool analysis, tool generation, task execution, and solution evaluation). Supporting this workflow are a tool generator that creates, tests, and iteratively refines reusable Python functions, a toolset optimizer that maintains hierarchical organization of the growing toolset, a task executor that carries out script generation, execution, and report compilation, and a solution evaluator that assesses task completion and drives iterative refinement. We implement this workflow with general-purpose coding agents that share a common agent workspace (see Figure 2), enabling failures encountered in one stage to be repaired by later stages without human intervention. We leverage state-of-the-art coding agents, specifically Claude Code [5], Codex (OpenAI, 2025), and OpenCode [50], as the underlying building blocks of our system.

Detailed system architecture of EL AGENTE FORJADOR

Figure 2. Detailed system architecture of EL AGENTE FORJADOR. The agent workspace (left) maintains a structured directory containing the task specification (question.md), the tool_smith/ and tools/ directories holding generated Python scripts and JSON metadata, and a report.md output file. Tool generation agents (centre top) comprise three roles: a tool analyzer that assesses task requirements and existing tool coverage, a tool generator that synthesizes new tools backed by package source code, and a tool reviewer that reviews and refines tools for correctness and alignment; a toolset optimizer refines tools. Task-solving agents (centre bottom) consist of a task executor that composes tools into executable pipelines and dispatches jobs via an MCP server, and a solution evaluator that validates outputs. Coding agent abilities (right) available to all agents include file read/modify, script execution, HPC job submission, and image viewing.

The Forjador workflow

Each run of El Agente Forjador begins with a task specified in natural language in a question.md file in the agent workspace. When a new task is provided, El Agente Forjador executes a multi-stage workflow in which each stage spawns a fresh coding agent session in the agent workspace with a different prompt.

  1. Tool analysis: For each task, the agent surveys the existing toolset in the workspace tools/ directory. It inspects available tools, reviews their source code, and determines whether they meet the task requirements. If gaps exist, the agent drafts a specification for the new tools that are needed.

  1. Tool generation: Given the specification of a new tool, the tool generator searches the source code of the scientific software required for the tool, implements the tool in Python, and writes test cases. It then iterates through a review–refinement loop until all tests pass. Details can be found in § 3.3.

  1. Task execution: Once all necessary tools are available, the agent writes task-specific execution scripts that compose the tools from the toolset. Specifically, the agent drafts Python scripts that import the required tools, configure input parameters, and orchestrate the computational pipeline. It then executes these scripts, monitors for errors, and iteratively debugs until the pipeline completes. Finally, the agent compiles the results into a report.md file that addresses the task specification. Details are provided in § 3.5.

  1. Solution evaluation: After execution, an automated evaluator assesses whether the generated report satisfies all task requirements and determines whether additional iterations are needed. If any criterion is not met, the evaluator produces a structured next-step plan for the subsequent iteration. This loop repeats until all criteria are satisfied or the iteration budget is exhausted. The evaluation criteria and mechanism are detailed in § 3.6.

Hierarchical Toolset with Progressive Disclosure. Each tool in El Agente Forjador is a Python file stored in a hierarchy of directories (see Figure 3). The hierarchical is built by the toolset optimizer, which we will introduce in § 3.4. In this way, the agent is not given all existing tools upfront. Instead, it discovers tools through progressive disclosure within this hierarchy. For instance, an agent working on molecular geometry optimization navigates into relevant categories such as molecular_geometry_processing/ and hartree_fock_calculations/, but does not see tools nested under unrelated branches like electronic_property_analysis/ unless the task requires them.

Toolset optimization and tool generation during a curriculum learning on quantum chemistry tasks

Figure 3. Toolset optimization and tool generation during a curriculum learning on quantum chemistry tasks. Left: A flat toolset at an early stage. Right: After optimization, existing tools (coloured lines) are reorganized into hierarchical subcategories based on functional similarity, and newly generated tools (green, labelled new) are added at the root awaiting future reorganization.

Curriculum Learning Through Task Sequencing. The persistent toolset across tasks naturally enables curriculum learning [10, 68]: when tasks are arranged from simple to complex, early agents generate foundational tools that later agents can directly reuse. For example: An early task, such as “optimize the geometry of methane” generates foundational tools for converting molecular strings (e.g., SMILES (Simplified Molecular-Input Line-Entry System) (Weininger, 1988)) to 3D structures and performing geometry optimization using Hartree–Fock (HF). A subsequent task, such as “compute the hydride abstraction energy of ethane”, reuses the structure generation and optimization tools but requires new tools to compute thermochemical properties. A later task such as “compute the pKapK_a of acetic acid in solution” reuses all prior tools and additionally generates tools for implicit solvation and Gibbs free energy corrections.

The goal of curriculum learning is to progressively build a toolset that covers the space of tasks in a given domain, so that future tasks can be solved primarily through tool reuse rather than repeated generation. This staged approach ensures that agents build on previously discovered knowledge, amortizing the cost of tool generation across tasks and thereby creating an increasingly capable toolset. As the toolset matures through the curriculum, the proportion of tasks requiring the generation of new tools diminishes. Importantly, later agents not only benefit from earlier tools but also refine them: when bugs are discovered during reuse, the universal agent capability enables on-the-fly debugging, improving tool quality over time without human intervention.

Tool Analyzer

The tool analyzer is responsible for translating a natural-language task into a concrete plan of which tools should be reused and which need to be generated. Given the task description and the current contents of the shared toolset, the analyzer inspects available tools, identifies the computational capabilities required by the task, and produces a structured analysis with three components: (i) a task analysis that decomposes the problem into its computational stages, links each stage to the tool that should perform it, and surfaces relevant domain considerations such as recommended methods, physical formulas, or common pitfalls; (ii) a list of existing tools to reuse, drawn from the current toolset; and (iii) a list of new tool requirements, each specified as an abstract contract — a name, a description of the desired functionality and the underlying package or method to use, and the expected input and output types — without committing to a concrete implementation.

Tool Generator

The tool generator is responsible for creating new tools when the tool analyzer deems existing ones are insufficient for a given task. Each generated tool is implemented as a standalone Python function with strict interface requirements and validation mechanisms. The generator operates in an isolated tool_smith/task_{id}/ directory within the agent workspace, where it drafts implementations and runs tests without affecting the shared toolset. Once a tool passes all tests, it is copied into the root of the shared tools/ directory, making it available for subsequent tasks. The generator follows an iterative refinement loop: it drafts an initial implementation based on task requirements, generates unit tests, executes these tests, analyzes failures, and regenerates the tool until all tests pass. A separate tool reviewer agent then reviews the tool for correctness, adherence to interface requirements, and alignment with domain-specific generation guidelines. The generator revises the implementation if the reviewer deems it unsatisfactory.

Local Source Browsing. When generating a tool, the tool generator is prompted to directly browse the site-packages directory, where Python packages are installed. We provide coding agents with precomputed navigation indexes that summarize each library’s module structure, import patterns, and common usage, enabling the agents to efficiently locate relevant functions without scanning entire packages. This design has two key advantages: (1) it enables tool generation against private or unreleased packages that have no public documentation, and (2) it guarantees that the agent references the exact interface of the installed version, avoiding outdated or version-mismatched information that is common in web-sourced documentation.

Strict Tool Interface Requirements. To ensure tools are reliable, composable, and debuggable, we enforce several constraints on all generated tools by prompts to the tool generator and tool reviewer:

  • No ad-hoc tools. Every tool must be a general-purpose reusable utility, not a task-specific script. The tool analyzer enforces this via an LLM-based validator that rejects proposals containing one-time scripts unlikely to be reused. This constraint ensures the toolset remains reusable across the curriculum and prevents redundant generation of near-identical single-purpose tools.

  • No silent failures or fallback behaviour. Tools must raise explicit exceptions when encountering errors rather than returning default values, suppressing warnings, or attempting automatic recovery. This strict error propagation is essential for enabling downstream debugging: when a tool fails during execution, the calling agent receives clear diagnostic information and can inspect, modify, and repair the tool. Silent failures would mask bugs and prevent the self-healing behaviour central to our approach.

  • Pydantic validation for type safety. All tool inputs and outputs are validated using Pydantic, a Python library that provides runtime type checking and data validation through declarative schemas. Each tool defines input parameters as BaseModel classes with explicit types, constraints, and documentation. This serves multiple purposes: (1) it enables agents to reason precisely about tool interfaces when composing multi-step workflows, (2) it catches type errors at runtime before they propagate through complex pipelines, and (3) it provides self-documenting code that agents can parse to understand tool capabilities.

Skill-Based Generation Guidelines. The tool generator can optionally leverage a collection of skills [5, 36]—curated markdown documents that encode domain-specific best practices, common patterns, and expert preferences. When generating tools, agents can read relevant skill documents to inform their implementations. For example, a skill document might direct the agent to use TenPy for density matrix renormalization group (DMRG) calculations instead of a from-scratch NumPy implementation, specify the correct pulse optimization interface in QuTiP, or provide a detailed reference for diagnosing imaginary vibrational frequencies in geometry optimizations. This mechanism serves as an important way to compensate for gaps in an LLM’s domain knowledge: rather than relying solely on parametric knowledge from training data, agents can consult authoritative, user-curated guidance at generation time. This allows EL AGENTE FORJADOR to generate tools aligned with established scientific practices. The generation guidelines used in our experiments are provided in Appendix § 29.

Toolset Optimizer

As agents solve more tasks and the toolset grows, maintaining navigability and context efficiency becomes critical. The tool structure optimizer is a separate coding agent that is triggered at the beginning of each new task, before tool analysis and generation. It recursively scans the tools/ directory and creates new subdirectories to group tools or directories when any directory exceeds a size threshold, ensuring that agents can quickly locate relevant tools without overwhelming their context windows.

The optimizer operates through a simple heuristic: when a tool category directory exceeds a threshold number of tools (10 in our configuration), it analyzes tool names, docstrings, and dependency patterns to identify natural subcategories. It then creates new subdirectories, moves tools accordingly, and updates import paths and documentation. Figure 3 illustrates this process: an initially flat toolset is reorganized into subcategories, while newly generated tools are placed at the root awaiting future reorganization.

In addition to reorganizing, the optimizer can identify functionally overlapping tools and merge them into unified implementations, thereby preventing unnecessary expansion of the tool library as multiple agents independently generate similar utilities. This feature was not enabled in our benchmark runs, as the toolsets remained small enough that merging introduced unnecessary overhead. A full description is provided in Appendix § 26.

Task Executor

Once all required tools are available, the task executor is invoked to generate and execute the solution pipeline. It receives the original task description, along with the tool analysis plan produced by the tool analyzer, and operates as a general-purpose coding agent within the agent workspace.

Script Generation and Execution. The coding agent is prompted with a structured instruction that includes the task specification, a navigation index of available Python packages, and the current contents of the tools/ directory. Guided by these inputs, the agent designs a multi-phase scripting strategy: it decomposes the computation into logical stages (e.g., preprocessing and input validation, main simulation, and result aggregation), each implemented as a separate Python script. The agent is prompt to first tests its pipeline on a small subset of inputs (two to three molecules or parameter points) to catch errors early, then scales to the full dataset once correctness is verified. Scripts are executed via the Model Context Protocol (MCP) execution interface (described below), which dispatches jobs to either a local subprocess or an HPC scheduler depending on the environment. During execution, the agent monitors outputs and logs, iteratively debugging failures until the pipeline completes. Because every agent has full write access to the tools/ directory, it can also debug and modify existing tools on the fly when a reused tool produces incorrect results or raises unexpected errors, enabling self-repair without re-entering the tool generation phase. The agent is prompt to compiles results into a report.md in the workspace that addresses each aspect of the original task specification. The presence and completeness of this report serves as the primary indicator of success for the iteration.

Model Context Protocol for Command Execution. Scientific computing often requires executing long-running computational jobs on HPC clusters with workload management systems like SLURM ([75]). To handle this seamlessly, we integrate an MCP server ([4]) that provides agents with robust command-execution capabilities across heterogeneous computational environments. In HPC environments with SLURM, it automatically generates job submission scripts with appropriate resource requests, submits jobs to the scheduler and retrieves results. In local or cloud environments without job schedulers, it executes commands as subprocesses. This abstraction allows agents to focus on scientific logic rather than infrastructure details.

Solution Evaluator

The solution evaluator is a coding agent that determines whether a generated report satisfies the task requirements; if it does not, the task executor is re-invoked with a structured next-step plan to refine the solution, enabling iterative improvement without human intervention. It reads both the task specification (question.md) and the generated report (report.md), and is prompted to browse the workspace to collect additional context to prevent the executor from cheating. It outputs a structured evaluation.json with boolean flags across five dimensions: bug_need_fix (whether bugs are detected that require fixing), script_complete (whether all required computations are implemented), further_simulation_needed (whether additional simulation is required), result_complete (whether all required deliverables are present, such as data tables, visualizations, and interpretations), and next_step_needed (whether any of the above conditions are unmet). When further work is required, it also provides an actionable next_step_plan in text, which is incorporated into the updated task specification for the next iteration. This evaluation-refinement loop runs for a maximum of five iterations, after which the task is marked as failed if requirements are still unmet. The detailed prompt can be found in Appendix § 21.

Results

We evaluate EL AGENTE FORJADOR across two capability domains: quantum chemistry and quantum dynamics. For quantum chemistry tasks, agents are required to use PySCF ([61, 62]) as the primary electronic structure backend, supplemented by RDKit ([41]) and the Atomistic Simulation Environment (ASE) Hjorth Larsen et al., [27]. For quantum dynamics tasks, the required software includes CUDA-Q NVIDIA, [48] and Qiskit Javadi-Abhari et al., [32] for quantum circuit simulation, Tequila Kottmann et al., [38] for variational quantum algorithms, QuTiP Johansson et al., [34, 35] for open quantum system dynamics, and TenPy Hauschild and Pollmann, [25] for tensor network simulations.

Quantum Chemistry

We first benchmark our system on 13 quantum chemistry tasks, derived from the benchmark set of El Agente Q and El Agente Gráfico, consisting of undergraduate-level tasks, spanning six categories: organic compounds property calculation, inorganic compounds property calculation (both covering geometry optimization, HOMO–LUMO gap, point group symmetry, and Mulliken charges), relative carbocation stability (ΔH\Delta H and ΔG\Delta G for hydride abstraction), cycloalkane ring strain energies (C3–C8), pKapK_a prediction with implicit solvation and proton calibration, and time-dependent density functional theory (TD-DFT) absorption spectra (S1 energy, oscillator strength, S1–T1 gap) Casida, [14]. Most categories are tested at two difficulty levels: Level 1 typically provides simpler or more scaffolded inputs, whereas Level 2 requires agents to handle more complex cases. Additionally, we introduce a Level 0 task for the organic compounds category, a single-molecule analysis of caffeine, to provide a simpler entry point for curriculum learning, allowing the agent to bootstrap foundational tools before tackling the harder tasks (see Table 1).

CategoryLevels (L)Task
Organic0/1/2Geometry optimization of molecules; report energy, point group, dipole, MO analysis, HOMO–LUMO gap, Mulliken charges, and Hessian check. L0: caffeine; L1: 3 organic molecules from SMILES; L2: 6 organic molecules from XYZ
Inorganic1/2Same workflow as organic plus structure visualization. L1: Cr(CO)6_6, ClF3_3, fluorophosphate from SMILES; L2: 6 inorganic/organometallic species from XYZ
Carbocations1/2Calculate ΔH\Delta H and ΔG\Delta G for the reaction R–H →\to R+^{+} + H−^{-} across 9 species (methane through toluene). L1: XYZ geometries provided; L2: agent generates 3D geometries from SMILES
Ring strain1/2Calculate ring strain energies of cycloalkanes (n=3n=3–8) via isodesmic reactions with frequency corrections. L1: reaction scheme given, cyclohexane reference; L2: agent determines scheme and reference
pKapK_a1/2Calculate pKapK_a of acid in water. L1: acetic acid; L2: chlorofluoroacetic acid with proton solvation calibration against three known acids
TD-DFT1/2TD-DFT on 3 chromophores; report S1_1 energy, oscillator strength, S1_1–T1_1 gap. L1: XYZ files and methodology hint provided; L2: no methodology hint

Table 1. Quantum chemistry benchmark: 13 tasks across 6 categories (PySCF), derived from the benchmark set of El Agente Q (Zou et al., 2025) and El Agente Gráfico [9]. Each task category is divided into levels of increasing difficulty. Full task prompts are provided in Appendix § 10.

Quantum Dynamics

The quantum dynamics benchmark comprises 11 tasks drawn from the El Agente Cuántico. These tasks span three categories: (i) quantum circuit implementation and quantum control, including Bell state preparation, variational quantum eigensolver (VQE) dissociation curves Peruzzo et al., [53]; Tilly et al. [66], noisy channel characterization, and GRAPE-based optimal control of a three-level system Khaneja et al., [37]; (ii) open quantum system dynamics, including Fenna-Matthews-Olson (FMO) exciton dynamics simulated via hierarchical equations of motion (HEOM) Adolphs and Renger, [2]; Tanimura [63], transverse-field Ising model magnetization, and Lindblad evolution Lindblad, [42]; and (iii) many-body simulations, including Floquet kicked Ising dynamics, Floquet dynamics with time-dependent density matrix renormalization group (TD-DMRG) White and Feiguin, [73]; Vidal [67], and phase diagram computation via DMRG White, [72] (see Table 2).

Table 2 Quantum dynamics benchmark: 11 tasks across 3 categories, derived from the benchmark set of El Agente Cuántico ([23]). Full task prompts are provided in Appendix § 10.

CategoryMain softwareTask
State Prep. & ControlCUDA-QBell state preparation and verification from measurements
TequilaH₂ VQE dissociation curve compared against Full-CI
QiskitDecay of Bell states under depolarizing channels
QuTiPGRAPE optimal control of a three-level system
Open Quantum SystemsQuTiPUnitary vs. Lindblad dynamics of a single qubit
QuTiPFMO exciton dynamics via HEOM at T=300T = 300 K and 77 K
TenPyGibbs state of 1D Hubbard chain via imaginary-time evolution
CUDA-QMagnetization dynamics in transverse-field Ising model
Many-Body SystemsCUDA-QDynamics of Floquet kicked Ising chain from a random state
TenPyDynamics of disordered Floquet spin chain via TD-DMRG
TenPyPhase transition in the cluster model via DMRG

Table 2.

Evaluation

To evaluate El Agente Forjador, we compare three operating modes across five coding agent setups to show the effect of tool generation and curriculum learning.

  • Zero-shot (ZS): Each problem is solved independently with an empty toolset; no prior tools are available. The four-stage agent workflow is active, so the agent forges an independent toolset for each task, exercising the tool generator and iterative evaluator from scratch.

  • Tool reuse (TR): Each problem is solved with access to a toolset constructed via curriculum learning using Claude Opus 4.6 (via Claude Code) across all problems in the benchmark. The same toolset is then reused by in all the setups. Tool generation is disabled; the tool analyzer remains active, enabling the agent to discover relevant tools through progressive disclosure and compose them.

  • Evaluator only (EO): The agent directly solves the problem without invoking the tool builder or accessing any existing toolset. Solutions are still verified by the automated solution evaluator (§ 3.6). This mode serves as a baseline that reflects the raw capability of the underlying coding agent without tool scaffolding.

Each mode–setup combination is repeated 3 times; for tool reuse (TR), each repetition draws from an independently curriculum-learned toolset from Claude Opus 4.6 (via Claude Code) with a fixed order of tasks (see Appendix § 24.§ 1). Across 24 tasks, 3 operating modes, 5 coding agent setups, and 3 repetitions, the evaluation encompasses 1,080 total task runs. Task success is evaluated against explicit criteria for each task, based on the numerical results and methodology adopted in the solutions. Each task is scored along two dimensions, accuracy and methodology, using per-criterion rubrics detailed in Appendix Tables 7, 8, 9, and 10. The combined score for each task is the mean of the accuracy and methodology subscores. For example, accuracy criteria check whether computed energies fall within specified tolerances of reference values and whether required physical quantities are reported, while methodology criteria verify that the correct computational workflow was followed.

Overall Performance. Table 3 summarizes overall performance across all five agentic setups and both benchmarks. On quantum chemistry, zero-shot scores range from 65.7% (Kimi K2.5 via OpenCode) to 86.7% (Gemini 3.1 Pro via OpenCode), with an average of 81.5% across models. On quantum dynamics, zero-shot scores are higher, ranging from 83.9% (Kimi K2.5 via OpenCode) to 98.5% (Claude Sonnet 4.6 via Claude Code), with an average of 91.5%, indicating that frontier coding agents already possess substantial scientific reasoning capability for quantum dynamics tasks out of the box.

Table 3 Average combined score (mean of accuracy + methodology/2 per question, averaged over 3 runs; ± denotes the sample standard deviation across the 3 runs; bold = best setup (ZS/TR/EO) for each model within each benchmark). Tool reuse (TR) yields the highest average on both benchmarks, with the largest gains for weaker models (e.g., Kimi: +16.5pp on quantum chemistry). Zero-shot (ZS) tool generation consistently outperforms the evaluator-only (EO) baseline, confirming that tool generation contributes beyond the evaluation loop alone.

ModelQuantum ChemistryQuantum Dynamics
ZSTREOZSTREO
Claude Opus 4.6 (via Claude Code)86.6% ±4.987.9% ±2.680.4% ±3.197.3% ±1.597.1% ±2.096.4% ±1.1
Claude Sonnet 4.6 (via Claude Code)85.4% ±1.584.4% ±1.784.2% ±1.698.5% ±1.197.7% ±0.297.2% ±1.1
GPT-5.2-Codex (via Codex)83.2% ±3.088.1% ±2.577.1% ±4.386.1% ±1.588.9% ±1.286.8% ±2.1
Gemini 3.1 Pro (via OpenCode)86.7% ±2.186.3% ±4.880.3% ±2.591.6% ±0.490.7% ±3.392.3% ±3.6
Kimi K2.5 (via OpenCode)65.7% ±15.082.2% ±5.861.5% ±7.683.9% ±5.791.5% ±4.984.0% ±4.7
Average81.5% ±3.785.8% ±2.476.7% ±1.591.5% ±1.093.2% ±1.591.3% ±0.8

Table 3.

The pattern across conditions differs between the two benchmarks. On quantum dynamics, all three setups achieve high scores (91.3–93.2% average), and the evaluator-only (EO) baseline matches or exceeds zero-shot (ZS) for three of the five models (GPT-5.2-Codex via Codex, Gemini 3.1 Pro via OpenCode, and Kimi K2.5 via OpenCode), suggesting that the iterative evaluation loop alone is largely sufficient when tasks are more self-contained. By contrast, on quantum chemistry—where tasks demand multi-step workflows, domain-specific methodology, and precise numerical outputs—EO scores drop substantially (76.7% average vs. 81.5% ZS), confirming that tool generation and reuse contribute meaningfully beyond the evaluation loop on harder, more complex tasks.

Per-task breakdowns (see Appendix § 24.§ 1) reveal systematic difficulty patterns. On quantum chemistry, Ring Strain L2 (66.4% ZS average) is the hardest task: it requires agents to independently determine an isodesmic reaction scheme, perform geometry optimizations and frequency calculations for eight cycloalkanes plus reference molecules, and apply thermodynamic corrections. This is a multi-step pipeline in which a single methodological error (e.g., a missing zero-point energy correction) cascades through all downstream results. Tool reuse raises this to 76.1%, because the curriculum-built tools already encode the correct thermochemical workflow. Similarly, pKapK_a L2 (78.0% ZS, 77.0% TR) demands implicit solvation modeling and proton solvation energy calibration against known acids, a domain-specific technique that weaker models frequently fail to derive from scratch but execute reliably when encoded in reusable tools. In quantum dynamics, the Gibbs/Hubbard task (71.7% ZS, 75.1% TR) requires imaginary-time DMRG evolution with TenPy, where convergence depends on careful bond-dimension and time-step choices; tool reuse provides pre-validated parameter choices that reduce much of the trial-and-error exploration.

Tool-Editing in Execution. We designed the task executor to have full write access to tool files for on-the-fly self-repair. We found this mechanism is actively used in some setups: Kimi K2.5 via OpenCode and Gemini 3.1 Pro via OpenCode edit or create tool files in over 40% of iterations in the zero-shot setting, while the Claude Code models rarely need to (1–6%), reflecting the higher quality of their initially generated tools (Appendix § 27). In the tool-reuse setting, edits drop to near zero across all models because the pre-built library requires little correction.

Tool Reuse Consistently Reduces Cost. A central motivation of curriculum learning is to amortize the cost of tool generation across tasks: once foundational tools are forged by an early, stronger agent, later agents skip the expensive tool-generation loop entirely and proceed directly to tool composition. This design yields substantial LLM API cost reductions across both benchmarks and all five models. On quantum dynamics (see Table 12), average cost reductions range from 62.7% for Claude Opus 4.6 via Claude Code to 77.9% for Kimi K2.5 via OpenCode, with a mean reduction of 66.9% across all models. On quantum chemistry (see Table 11), reductions are more modest but still consistent, ranging from 33.2% for Claude Sonnet 4.6 via Claude Code to 64.2% for Kimi K2.5 via OpenCode, with a mean of 49.6%. The effect is most pronounced for weaker models: Kimi K2.5 via OpenCode achieves the largest cost savings on both benchmarks, suggesting that tool reuse disproportionately benefits models that would otherwise spend more tokens on exploratory reasoning and re-derivation, precisely the token-intensive tool generation and iterative testing phases that the curriculum library eliminates.

Model / RunTime (min) ZSTime (min) TRTime (min) Δ\Delta%Time (min) EOCost (USD) ZSCost (USD) TRCost (USD) Δ\Delta%Cost (USD) EOAvg Score ZSAvg Score TRAvg Score EO
Claude Code (Opus 4.6)
R181.593.2+14.3%66.3$5.98 | $4.51-24.5%$1.43 | 88.0% | 90.3% | 78.7%
R277.652.1-32.8%79.7$5.25 | $1.73-67.1%$1.81 | 81.2% | 88.4% | 83.9%
R371.554.5-23.7%76.0$5.44 | $1.84-66.1%$1.59 | 90.7% | 85.1% | 78.5%
Avg76.866.6-13.3%74.0$5.56 | $2.69-51.5%$1.61 | 86.6% | 87.9% | 80.4%
Claude Code (Sonnet 4.6)
R1115.373.2-36.5%63.2$7.02 | $5.33-24.1%$0.97 | 83.6% | 84.2% | 85.2%
R269.650.3-27.7%53.6$2.62 | $1.82-30.6%$1.07 | 86.5% | 86.3% | 85.0%
R361.065.2+6.8%75.7$2.84 | $1.20-57.9%$1.17 | 85.9% | 82.8% | 82.4%
Avg82.062.9-23.3%64.2$4.16 | $2.78-33.2%$1.07 | 85.4% | 84.4% | 84.2%
Codex (GPT-5.2-Codex)
R1121.482.4-32.2%191.4$2.31 | $0.97-58.0%$0.91 | 86.2% | 89.2% | 73.4%
R2130.5148.9+14.1%261.8$2.36 | $1.07-54.9%$1.12 | 83.0% | 85.3% | 81.8%
R3105.5127.6+21.0%100.3$1.92 | $0.85-55.6%$0.78 | 80.3% | 89.8% | 76.0%
Avg119.1119.6+0.4%184.5$2.20 | $0.96-56.2%$0.94 | 83.2% | 88.1% | 77.1%
OpenCode (Gemini 3.1 Pro)
R1130.096.1-26.1%105.2$4.33 | $1.84-57.5%$1.48 | 84.3% | 89.6% | 83.0%
R2138.973.8-46.9%106.8$4.38 | $1.31-70.0%$2.27 | 87.2% | 80.8% | 80.1%
R3132.2149.7+13.2%235.7$4.62 | $3.05-33.9%$2.40 | 88.4% | 88.4% | 78.0%
Avg133.7106.5-20.3%149.2$4.44 | $2.07-53.4%$2.05 | 86.7% | 86.3% | 80.3%
OpenCode (Kimi K2.5)
R1193.593.8-51.5%336.4$1.49 | $0.63-57.9%$0.73 | 72.0% | 88.8% | 55.0%
R2498.5102.4-79.5%145.3$2.16 | $0.74-65.9%$0.43 | 48.6% | 77.9% | 59.6%
R3136.595.8-29.9%102.0$1.57 | $0.51-67.8%$0.38 | 76.5% | 79.8% | 69.8%
Avg276.297.3-64.8%194.6$1.74 | $0.62-64.2%$0.52 | 65.7% | 82.2% | 61.5%

Table 11. Zero-shot vs. Tool-reuse vs. Evaluator Only: Quantum Chemistry

Model / RunTime (min)Cost (USD)Avg Score
ZSTRΔ%\Delta\%EOZSTRΔ%\Delta\%EOZSTREO
Claude Code (Opus 4.6)
R1161.316.0-90.1%150.8$7.77 | $2.78-64.2%$1.49 | 98.9% | 99.4% | 97.7%
R2114.517.5-84.7%141.5$3.97 | $1.62-59.3%$1.44 | 97.1% | 95.5% | 96.1%
R3109.312.2-88.9%88.8$3.69 | $1.36-63.2%$1.70 | 96.0% | 96.3% | 95.5%
Avg128.415.2-88.1%127.1$5.15 | $1.92-62.7%$1.55 | 97.3% | 97.1% | 96.4%
Claude Code (Sonnet 4.6)
R182.338.0-53.8%63.6$9.28 | $2.97-67.9%$0.82 | 99.0% | 97.9% | 97.9%
R252.611.4-78.3%74.6$2.75 | $1.31-52.3%$0.70 | 97.3% | 97.5% | 95.9%
R362.049.1-20.8%27.0$3.24 | $0.79-75.6%$0.96 | 99.4% | 97.8% | 97.8%
Avg65.732.9-49.9%55.0$5.09 | $1.69-66.8%$0.83 | 98.5% | 97.7% | 97.2%
Codex (GPT-5.2-Codex)
R131.234.4+10.4%18.5$2.36 | $0.52-77.9%$0.85 | 84.6% | 87.5% | 88.0%
R290.226.3-70.8%19.4$1.70 | $0.65-61.5%$0.79 | 87.6% | 89.6% | 88.0%
R365.939.1-40.7%19.0$2.34 | $0.52-77.7%$0.77 | 86.2% | 89.5% | 84.4%
Avg62.433.3-46.7%18.9$2.13 | $0.56-73.5%$0.80 | 86.1% | 88.9% | 86.8%
OpenCode (Gemini 3.1 Pro)
R140.165.7+63.8%14.7$2.21 | $0.77-65.2%$0.68 | 91.4% | 93.3% | 96.3%
R226.621.4-19.5%13.7$2.02 | $0.69-65.9%$0.78 | 92.1% | 91.9% | 89.4%
R340.835.1-14.0%18.0$2.29 | $0.92-59.8%$0.84 | 91.3% | 87.0% | 91.2%
Avg35.840.7+13.6%15.4$2.17 | $0.79-63.5%$0.76 | 91.6% | 90.7% | 92.3%
OpenCode (Kimi K2.5)
R1329.674.8-77.3%314.2$1.35 | $0.27-80.0%$0.47 | 86.7% | 96.7% | 79.8%
R2735.782.9-88.7%40.0$2.04 | $0.41-80.0%$0.24 | 77.4% | 87.0% | 89.1%
R3296.168.5-76.9%227.5$1.06 | $0.30-71.2%$0.40 | 87.6% | 90.7% | 83.2%
Avg453.875.4-83.4%193.9$1.48 | $0.33-77.9%$0.37 | 83.9% | 91.5% | 84.0%

Table 12. Zero-shot vs. Tool-reuse vs. Evaluator Only: Quantum Dynamics

Tool Reuse Reduces Runtime for Most Models. Tool reuse also reduces wall-clock time for most model–benchmark combinations, because agents bypass the tool generation and unit-testing loop and proceed directly to task execution. The most dramatic speedup occurs for Claude Opus 4.6 via Claude Code on quantum dynamics: from an average of 128.4 minutes (ZS) to 15.2 minutes with tool reuse (−88.1%), as the model can directly compose tools rather than re-discovering and re-implementing solutions. Kimi K2.5 via OpenCode also benefits substantially, dropping from 453.8 to 75.4 minutes (−83.4%) on quantum dynamics and from 276.2 to 97.3 minutes (−64.8%) on quantum chemistry. Overall, runtime reductions in quantum chemistry range from 13.3% for Claude Opus 4.6 via Claude Code to 64.8% for Kimi K2.5 via OpenCode, consistent with the harder generalization required. GPT-5.2-Codex via Codex is the sole exception, with tool reuse yielding a marginal increase of +0.4% on quantum chemistry.

Figure 4. Relative Cost / Time / Accuracy radar plots for EL AGENTE FORJADOR with five agent setups on the quantum chemistry tasks (top) and quantum dynamics tasks (bottom) with different tool generation strategies. Each axis is independently min–max normalized across all models and conditions, then rescaled to [0.1, 0.9]. Accuracy (higher = better); Speed (lower time = better); Frugality (lower cost = better). Each radar represents a model; the shaded area indicates the fraction of tasks solved. Tool reuse consistently expands the shaded area toward the frugality and speed axes while maintaining or improving accuracy, with the most pronounced gains for weaker models such as Kimi K2.5 via OpenCode and GPT-5.2-Codex via Codex.

Tool Reuse Maintains or Improves Accuracy. Zero-shot accuracy is already high across both benchmarks, with average scores (combining accuracy and methodology) ranging from 65.7% to 98.5% depending on model and benchmark (Table 3). Tool reuse either maintains or improves these scores. In quantum chemistry, tool reuse raises the average score from 81.5% (ZS) to 85.8% (TR); in quantum dynamics, from 91.5% to 93.2%. The improvement is most pronounced for weaker models: Kimi K2.5 via OpenCode jumps from 65.7% to 82.2% on quantum chemistry and from 83.9% to 91.5% on quantum dynamics, a +16.5 and +7.6 percentage-point gains, respectively. GPT-5.2-Codex via Codex similarly improves from 83.2% to 88.1% on quantum chemistry and from 86.1% to 88.9% on quantum dynamics. These results demonstrate that the curriculum-built toolset not only reduces cost but also provides a scaffolding effect: the tool generator (§ 3.3) encodes correct computational methodology into the tools themselves, allowing weaker models to achieve accuracy comparable to stronger ones by composing well-tested building blocks rather than re-deriving domain logic from scratch.

Case Studies

A key promise of task-driven tool generation is that the resulting toolsets are not confined to the domain in which they were created: tools forged for quantum chemistry should compose seamlessly with tools forged for quantum dynamics, enabling cross-domain workflows. Moreover, when the existing library lacks a required capability, the agent can forge new tools on the fly, extending its repertoire without human intervention. To test this, we present two representative case studies. Both problems require bridging classical electronic-structure theory and open-quantum-system dynamics, a combination that demands tools from multiple domains and, in each case, triggers the generation of new tools to fill gaps in the existing toolset. To set up the case studies, we seeded the agent’s toolset by combining one curriculum-built toolset from the quantum chemistry benchmark with one from the quantum dynamics benchmark, giving the agent a cross-domain toolset to draw from at the outset. Traces of the case studies can be found in Appendix § 30.

Case Study 1: Ethylene Excited States via tddft and Quantum Subspace Expansion

Ethylene is the prototypical benchmark for π→π∗\pi\to\pi^{*} excitations and a stringent test of electronic structure methods. Comparing TD-DFT, the workhorse of computational photochemistry, against a quantum algorithm—QSE (Quantum Subspace Expansion) ([45]) in this case—on the same molecule probes both the strengths and limitations of each approach. The problem additionally requires interoperability across three distinct software ecosystems: PySCF, Tequila, and CUDA-Q. The following prompt is provided to EL AGENTE FORJADOR.

Prompt For the molecule ethylene (C=C), compute the first excited state energy using TD-DFT, and estimate the first excited state energy using a quantum algorithm. Optimize the geometry using B3LYP/def2-SVP and compute the S1S_1 energy using TD-DFT. Identify an active space capturing the π\pi and σ\sigma system. Estimate the first excited state energy using Quantum Subspace Expansion with CUDA-Q simulation. Analyze the nature of the π→π∗\pi\to\pi^{*} transition, including limitations of TD-DFT versus quantum algorithms and the effect of correlation and active space choice. Make a visualization of important molecular orbitals.

The tool analyzer identified nine candidate tools, of which five were selected for the workflow, spanning geometry optimization, TD-DFT, and molecular orbital analysis (PySCF-based), as well as Hamiltonian construction (Tequila-based). Crucially, three capabilities were missing from the existing library, and the tool generator forged them on the fly:

  • run_pyscf_casci.py — runs CASCI calculations for classical multireference benchmarking within a user-specified active space;

  • visualize_molecular_orbitals.py — renders 2D contour plots of molecular orbital wavefunctions on a grid, enabling the orbital visualizations requested in the prompt;

  • run_quantum_subspace_expansion.py — implements the QSE algorithm with CUDA-Q simulation, building the excitation subspace from single and double excitation operators, and solving the generalized eigenvalue problem.

All three tools passed automated unit testing and review before being used in the workflow.

The agent executed the workflow as follows:

  1. smiles_to_3d_geometry.py (reused from quantum chemistry) generated the initial ethylene structure from the SMILES string C=C, followed by run_dft_geometry_optimization.py (reused from quantum chemistry) at B3LYP/def2-SVP (E0=−78.5316E_0 = -78.5316 Hartree).

  2. run_tddft_calculation.py (reused from quantum chemistry) computed singlet and triplet excited states, identifying the π→π∗\pi\to\pi^{*} S1S_1 at 8.15 eV (f=0.375f = 0.375) and T1T_1 at 4.09 eV.

  3. analyze_molecular_orbitals.py (reused from quantum chemistry) mapped the frontier orbitals (HOMO at −7.51-7.51 eV, LUMO at 0.15 eV), guiding active space selection.

  1. run_pyscf_casci.py (newly forged) performed CASCI calculations at three active space sizes—CAS(2,2), CAS(4,4), and CAS(6,6)—providing classical multireference benchmarks. All three yield a consistent first excitation energy of ∼4.29 eV (the T1_1 state), confirming convergence with respect to active space size within the def2-SVP basis.

  1. tequila_build_molecular_hamiltonian.py (reused from quantum dynamics) constructed second-quantized Hamiltonians within CAS(2,2) and CAS(4,4) active spaces (STO-3G basis), mapped to 4 and 8 qubits respectively via Jordan–Wigner transformation.

  1. run_quantum_subspace_expansion.py (newly forged) executed QSE on both active spaces: QSE(2,2) with a 6-dimensional subspace yielded a first excitation of 4.88 eV, while QSE(4,4) with a 53-dimensional subspace yielded 2.29 eV.

  1. visualize_molecular_orbitals.py (newly forged) rendered contour plots of four frontier orbitals (HOMO−1, HOMO, LUMO, LUMO+1) in both the xzxz- and xyxy-planes (Figure 6), clearly resolving the σCC\sigma_{\mathrm{CC}}, πCC\pi_{\mathrm{CC}}, πCC∗\pi^{*}_{\mathrm{CC}}, and σCC∗\sigma^{*}_{\mathrm{CC}} character.

Frontier orbital visualizations of ethylene HOMO and LUMO in the xz-plane

Figure 6. Frontier orbital visualizations generated by the newly forged visualize_molecular_orbitals.py tool: HOMO (πCC\pi_{\mathrm{CC}}, left) and LUMO (πCC∗\pi^{*}_{\mathrm{CC}}, right) of ethylene in the xzxz-plane. The π→π∗\pi\to\pi^{*} character of the dominant S1S_1 transition is clearly visible from the nodal structure.

Results are summarized in Figure 5. TD-DFT (B3LYP/def2-SVP) places the S1_1 at 8.15 eV, somewhat above the experimental valence π→π∗\pi\rightarrow\pi^{*} excitation energy of ethylene (∼7.66 eV). The CASCI first excitations (∼4.29 eV, def2-SVP) and QSE(2,2) (4.88 eV, STO-3G) both correspond to the T1_1 state. The QSE(4,4) result (2.29 eV) deviates more substantially, which the agent attributed to the enlarged excitation subspace and the limitations of the minimal STO-3G basis. The agent’s report therefore treated the TD-DFT result as the closest estimate to the valence S1_1 excitation among the methods considered here, while the quantum algorithm primarily captured static-correlation effects within the chosen active space.

Ethylene First Excited State: Method Comparison

Figure 5. Figure 5 Figure generated by agents for case study 1: Comparison of first excitation energies from TD-DFT (B3LYP/def2-SVP), CASCI at three active space sizes (def2-SVP), QSE at two active space sizes (STO-3G, CUDA-Q simulation), and the experimental valence π→π∗\pi\to\pi^{*} excitation of ethylene (∼7.66\sim7.66 eV, dashed red line). CASCI results are consistent across active spaces (∼4.29\sim4.29 eV, corresponding to T1_1). QSE(2,2) agrees well with CASCI, while QSE(4,4) deviates due to the larger subspace and minimal basis limitations. TD-DFT provides the closest estimate to the valence S1_1 excitation among the methods shown.

Case Study 2: Rubidium-87 Hyperfine Qubit

Rb-87 is among the most widely used atomic qubits in quantum computing and quantum sensing ([26]). Quantitatively connecting the electron density at the nucleus, a quantity accessible from ab initio calculation, to the qubit’s Hamiltonian and decoherence properties demonstrates the kind of cross-domain reasoning that is important to quantum engineering. The problem also probes the limits of non-relativistic DFT on heavy atoms (Rb, Z=37Z = 37), testing whether the agent can critically assess its own computational results against experimental benchmarks. The following prompt is provided to EL AGENTE FORJADOR.

Prompt Model a rubidium-87 hyperfine qubit as a two-level open quantum system. Compute the ground-state electron density at the nucleus using PySCF, construct a two-level Hamiltonian (H=(ω/2) ZH = (\omega/2)\,Z) from it, and simulate Lindblad dynamics with QuTiP. Study the evolution from (a) the excited state (∣1⟩|1\rangle) and (b) a superposition ((∣0⟩+∣1⟩)/2(|0\rangle+ |1\rangle)/\sqrt{2}), then plot the excited-state population and coherence over time and provide a brief analysis. Your plots should be publication-quality plots.

The task required integrating the quantum chemistry toolset (built with PySCF) with the QuTiP dynamics tools for quantum dynamics. The tool analyzer identified four reusable tools: run_dft_single_point.py and run_single_point_hf.py from quantum chemistry, plus qutip_lindblad_evolution.py and plot_line_comparison.py from quantum dynamics. One capability was missing: evaluating the electron density at nuclear positions from a converged SCF object. The tool generator forged a new tool, compute_electron_density_at_nuclei.py, which evaluates AO basis functions at specified nuclear coordinates via PySCF’s numint.eval_ao and eval_rho routines and returns the total electron density, supporting both restricted and unrestricted SCF objects.

The agent executed the workflow in a single consolidated script:

  1. run_dft_single_point.py (reused from quantum chemistry) converged a DFT/B3LYP/def2-SVP calculation for a neutral Rb atom (charge =0= 0, spin multiplicity =2= 2, E0=−487.62E_0 = -487.62 Hartree). The agent first attempted a cc-pVDZ basis, found it unavailable for Rb, and switched to the def2-SVP basis.

  1. compute_electron_density_at_nuclei.py (newly forged) evaluated the contact density at the nuclear origin, yielding ρ(0)=2.66 e/bohr3\rho(0) = 2.66\,e/\mathrm{bohr}^{3}. The resulting Fermi contact coupling (AF≈3.9×1016A_F \approx3.9 \times10^{16} Hz) vastly overestimates the experimental hyperfine splitting (6.83 GHz) because the total density is dominated by core ss-electrons (1s–4s), not the valence 5s electron responsible for the physical coupling. The

agent correctly identified this limitation and noted that isolating the valence contribution would require relativistic methods (ZORA or Douglas–Kroll–Hess). The experimental ground-state hyperfine splitting of 87Rb{}^{87}\mathrm{Rb}, ωhf=2π×6.8347 GHz\omega_{\mathrm{hf}} = 2\pi\times6.8347\ \mathrm{GHz}, was adopted for the subsequent Lindblad simulation.

  1. qutip_lindblad_evolution.py (reused from quantum dynamics) simulated the two-level system with decoherence parameters T1=10T_1 = 10 and T2=5T_2 = 5 (in units of 1/ω1/\omega), using collapse operators for T1T_1 relaxation (γ1 σ−\sqrt{\gamma_1}\,\sigma_-, γ1=0.1\gamma_1 = 0.1) and pure dephasing (γϕ/2 σz\sqrt{\gamma_\phi/2}\,\sigma_z, γϕ=0.15\gamma_\phi= 0.15). The simulation spanned 30/ω30/\omega to capture the full population and coherence decay. The agent initially obtained incorrect dynamics due to QuTiP’s basis convention (∣0⟩|0\rangle is the +1+1 eigenstate of σz\sigma_z, i.e. the excited state), diagnosed the mismatch by comparing against analytical Bloch-equation solutions, and corrected the initial-state assignments and projectors accordingly.

  1. plot_line_comparison.py (reused from quantum dynamics) generated publication-quality figures with both numerical (solid) and analytical (dashed) curves overlaid for validation (Figure 7).

Two plots showing excited-state population decay and off-diagonal coherence decay for an Rb-87 hyperfine qubit

Figure 7. Figures generated by agents for case study 2: Lindblad dynamics of a 87Rb{}^{87}\mathrm{Rb} hyperfine qubit using the experimental hyperfine splitting, with the PySCF contact density serving as a diagnostic comparison rather than a quantitative input to the dynamics. Left: Excited-state population Pe(t)P_e(t) decays exponentially with T1=10/ωT_1 = 10/\omega from both initial states (∣e⟩|e\rangle and (∣e⟩+∣g⟩)/2(|e\rangle+ |g\rangle)/\sqrt{2}). Right: Coherence ∣ρ01∣|\rho_{01}| decays on the shorter T2=5/ωT_2 = 5/\omega timescale for the superposition state; the eigenstate ∣e⟩|e\rangle generates no coherence. Solid lines are numerical QuTiP results; dashed lines are analytical Bloch-equation solutions, showing agreement to machine precision.

Results are shown in Figure 7. Population decays exponentially on the T1=10/ωT_1 = 10/\omega timescale from both initial states, while coherence decays on the shorter T2=5/ωT_2 = 5/\omega timescale for the superposition state; no coherence is generated from the eigenstate ∣e⟩|e\rangle, consistent with Lindblad theory. The numerical QuTiP solutions match the analytical Bloch-equation predictions to machine precision, validating the implementation. The T2<T1T_2 < T_1 hierarchy (1/T2=1/(2T1)+γϕ1/T_2 = 1/(2T_1) + \gamma_\phi) reflects the combined effect of relaxation and pure dephasing, a universal feature of open quantum systems. The agent’s report discussed implications for real Rb-87 qubits, where T1T_1 can exceed seconds while T2T_2 is limited by magnetic-field fluctuations and collisions.

Discussion

Strengths

Task-Driven Agent Generation Reduces Human Involvement. Our approach significantly reduces the need for human intervention in building agent systems. Instead of relying on manually engineered, domain-specific prompts or hand-crafted tools, agents are generated in a task-driven manner: complex capabilities emerge through task decomposition and tool generation. This paradigm aligns well with the strengths of LLMs, whose training data already encode most of the relevant procedural and domain knowledge. In practice, describing a target task or simulation objective is often easier than designing expert-level prompts.

Tool Reuse Simultaneously Improves Cost, Speed, and Accuracy. In most machine learning settings, improvements in one metric come at the expense of another. Tool reuse breaks this trade-off: across five coding agent setups, we observe simultaneous reductions in API cost (33–78%) and wall-clock time (up to 88%), with equal or improved task accuracy. This is because curriculum-built tools amortize the exploration cost of tool generation: once a useful tool has been discovered and validated, it can be reused at negligible marginal cost. The result is a progressively more efficient system where per-task cost decreases as the toolset grows. Moreover, because the curriculum toolset is built by a stronger model (Claude Opus 4.6) and reused by weaker ones, tool reuse also serves as strong-to-weak knowledge transfer: correct domain methodology is encoded in the tools and can be used by weaker agents.

Universal Agents Enable Self-Healing Tool Ecosystems. Rather than assigning agents fixed context and roles, all agents in our framework are universal: any agent can code, debug, and browse the whole agent workspace. This design creates a self-healing ecosystem. Tools are often imperfect at the time of initial generation but are subsequently corrected by downstream agents. Because later agents depend on these tools to solve their own tasks, failures naturally trigger inspection, refinement, and repair, all without explicit human supervision. In practice, bugs surface when tools are applied in new contexts, and the same agent that encounters the bug has the capability to fix it—an effect quantified by the tool-editing statistics in Appendix § 27. The curriculum ordering amplifies this effect, as tools generated for simpler tasks are tested by increasingly complex downstream applications.

Limitations & Outlook

We identify several limitations of the current system and outline directions for future work.

Unreliable Self-Verification and Reward Exploitation. Our system relies on agent self-verification and automated evaluation signals. As with many autonomous agent frameworks [30, 79], these signals are not always reliable. Agents may incorrectly assess correctness, fail to detect subtle errors, or converge to behaviours that exploit weaknesses in the evaluation function, optimizing for superficial success metrics rather than true task correctness. This risk is particularly acute in scientific computing, where numerically plausible but physically incorrect results (e.g., a geometry optimization converging to a saddle point rather than a minimum) may pass automated checks.

A promising mitigation is evaluation-time scaling: allocating more computation to verification and refinement, analogous to test-time compute scaling in language models [59]. Recent work has taken important steps toward verifiable and self-correcting AI agents for quantum many-body simulations [17]. Domain-specific invariants (conservation laws, symmetry constraints, known asymptotic limits) could serve as physics-informed verification signals that are harder for agents to exploit than generic correctness metrics.

Restricted Software Ecosystem. The current implementation is limited to Python-based tools and a predefined set of repositories. While this simplifies execution and reuse, it excludes tasks that require input-file-driven software, such as ORCA [47], VASP [39], or Gaussian [19], external APIs, or non-Python ecosystems, which remain prevalent in computational chemistry. Extending the framework to wrap such software (generating input files, launching executables, and parsing output) is a natural next step that would substantially broaden the system’s applicability without abandoning the Python-based tool abstraction layer.

Toward Self-Directed Curriculum Generation. The current system requires human-specified task sequences to drive curriculum learning. Future versions of the system could integrate self-tasking mechanisms [29, 74, 78], in which the agent identifies gaps in its toolset and generates synthetic problems to address them, analogous to how Voyager [68] grows skills through self-directed exploration. Combined with automated verification, this would close the loop from tool generation to validation without human intervention, moving toward a fully autonomous scientific agent that expands its own capabilities over time.

Conclusion

We present El Agente Forjador, a multi-agent framework that shifts the bottleneck in scientific automation from building tools to specifying tasks. The system autonomously forges, validates, and composes reusable computational tools through a four-stage workflow driven by task requirements rather than manual engineering. Across 24 tasks spanning quantum chemistry and quantum dynamics on five coding-agent backends, curriculum-based tool reuse cuts API cost by 33–78% and wall-clock time by up to 88%—without sacrificing accuracy. Moreover, encoding domain methodology into reusable tools raises average scores from 81.5% to 85.8% on quantum chemistry and from 91.5% to 93.2% on quantum dynamics, with weaker models gaining as much as 16.5 percentage points—approaching the performance of frontier models at a fraction of the cost. Case studies further show that tools forged in separate domains compose to solve hybrid problems, with any missing capability forged on demand. These results establish a paradigm in which scientific agent systems are defined entirely by the tasks to be solved: researchers specify what to compute, and the computational infrastructure for doing so emerges and self-improves through use.

Acknowledgments

We gratefully acknowledge the longstanding contributions of the Matter Lab’s current and past group members (https://www.matter.toronto.edu/), in particular to El Agente team (https://www.elagente.ca). J.B. acknowledges funding from the Eric and Wendy Schmidt AI in Science Postdoctoral Fellowship Program, a program by Schmidt Futures. A.A.-G. Thanks to Anders G. Frøseth for his generous support. A.A.-G. also acknowledges the generous support of Natural Resources Canada and the Canada 150 Research Chairs program. This research is part of the University of Toronto’s Acceleration Consortium, which receives funding from the CFREF-2022-00042 Canada First Research Excellence Fund.This work was supported by the Defense Advanced Research Projects Agency (DARPA) under Agreement No. HR0011262E022. This work was generously supported by the AI2050 program of Schmidt Sciences.

Data availability

All the workspaces produced by El Agente Forjador in the benchmark are available via https://doi.org/10.5683/SP3/0YOMKL.

Supporting Information and Technical Details

Experiments are conducted with identical software and hardware configurations. To avoid inconsistency from the HPC waiting queue for SLURM job submission (§ 3.5), we dedicated all cores to the experiment and used subprocess to simulate SLURM-based command execution. Although our experiments did not employ a sandboxed execution environment, we have verified that in all runs the agent did not access or copy reference answers from anywhere.

Task typeCPU Cores
Quantum dynamics tasks20
Quantum chemistry tasks40
Case Studies40

Table 4. Hardware configuration.

SoftwareVersion
Codex0.93.0
Claude Code2.1.63
OpenCode1.1.52

Table 5. Software versions.

ModelProviderInputCache WriteCache ReadOutput
Claude Opus 4.6Anthropic5.006.25a / 10.00b0.5025.00
Claude Sonnet 4.6Anthropic3.003.75a / 6.00b0.3015.00
GPT-5.2-CodexOpenAI1.75—0.17514.00
Gemini 3.1 Pro Preview*Google2.00c / 4.00d—0.20c / 0.40d12.00c / 18.00d
Kimi K2.5*Moonshot AI0.45—0.2252.20

Table 6. Model API pricing (per 1M tokens, USD).

a5-min cache TTL (1.25× input price). b1-hour cache TTL (2× input price). TTL (Time To Live) configuration is automatically handled by Claude Code for prompts ≤200k tokens; d prompts >200k tokens.

*Prices sourced from OpenRouter [51].

List of Task Prompts

Quantum chemistry tasks

The quantum chemistry tasks we used to benchmark are the same suite of problems as El Agente Gráfico [9], with a reduced number of molecules per task for evaluation efficiency; this reduction has a negligible effect on task difficulty, as the core computational methodology remains identical. We add an extra Level 0 task (organic molecule analysis of caffeine) to the first category to provide a simpler entry point for curriculum learning, allowing the agent to bootstrap its toolset before tackling the harder Level 1 and Level 2 tasks.

Organic Compounds – Level 0

Prompt Organic Molecule Analysis - Level 0 For the three compounds listed below, perform a geometry optimization using the Hartree-Fock (HF) method and the def2-SVP basis set in the gas phase.

After optimization, generate a separate report for each molecule. Each report must contain:

  1. Final Cartesian coordinates (in Å)

  2. Total energy (in Hartrees)

  3. Point group symmetry

  4. Dipole moment (in Debye)

  5. Molecular orbital analysis (including an MO energy table and the HOMO–LUMO gap)

  6. Atomic charge analysis (Mulliken)

Compound:

  • caffeine: CN1C=NC2=C1C(=O)N(C(=O)N2C)C

Always verify the presence of any imaginary vibrational frequencies—excluding translational and rotational modes—using the Hessian computed in PySCF with mf.grids.level = 3. If an imaginary mode is identified, displace the structure along the corresponding normal mode and re-optimize the geometry to eliminate the instability and confirm that the resulting structure corresponds to a stable minimum.

Organic Compounds – Level 1

Prompt Organic Molecule Analysis - Level 1 For the three compounds listed below, perform a geometry optimization using the Hartree-Fock (HF) method and the def2-SVP basis set in the gas phase. After optimization, generate a separate report for each molecule. Each report must contain:

  1. Final Cartesian coordinates (in Å)

  1. Total energy (in Hartrees)

  1. Point group symmetry

  1. Dipole moment (in Debye)

  1. Molecular orbital analysis (including an MO energy table and the HOMO–LUMO gap)

  1. Atomic charge analysis (Mulliken)

Compounds:

  • caffeine: CN1C=NC2=C1C(=O)N(C(=O)N2C)C

  • theobromine: CN1C=NC2=C1C(=O)NC(=O)N2C

  • acetylsalicylic_acid: CC(=O)OC1=CC=CC=C1C(=O)O

Organic Compounds – Level 2

Prompt Organic Molecule Analysis - Level 2 For the 6 molecules defined below by their filenames, charge, and multiplicity, perform a geometry optimization with the Hartree-Fock (HF) method and the def2-SVP basis set in the gas phase. Assume you have access to the initial geometry from the corresponding XYZ files.

After optimization, generate a separate report for each molecule. Each report must contain:

  1. Final Cartesian coordinates (in Å)

  1. Total energy (in Hartrees)

  1. Point group symmetry

  1. Dipole moment (in Debye)

  1. Molecular orbital analysis (including an MO energy table and the HOMO–LUMO gap)

  1. Atomic charge analysis (Mulliken)

Molecules:

  1. caffeine_openbabel.xyz (charge = 0; multiplicity = 1)

  1. theobromine_openbabel.xyz (charge = 0; multiplicity = 1)

  1. aspirin_openbabel.xyz (charge = 0; multiplicity = 1)

  1. methyl_salicylate_openbabel.xyz (charge = 0; multiplicity = 1)

  1. diisopropylamide_anion_openbabel.xyz (charge = -1; multiplicity = 1)

  1. diisopropylammonium_cation_openbabel.xyz (charge = +1; multiplicity = 1)

Inorganic Compounds – Level 1

Prompt Inorganic Molecule Analysis - Level 1 For the three inorganic compounds listed below, perform a geometry optimization using the Hartree-Fock (HF) method and the def2-SVP basis set in the gas phase.

After optimization, generate a separate report for each molecule. Each report must contain:

  1. Final Cartesian coordinates (in Å)

  1. Total energy (in Hartrees)

  1. Point group symmetry

  1. Dipole moment (in Debye)

  1. Molecular orbital analysis (including an MO energy table and the HOMO–LUMO gap)

  1. Atomic charge analysis (Mulliken)

  1. An image of the optimized structure

Compounds:

  • Chromium(0) hexacarbonyl (low spin): Cr(=C=O)(=C=O)(=C=O)(=C=O)(=C=O)

  • Chlorine trifluoride: FCl(F)F

  • Fluorophosphoric acid (singly deprotonated form): [O-]P(F)(O)=O

Inorganic Compounds – Level 2

Prompt Inorganic Molecule Analysis - Level 2 For the 6 inorganic molecules defined below by their filenames, charge, and multiplicity, perform a geometry optimization with the Hartree-Fock (HF) method and the def2-SVP basis set in the gas phase. Assume you have access to the initial geometry from the corresponding XYZ files.

After optimization, generate a separate report for each molecule. Each report must contain:

  1. Final Cartesian coordinates (in Å)

  1. Total energy (in Hartrees)

  1. Point group symmetry

  1. Dipole moment (in Debye)

  1. Molecular orbital analysis (including an MO energy table and the HOMO–LUMO gap)

  1. Atomic charge analysis (Mulliken)

  1. An image of the optimized structure

Molecules:

  1. chromium_hexacarbonyl.xyz (charge = 0; multiplicity = 1)

  1. chlorine_trifluoride.xyz (charge = 0; multiplicity = 1)

  1. fluorophosphoric_acid_singly_deprotonated_form.xyz (charge = -1; multiplicity = 1)

  1. trifluoromethane_sulfonate.xyz (charge = -1; multiplicity = 1)

  1. cyclohexyldimethylphosphine.xyz (charge = 0; multiplicity = 1)

  1. t-butylisothiocyanate.xyz (charge = 0; multiplicity = 1)

Carbocations – Level 1

Prompt Carbocation Stability - Level 1 Calculate the carbocation formation enthalpies (ΔH\Delta H) and Gibbs free energies (ΔG\Delta G) for the reaction:

R-H→R++H−R\text{-}H \to R^{+} + H^{-}

The R-H compounds to study are: methane, ethane, propane, 2-methylpropane, toluene, benzene, dimethyl ether, trimethylamine, and propene.

You are provided with initial XYZ geometry files for all R-H (molecules), R+ (carbocations), and H- (hydride) species. Instructions:

  1. Optimize the structures of all R-H and R+ species using DFT with the B3LYP functional and def2-SVP basis set. The provided hydride (H-) structure should be used as-is without optimization.

  2. Use the following charge and multiplicity:

    • R-H molecules: charge 0, multiplicity 1

    • R+ carbocations: charge 1, multiplicity 1

    • Hydride (H-): charge -1, multiplicity 1

  3. From the outputs, calculate the formation enthalpy and Gibbs free energy for each R-H compound’s reaction.

  4. Report the results (in kcal/mol) in a table and save it to the report.md file.

Carbocations – Level 2

Prompt Carbocation Stability - Level 2 Calculate the carbocation formation enthalpies (ΔH\Delta H) and Gibbs free energies (ΔG\Delta G) for the reaction:

R−H→R++H−R-H \rightarrow R^{+} + H^{-}

Instructions:

  1. Generate 3D geometries for the R-H and R+ species from the SMILES strings below. Also include the hydride anion (H-).

  2. Optimize the geometries of all R-H and R+ species using DFT with the B3LYP functional and def2-SVP basis set. The hydride (H-) structure should not be optimized.

  3. Use the following charge and multiplicity:

    • R-H molecules: charge 0, multiplicity 1

    • R+ carbocations: charge 1, multiplicity 1

    • Hydride (H-): charge -1, multiplicity 1

  4. From the outputs, calculate the formation enthalpy and Gibbs free energy for each reaction.

  5. Report the results (in kcal/mol) in a table and save it to a text file.

SMILES Strings:

  • R-H compounds:

    • methane: C

    • ethane: CC

    • propane: CCC

    • 2-methylpropane: CC(C)C

    • toluene: Cc1ccccc1

    • benzene: c1ccccc1

    • dimethyl ether: COC

    • trimethylamine: CN(C)C

    • propene: C=CC

  • R+ carbocations:

  • CH3+

  • CH2+C

  • CCH+C

  • CC+(C)C

  • c1c(cccc1)CH2+

  • c1c+cccc1

  • COCH2+

  • CN(C)CH2+

  • CH2+C=C

Ring Strain – Level 1

Prompt Cycloalkane Ring Strain - Level 1 Your goal is to compute the relative ring strain energies (RSE) for cycloalkanes from C3 to C8.

  1. Calculate Reaction Energies: Compute the ΔH\Delta H and ΔG\Delta G for the following reactions, for n=4n=4, 5, 6, 7, and 8:

cyclo(CnH2n)→cyclo(Cn-1H2n-3)-CH3

  • Use the B3LYP/def2-svp level of theory.

  • All structures must be optimized, and frequency calculations are required to obtain enthalpies and Gibbs free energies.

  • The first reaction (n=4n=4) is cyclobutane (C1CCC1) → methylcyclopropane (CC1CC1). You must generate the other reactants and products.

  1. Calculate Relative RSE:

  • First, determine RSE values by setting the RSE of cyclooctane (n=8n=8) to zero.

  • The RSE of cyclo(Cn−1H2n−2C_{n-1}H_{2n-2}) is the RSE of cyclo(CnH2nC_nH_{2n}) plus the reaction energy (ΔH\Delta H or ΔG\Delta G) calculated in step 1.

  • Calculate this iteratively down to n=3n=3.

  1. Report Final Table:

  • Renormalize the RSE values, setting the RSE of cyclohexane (n=6n=6) as the zero reference point.

  • Report the final results as a table of ring size (n=3 to 8) vs. RSE (ΔH\Delta H and ΔG\Delta G).

Ring Strain – Level 2

Prompt Cycloalkane Ring Strain - Level 2 Compute the values of ΔH\Delta H and ΔG\Delta G for the following reactions, for n=4n=4, 5, 6, 7, and 8:

cyclo(CnH2n)→cyclo(Cn-1H2n-3)-CH3

  • Perform these calculations using the B3LYP/def2-svp level of theory.

  • All structures must be optimized, and frequency calculations are required.

Use these reaction energies to approximate the relative ring strain energies of cycloalkanes (from C3 to C8). You must determine the appropriate reference point and methodology to calculate the strain.

Report the final results as a table of ring size (n=3 to 8) vs. relative ring strain enthalpy and free energy.

pKapK_a – Level 1

Prompt pKa of Carboxylic Acids - Level 1 Calculate the pKapK_a of acetic acid in water using two calculations at the B3LYP/def2-SVP level of theory with the CPCM implicit solvation model.

pKapK_a – Level 2

Prompt pKa of Carboxylic Acids - Level 2 Calculate the pKapK_a of chlorofluoroacetic acid using B3LYP/def2-SVP.

To do so, first calibrate the free energy of solvation of the proton based on the known literature values of some related carboxylic acids:

  1. Acetic acid; pKa = 4.76

  2. Fluoroacetic acid; pKa = 2.586

  3. Chloroacetic acid; pKa = 2.86

TD-DFT – Level 1

Prompt Electronic Absorption Spectra - Level 1 Compute the energy level of S1, the energy difference between S1 and T1, and the oscillator strength to the S1 state for the following structures from the default working directory: 2.xyz, 3.xyz, 5.xyz. Perform a single-point TDDFT (after geometry optimization and checking for geometric stability) calculation with B3LYP/def2-SVP.

TD-DFT – Level 2

Prompt Electronic Absorption Spectra - Level 2 Compute the energy level of S1, the energy difference between S1 and T1, and the oscillator strength to the S1 state for the following structures from the default working directory: 2.xyz, 3.xyz, 5.xyz. Perform a single-point TDDFT calculation with B3LYP/def2-SVP.

Quantum dynamics tasks

The quantum dynamics tasks we used in the benchmark uses the same suite of problems as El Agente Cuántico (Pérez-Sánchez et al., [52]), with one minor modification: each problem prompt explicitly requests the agent to generate publication-quality figures, enabling systematic evaluation of plot correctness alongside quantitative outputs.

Bell State

Prompt Bell state measurements Use CUDA-Q and create a 2-qubit quantum circuit that prepares a Bell state (∣00⟩+∣11⟩)/2(|00\rangle+ |11\rangle)/\sqrt{2}. Start in ∣00⟩|00\rangle. Apply a Hadamard gate on qubit 0 and then a CNOT with control qubit 0 and target qubit 1. Measure both qubits in the computational ⟨Z∣Z⟩\langle Z|Z\rangle basis with 4096 shots and return the measurement counts. From those counts, compute and return the expectation value of Z⊗ZZ \otimes Z. Then also estimate the expectation value of X⊗XX \otimes X by measuring in the X basis, again with 4096 shots, and return both the counts and the estimated ⟨X⊗X∣X⊗X⟩\langle X \otimes X|X \otimes X\rangle. Create publication quality figures and physically analyze the results.

Cluster Model String Order

Prompt Dmrg cluster string order Consider a one-dimensional ring of NN qubits with periodic boundary conditions. Define the cluster stabilizer

Ki=Zi−1XiZi+1,(1)K_i = Z_{i-1}X_iZ_{i+1}, \tag*{(1)}

with site indices understood modulo $N. The transverse-field cluster Hamiltonian is

H(θ)=−cos⁡θ∑i=1NKi−sin⁡θ∑i=1NXi,θ∈[0,π/2].(2)H(\theta)=-\cos\theta\sum_{i=1}^{N}K_i-\sin\theta\sum_{i=1}^{N}X_i,\qquad\theta\in[0,\pi/2]. \tag*{(2)}

The cluster Hamiltonian strength is explicitly defined as J=cos⁡θJ=\cos\theta (with transverse-field strength h=sin⁡θh=\sin\theta).

Using DMRG as implemented in TenPy, compute the ground state of H(θ)H(\theta) for N=11,21,41N=11,21,41 with bond dimension 100.

Define the string operator for odd NN as

ON=Z1(∏j=2j evenN−1Xj)ZN,(3)\mathcal{O}_N=Z_1\left(\prod_{\substack{j=2\\j\ \text{even}}}^{N-1}X_j\right)Z_N, \tag*{(3)}

corresponding to the pattern ZXIX⋯IXZZXIX\cdots IXZ, and evaluate the string-order parameter

SN(θ)=⟨ψ0(θ;N)∣ON∣ψ0(θ;N)⟩.(4)S_N(\theta)=\langle\psi_0(\theta;N)|\mathcal{O}_N|\psi_0(\theta;N)\rangle. \tag*{(4)}

Create a publication quality plot for SNS_N as a function of the cluster strength J=cos⁡θJ=\cos\theta for the three system sizes and estimate the critical point from finite-size crossings or the location of maximal slope. Physically analyze the results.

Noisy Bell State

Prompt Bell state noise Use Qiskit and prepare the Bell state (∣00⟩+∣11⟩)/2(|00\rangle+|11\rangle)/\sqrt{2}. Start in ∣00⟩|00\rangle, apply a Hadamard gate on qubit 0 and then a CNOT with control qubit 0 and target qubit 1. Add a depolarizing noise channel with probability pp. Simulate the circuit for p∈{0,0.05,0.1,0.2,0.3}p\in\{0,0.05,0.1,0.2,0.3\}. For each value of pp, run 4096 shots in the ZZ basis, return the measurement counts, and compute ⟨Z⊗Z⟩\langle Z\otimes Z\rangle. Then insert Hadamard gates on both qubits to measure in the XX basis, run 4096 shots, return the measurement counts, and compute ⟨X⊗X⟩\langle X\otimes X\rangle. Create a publication quality plot for both correlators as functions of pp and comment on how the noise degrades the Bell-state correlations. Physically analyze the results.

H2H_2 VQE Dissociation

Prompt H2 VQE dissociation Use tequila and compute the VQE energy of H2H_2 over bond distances from 0.4 to 2.2 Å and compare against the exact answer. For the plot, create a figure of the dissociation curve and explain the physical meaning and where the curve deviates from exact energies. Create publication quality figures and physically analyze the results.

Gibbs State

Prompt Hubbard gibbs state Prepare a Gibbs state of a 1D Hubbard model on a classical computer using imaginary-time evolution with TenPy. Consider a 10-site Hubbard chain with open boundary conditions, hopping t=1t=1, on-site interaction U=4U=4, and half filling. Target an inverse temperature 1/T=21/T=2. Validate that the resulting state is thermal by checking energies and occupancies. Create publication quality figures and physically analyze the results.

Ising Dynamics

Prompt Ising magnetization dynamics Use CUDA-Q and implement a simulation of the transverse-field Ising model for a 10-qubit chain with open boundary conditions. Compute the dynamics of the magnetization ⟨Z⟩\langle Z\rangle for two parameter regimes, Jcoup=10JJ_{\mathrm{coup}}=10J with h=0.1Jh=0.1J, and Jcoup=0.1JJ_{\mathrm{coup}}=0.1J with h=10Jh = 10 J. Start the evolution from a Haar-random initial state and simulate the dynamics over a total time of 10 seconds using a second-order product formula with 1000 time steps. Generate a heatmap where the x-axis corresponds to qubit position, the y-axis to time, and the color scale to the ZZ-magnetization, for each of these two phases. Create publication quality figures and physically analyze the resulting magnetization dynamics between the two parameter choices.

Open Qubit Dynamics

Prompt Qutip lindblad evolution Use QuTiP and compare the dynamics of a single qubit under unitary evolution and under open system Lindblad evolution using:

  • Hamiltonian: H=X+0.5∗ZH = X + 0.5 * Z

  • Initial states: Use the plus and minus eigenstates of XX.

  • Dissipation: Use a collapse operator C=γ∗sigmam⁡()C = \sqrt{\gamma} * \operatorname{sigmam}(), with γ=0.2\gamma= 0.2.

  • Evolution: Use a time range from t=0t = 0 to t=40t = 40 with 400 time steps.

Compute and store the expectation value of ZZ as a function of time for each initial state. Create publication quality figures and physically analyze the results.

FMO HEOM

Prompt Fmo heom dynamics Use QuTiP and use the HEOM implementation to simulate exciton dynamics in the Fenna–Matthews–Olson (FMO) complex. Use the following parameters:

  • System Hamiltonian =

H=(240.0−87.75.5−5.96.7−13.7−9.9−87.7315.030.88.20.711.84.35.530.80.0−53.5−2.2−9.66.0−5.98.2−53.5130.0−70.7−17.0−63.36.70.7−2.2−70.7285.081.1−1.3−13.711.8−9.6−17.081.1435.039.7−9.94.36.0−63.3−1.339.7245.0).H = \begin{pmatrix} 240.0 & -87.7 & 5.5 & -5.9 & 6.7 & -13.7 & -9.9 \\ -87.7 & 315.0 & 30.8 & 8.2 & 0.7 & 11.8 & 4.3 \\ 5.5 & 30.8 & 0.0 & -53.5 & -2.2 & -9.6 & 6.0 \\ -5.9 & 8.2 & -53.5 & 130.0 & -70.7 & -17.0 & -63.3 \\ 6.7 & 0.7 & -2.2 & -70.7 & 285.0 & 81.1 & -1.3 \\ -13.7 & 11.8 & -9.6 & -17.0 & 81.1 & 435.0 & 39.7 \\ -9.9 & 4.3 & 6.0 & -63.3 & -1.3 & 39.7 & 245.0 \end{pmatrix}.
  • Bath model: Drude–Lorentz spectral density with reorganization energy λ=35 cm−1\lambda= 35\ \mathrm{cm}^{-1}, cutoff time 1/γ=50 fs1/\gamma= 50\ \mathrm{fs}, and temperature T=300 KT = 300\ \mathrm{K} and T=77 KT = 77\ \mathrm{K}.

  • HEOM parameters: hierarchy depth L=4L = 4, number of Matsubara terms K=2K = 2.

  • Initial condition: system localized on site 0.

  • Dynamics: propagate for 1 ps and record site populations vs. time.

  • Report: Plot all site populations as a function of time at the two different temperatures and analyze the results.

GRAPE Control

Prompt Lambda grape control Use QuTiP and solve a quantum control problem for a Lambda-type three-level system (levels ∣1⟩\lvert1\rangle, ∣2⟩\lvert2\rangle, ∣3⟩\lvert3\rangle). The goal is to transfer population from the ground state ∣1⟩\lvert1\rangle to the target state ∣3⟩\lvert3\rangle while minimizing the occupation of the intermediate state ∣2⟩\lvert2\rangle.

  • Control Hamiltonians: Hc1=(∣1⟩⟨2∣+∣2⟩⟨1∣)H_{c1}=(|1\rangle\langle2|+|2\rangle\langle1|) (Pump coupling). Hc2=(∣2⟩⟨3∣+∣3⟩⟨2∣)H_{c2}=(|2\rangle\langle3|+|3\rangle\langle2|) (Stokes coupling).

  • The Optimization: Use the GRAPE algorithm.

  • Duration: T=40T=40 (arbitrary time units) with time slots =3000=3000.

  • Validation: After optimizing the pulses, run a time-evolution simulation using the generated pulses to verify the dynamics.

  • Output: A plot showing the Control Pulses (Amplitude vs Time). A plot showing the Populations (P1, P2, P3) vs Time. Print the final Fidelity and physically analyze the results.

Floquet Kicked Ising

Prompt Floquet kicked ising Use CUDA-Q and simulate the Floquet dynamics of a periodically kicked Ising chain with 10 qubits and open boundary conditions. The system has nearest-neighbor ZZZZ interactions with coupling J=1J=1, and is kicked every T=1T=1 by a global transverse field in XX. Use a strong kick with strength h=2Jh=2J so that the effect of the drive is clearly visible in the dynamics. Initialize the system in a Haar-random state and simulate the evolution for 10 Floquet periods.

Plot a heatmap of ⟨Zi(t)⟩\langle Z_i(t)\rangle, with qubit index on the x-axis, Floquet step (time) on the y-axis, and color representing the local magnetization. Physically analyze the results. All figure should be publication quality.

Floquet TD-DMRG Disorder

Prompt Floquet dmrg disorder Simulate Floquet dynamics with TD-DMRG for a 1D disordered spin-1/2 chain. Use a periodically driven Hamiltonian with period T=τ1+τ2T=\tau_1+\tau_2. During 0<t<τ10<t<\tau_1, evolve under a strong global x-field plus interactions and disorder: H=∑iΩxSix+ΔiSiz+J(SixSi+1x+SiySi+1y−SizSi+1z)H=\sum_i\Omega_xS_i^x+\Delta_iS_i^z+J(S_i^xS_{i+1}^x+S_i^yS_{i+1}^y-S_i^zS_{i+1}^z). During τ1<t<T\tau_1<t<T, switch to a global y-field, H=∑iΩy(1−ϵ)Siy+ΔiSiz+Hi,i+1H=\sum_i\Omega_y(1-\epsilon)S_i^y+\Delta_iS_i^z+H_{i,i+1}. Choose Ωxτ1≈π\Omega_x\tau_1\approx\pi so each period approximately flips the x-polarization.

Use the following parameters: system size L=10L=10 spins, maximum bond dimension χmax⁡=100\chi_{\max}=100, time step δt=0.03\delta t=0.03, evolve for Nperiods=50N_{\mathrm{periods}}=50 Floquet periods, average over Ndisorder=5N_{\mathrm{disorder}}=5 disorder realizations, and scan ϵ∈{0,0.15,0.3}\epsilon\in\{0,0.15,0.3\} (3 values). Keep the Hamiltonian parameters as before: J=1J=1, Ωx=Ωy=4J\Omega_x=\Omega_y=4J, τ1=π/(2Ωx)≈0.393\tau_1=\pi/(2\Omega_x)\approx0.393, τ2=0.5\tau_2=0.5, and disorder strength W=2JW=2J.

Initialize the system in a product state polarized along +x+x. Evolve stroboscopically for many periods using TD-DMRG (TEBD or TDVP), keeping truncation errors under control. Use disorder Δi∈(−W,W)\Delta_i\in(-W,W) and average over several realizations.

After each Floquet period, measure the bulk x-magnetization and plot it versus the number of periods. Vary ϵ\epsilon to identify regimes with long-lived period-doubling (subharmonic 2T2T oscillations) versus rapid decay due to heating. Track entanglement growth and discuss how it limits the reachable simulation time. Create publication quality figures and physically analyze the results.

Solution Evaluator Prompt

Prompt You are a Report Evaluation Agent specialized in assessing whether a report satisfies task requirements.

Your Mission:

Carefully analyze the task requirements and the generated report to determine:

  1. Whether there are bugs that haven’t been fixed

  1. Whether the implementation is complete and correct

  1. Whether the key tools are well implemented

  1. Whether more simulation is needed

  1. Whether the report satisfies all requirements

  1. What the next step should be if the task is not complete

The task description is read from ./question.md and the report to evaluate from ./report.md.

Evaluation Criteria:

Bug Detection:

  • Check if the report mentions any errors, exceptions, or failures

  • Look for incorrect results or unexpected behavior

  • Identify missing error handling or edge cases

Script Completeness:

  • Verify all required functionality is implemented

  • Check if all task requirements are addressed

  • Ensure the implementation follows best practices

Result Completeness:

  • Verify the report contains all required information

  • Check if all task deliverables are present

  • Ensure the report is clear and comprehensive

  • Check important figures in the report

For example, in quantum chemistry calculations, the presence of a significant vibrational imaginary frequency after geometry optimization indicates that the structure is not a true minimum. In such cases, the geometry should be displaced along the corresponding mass-unweighted normal mode and subsequently re-optimized.

Output:

Evaluate the report and create a file called evaluation.json in the current directory with the following fields:

  • bug_need_fix: true if bugs detected that need fixing

  • script_complete: true if implementation is complete

  • further_simulation_needed: true if more simulation needed

  • result_complete: true if report satisfies all requirements

  • next_step_needed: true if any of the above conditions are not met

  • next_step_plan: specific next steps if needed with helpful notes, or “Task complete; no further action needed”

Decision Logic:

Set next_step_needed to false only when all four conditions hold simultaneously: no bugs detected (bug_need_fix is false), script is complete (script_complete is true), no further simulation needed (further_simulation_needed\texttt{further\_simulation\_needed} is false), and results are complete (result_complete\texttt{result\_complete} is true). If any condition fails, set next_step_needed\texttt{next\_step\_needed} to true and provide specific next steps.

Important Notes:

  1. Be thorough but not overly strict; minor issues that do not affect correctness may not require rework

  2. Focus on whether the task requirements are actually met, not whether the approach is optimal

  3. If the report indicates successful completion and all requirements appear met, do not create unnecessary next steps

  4. Be specific in your next_step_plan\texttt{next\_step\_plan}: provide actionable guidance, but do not suggest installing new software

  5. Consider the task context; some tasks may intentionally not require certain features

Please do thorough research and then create the evaluation.json\texttt{evaluation.json} file.

Judge Criteria and Ground Truths

Our evaluation criteria build on those introduced in El Agente Q ((Zou et al., 2025)) and El Agente Gráfico ([9]), but extend them in two ways. First, we adopt the dual-axis scoring scheme of El Agente Gráfico, which separates accuracy (numerical agreement with reference values) from methodology (correctness of the computational workflow), rather than a single binary pass/fail metric. Second, for the quantum dynamics tasks we introduce plot-level evaluation criteria that assess whether required figures are present and physically meaningful, complementing the quantitative checks. Reference values for the quantum chemistry tasks are obtained from El Agente Gráfico, while reference values for the quantum dynamics tasks are obtained from manually verified agent solutions. All reference values are provided below.

TaskVar.IDFull (1.0)Partial (0.5)
Organic CompoundsL0, L1, L2C1∣E−Eref∣≤0.001Eh|E-E_{\mathrm{ref}}| \le0.001 E_h0.001<∣E−Eref∣≤0.010Eh0.001 < |E-E_{\mathrm{ref}}| \le0.010 E_h
Organic CompoundsL0, L1, L2C2Symmetry group exact match (case-sensitive)—
Organic CompoundsL0, L1, L2C3∣μ−μref∣≤0.05 D|\mu-\mu_{\mathrm{ref}}| \le0.05\,\mathrm{D}0.05<∣μ−μref∣≤0.20 D0.05 < |\mu-\mu_{\mathrm{ref}}| \le0.20\,\mathrm{D}
Organic CompoundsL0, L1, L2C4∣ΔHL−ΔHL,ref∣≤0.002Eh|\Delta_{\mathrm{HL}}-\Delta_{\mathrm{HL,ref}}| \le0.002 E_h0.002<∣ΔHL−ΔHL,ref∣≤0.010Eh0.002 < |\Delta_{\mathrm{HL}}-\Delta_{\mathrm{HL,ref}}| \le0.010 E_h
Organic CompoundsL0, L1, L2C5Mulliken charge MAD ≤0.02 e\le0.02\,eMAD ≤0.05 e\le0.05\,e
Inorganic CompoundsL1, L2C1∣E−Eref∣≤0.001Eh|E-E_{\mathrm{ref}}| \le0.001 E_h0.001<∣E−Eref∣≤0.010Eh0.001 < |E-E_{\mathrm{ref}}| \le0.010 E_h
Inorganic CompoundsL1, L2C2Symmetry group exact match (case-sensitive)—
Inorganic CompoundsL1, L2C3∣μ−μref∣≤0.05 D|\mu-\mu_{\mathrm{ref}}| \le0.05\,\mathrm{D}0.05<∣μ−μref∣≤0.20 D0.05 < |\mu-\mu_{\mathrm{ref}}| \le0.20\,\mathrm{D}
Inorganic CompoundsL1, L2C4∣ΔHL−ΔHL,ref∣≤0.002Eh|\Delta_{\mathrm{HL}}-\Delta_{\mathrm{HL,ref}}| \le0.002 E_h0.002<∣ΔHL−ΔHL,ref∣≤0.010Eh0.002 < |\Delta_{\mathrm{HL}}-\Delta_{\mathrm{HL,ref}}| \le0.010 E_h
TaskVar.IDFull (1.0)Partial (0.5)
C5Mulliken charge MAD ≤0.02 e\le0.02\,eMAD ≤0.05 e\le0.05\,e
Carbo-cationsL1, L2C1∣ΔH−ΔHref∣≤2.0|\Delta H-\Delta H_{\mathrm{ref}}|\le2.0 kcal/mol (per molecule)2.0<∣ΔH−ΔHref∣≤5.02.0<|\Delta H-\Delta H_{\mathrm{ref}}|\le5.0 kcal/mol
C2∣ΔG−ΔGref∣≤2.0|\Delta G-\Delta G_{\mathrm{ref}}|\le2.0 kcal/mol (per molecule)2.0<∣ΔG−ΔGref∣≤5.02.0<|\Delta G-\Delta G_{\mathrm{ref}}|\le5.0 kcal/mol
Ring StrainL1, L2C1∣gap⁡(ΔHn)−ref⁡∣≤1.0|\operatorname{gap}(\Delta H_n)-\operatorname{ref}|\le1.0 kcal/mol (per consecutive RSE gap)1.0<∣gap⁡(ΔHn)−ref⁡∣≤3.01.0<|\operatorname{gap}(\Delta H_n)-\operatorname{ref}|\le3.0 kcal/mol
C2∣gap⁡(ΔGn)−ref⁡∣≤1.0|\operatorname{gap}(\Delta G_n)-\operatorname{ref}|\le1.0 kcal/mol (per consecutive RSE gap)1.0<∣gap⁡(ΔGn)−ref⁡∣≤3.01.0<|\operatorname{gap}(\Delta G_n)-\operatorname{ref}|\le3.0 kcal/mol
pKapK_aL1C119≤pKa≤2519\le pK_a\le25 (acetic acid, CPCM water, B3LYP/def2-SVP)—
C2ΔG=G(A−)−G(HA)∈[0.469,0.477] Eh\Delta G=G(\mathrm{A}^{-})-G(\mathrm{HA})\in[0.469,0.477]\,E_h—
C3Both GtotG_{\mathrm{tot}} values within ±0.005 Eh\pm0.005\,E_h of referenceOnly one GtotG_{\mathrm{tot}} within ±0.005 Eh\pm0.005\,E_h
pKapK_aL2C1−2.70≤pKa≤1.50-2.70\le pK_a\le1.50 (chlorofluoroacetic acid, SMD water)—
C2ΔG=G(A−)−G(HA)∈[0.451,0.458] Eh\Delta G=G(\mathrm{A}^{-})-G(\mathrm{HA})\in[0.451,0.458]\,E_h for target acid—
C3Both GtotG_{\mathrm{tot}} values within ±0.005 Eh\pm0.005\,E_h of referenceOnly one GtotG_{\mathrm{tot}} within ±0.005 Eh\pm0.005\,E_h
C4ΔG\Delta G for ≥2\ge2 reference acids within ±0.004 Eh\pm0.004\,E_h of reference and used to calibrate pKapK_a—
TDDFTL1, L2C1∣E(S1)−Eref∣≤0.05|E(S_1)-E_{\mathrm{ref}}|\le0.05 eV (per structure)0.05<∣E(S1)−Eref∣≤0.150.05<|E(S_1)-E_{\mathrm{ref}}|\le0.15 eV
C2∣E(T1)−Eref∣≤0.05|E(T_1)-E_{\mathrm{ref}}|\le0.05 eV (per structure)0.05<∣E(T1)−Eref∣≤0.150.05<|E(T_1)-E_{\mathrm{ref}}|\le0.15 eV
C3∣ΔE(S1−T1)−ref⁡∣≤0.03|\Delta E(S_1-T_1)-\operatorname{ref}|\le0.03 eV (per structure)0.03<∣ΔE(S1−T1)−ref⁡∣≤0.100.03<|\Delta E(S_1-T_1)-\operatorname{ref}|\le0.10 eV
C4f(S0→S1)f(S_0\to S_1) within 20% relative error (per structure)20% < rel. error ≤50\le50%

Table 7. Accuracy criteria for the quantum chemistry tasks. Per-property/per-molecule criteria are evaluated independently; full score (1.0) and partial score (0.5) conditions are shown; score 0 applies otherwise. Levels: L0 = level 0, L1 = level 1, L2 = level 2.

TaskVar.#Sub-task descriptionWt.
Organic CompoundsL0–L21Generate 3D geometries from SMILES or provided XYZ files20%
Organic CompoundsL0–L22Gas-phase optimization at HF/def2-SVP; correct charge/multiplicity per molecule; harmonic frequencies to confirm true minimum (no imaginary frequencies); re-optimize along imaginary mode if needed40%
Organic CompoundsL0–L23Report: optimized coordinates, total energy (EhE_h), point group, dipole (D), HOMO–LUMO gap (EhE_h), Mulliken charges40%
Inorganic CompoundsL1–L21Assign correct charge and multiplicity for each molecule25%
Inorganic CompoundsL1–L22Gas-phase geometry optimization (e.g. B3LYP/def2-SVP); harmonic frequency calculation to confirm true minimum; re-optimize if imaginary frequency found40%
Inorganic CompoundsL1–L23Report: optimized coordinates, total energy (EhE_h), point group, dipole (D), HOMO–LUMO gap (EhE_h), Mulliken charges35%
CarbocationsL1–L21Generate initial 3D geometries for all R–H parent molecules and R+^{+} carbocations; do not optimize H−^{-}10%
CarbocationsL1–L22Optimize R–H and R+^{+} (e.g. B3LYP/def2-SVP); harmonic frequencies for ZPE, HH, GG at 298.15 K; confirm true minima40%
CarbocationsL1–L23Extract HH and GG for all species; compute ΔH=H(R+)+H(H−)−H(R-H)\Delta H = H(\mathrm{R}^{+}) + H(\mathrm{H}^{-}) - H(\mathrm{R\text{-}H}) and ΔG\Delta G for each R–H→\rightarrowR+^{+}+H−^{-} reaction50%
Ring StrainL1–L21Generate initial 3D geometries for cycloalkanes (C3_3–C8_8) and methyl-cycloalkanes (C3_3–C7_7)10%
Ring StrainL1–L22Isodesmic ladder: cyclo-(Cn_nH2n_{2n}) →\rightarrow methylcyclo-(Cn−1_{n-1}H2n−3_{2n-3}) for n=4,5,6,7,8n = 4, 5, 6, 7, 825%
Ring StrainL1–L23Optimize all structures (e.g. B3LYP/def2-SVP); harmonic frequencies for HH and GG at 298.15 K; confirm true minima30%
Ring StrainL1–L24Extract HH and GG; compute reaction ΔH(n)\Delta H(n) and ΔG(n)\Delta G(n); accumulate RSE relative to cyclohexane (RSE = 0); report gap table35%
pKapK_aL11Target acid HA and conjugate base A−^{-}; proton H+^{+} handled via solvation energy20%
pKapK_aL12Optimize HA (charge 0) and A−^{-} (charge −1) with CPCM water (ε=78.4\varepsilon= 78.4); harmonic frequencies for GG at 298.15 K30%
pKapK_aL13ΔGdeprot=G(A−)+G(H+,solv)−G(HA)\Delta G_{\mathrm{deprot}} = G(\mathrm{A}^{-}) + G(\mathrm{H}^{+},\mathrm{solv}) - G(\mathrm{HA}); use G(H+,solv)=−265.9G(\mathrm{H}^{+},\mathrm{solv}) = -265.9 kcal/mol25%
pKapK_aL14pKa=ΔGdeprot/(RTln⁡10)=ΔGdeprot/1.3644pK_a = \Delta G_{\mathrm{deprot}}/(RT \ln10) = \Delta G_{\mathrm{deprot}}/1.3644 kcal/mol at 298.15 K25%
TaskVar.#Sub-task descriptionWt.
pKapK_aL21Target acid and conjugate base; ≥2\ge2 reference acids (acetic, fluoroacetic, chloroacetic) with known experimental pKapK_a15%
pKapK_aL22Optimize all acids and bases with PCM/CPCM water; harmonic frequencies for GG at 298.15 K; confirm true minima25%
pKapK_aL23For each acid HA: ΔGdeprot=G(A−)+G(H+)−G(HA)\Delta G_{\mathrm{deprot}}=G(A^-)+G(H^+)-G(HA); raw values are large because proton DFT/PCM energy is poorly described20%
pKapK_aL24For each reference acid: correction =ΔGexp−ΔGcalc=\Delta G_{\mathrm{exp}}-\Delta G_{\mathrm{calc}}; average over all reference acids to get single correction constant25%
pKapK_aL25Apply average correction to target ΔGdeprot\Delta G_{\mathrm{deprot}}; report pKa=ΔGcorr/(RTln⁡10)pK_a=\Delta G_{\mathrm{corr}}/(RT\ln10)15%
TDDFTL1–L21Optimize all structures (e.g. B3LYP/def2-SVP); confirm true minima (no imaginary frequencies)20%
TDDFTL1–L22TDDFT with suitable basis; request ≥5\ge5 singlet +≥5+\ge5 triplet roots; compute both SS and TT states50%
TDDFTL1–L23Extract E(S1)E(S_1) (eV), E(T1)E(T_1) (eV), ΔE(S1−T1)\Delta E(S_1-T_1) (eV), oscillator strength f(S0→S1)f(S_0\to S_1)30%

Table 8. Methodology criteria for the quantum chemistry tasks.

TaskIDCondition for score 1
Bell State (CUDA-Q)C1⟨Z⊗Z⟩\langle Z\otimes Z\rangle within ±0.1\pm0.1 of +1.0+1.0
Bell State (CUDA-Q)C2⟨X⊗X⟩\langle X\otimes X\rangle within ±0.1\pm0.1 of +1.0+1.0
Bell State (CUDA-Q)C3Only ∣00⟩\lvert00\rangle and ∣11⟩\lvert11\rangle appear in ZZ-basis, each ≈50%\approx50\%
Bell State (CUDA-Q)C4Histograms show two peaks at ∣00⟩\lvert00\rangle and ∣11⟩\lvert11\rangle (≈50%\approx50\% each) for both bases
Bell State (CUDA-Q)C5Discusses entanglement, why ⟨Z⊗Z⟩=⟨X⊗X⟩=+1\langle Z\otimes Z\rangle=\langle X\otimes X\rangle=+1, Bell correlations
H2_2 VQE Dissociation (tequila)C1VQE minimum at R=0.70R=0.70–0.800.80 Å, energy in [−1.17,−1.10][-1.17,-1.10] Ha
H2_2 VQE Dissociation (tequila)C2Curve shows clear minimum, steep rise at short RR, asymptote at large RR
H2_2 VQE Dissociation (tequila)C3VQE and exact (FCI) energies compared at ≥2\ge2 bond distances
H2_2 VQE Dissociation (tequila)C4Figure shows VQE and FCI curves, nearly overlapping, minimum near R=0.70R=0.70 Å
H2_2 VQE Dissociation (tequila)C5Discusses dissociation limit and why UCCSD is exact for H2_2/STO-3G
TaskIDCondition for score 1
Gibbs State (TenPy)C1E/LE/L reported negative, in [−0.7,−0.2][-0.7,-0.2] Ha (physically reasonable for U=4U=4, β=2\beta=2)
C2⟨ntot⟩≈1.0\langle n_{\mathrm{tot}}\rangle\approx1.0 and ⟨n↑⟩≈⟨n↓⟩≈0.5\langle n_{\uparrow}\rangle\approx\langle n_{\downarrow}\rangle\approx0.5
C3Energy curve monotonically decreasing with β\beta; occupancies flat at ≈1.0/0.5\approx1.0/0.5
C4Validates thermal state (energy, occupancy, double-occupancy); discusses Mott physics at U/t=4U/t=4
Ising Dynamics (CUDA-Q)C1FM heatmap (Jcoup=10JJ_{\mathrm{coup}}=10J, h=0.1Jh=0.1J) shows coherent, structured dynamics
C2PM heatmap (Jcoup=0.1JJ_{\mathrm{coup}}=0.1J, h=10Jh=10J) shows qualitatively different dynamics from FM
C3Two visually distinct heatmaps; FM: quasi-static stripes, small amplitude; PM: rapid uniform oscillations
C4Correctly identifies FM vs. PM regimes and explains dynamical differences
Open Qubit Dynamics (QuTiP)C1⟨Z⟩\langle Z\rangle oscillates persistently without decay (unitary) for both ∣+⟩|+\rangle and ∣−⟩|-\rangle
C2⟨Z⟩\langle Z\rangle decays to a steady state (Lindblad, C=0.2 σ−C=\sqrt{0.2}\,\sigma_{-}) for both states
C3Unitary panel: two mirror-image oscillatory curves; Lindblad: both converge to same steady state
C4Explains collapse operator role, steady state, why dissipation breaks oscillations
FMO HEOM (QuTiP)C1T=300 KT=300\,\mathrm{K}: populations sum to 1; site 0 starts at 1 and does not return above 0.5 after 300 fs
C2T=77 KT=77\,\mathrm{K} shows more pronounced quantum beats than T=300 KT=300\,\mathrm{K}
C3T=300 KT=300\,\mathrm{K}: damped oscillations, population spreading to ≥3\ge3 sites by 1 ps; T=77 KT=77\,\mathrm{K}: more pronounced beats
C4Discusses quantum coherence in energy transfer, Drude–Lorentz bath, temperature dependence, FMO light harvesting
GRAPE Control (QuTiP)C1Final fidelity ≥0.90\ge0.90 for ∣1⟩→∣3⟩|1\rangle\to|3\rangle transfer
C2Final population P3≥0.90P_3 \ge0.90 at end of evolution
C3Pulse figure (pump and Stokes vs. time) and population figure (P1P_1, P2P_2, P3P_3 vs. time) both present and correct
C4Discusses GRAPE optimization and transfer mechanism; STIRAP solutions mention dark-state passage
Floquet Kicked Ising (CUDA-Q)C1Heatmap with qubit index vs. Floquet step; magnetization near zero (≈±0.2\approx\pm0.2) with non-trivial structure
TaskIDCondition for score 1
C2Parameters J=1J=1, h=2Jh=2J, T=1T=1, 10 Floquet periods, 10 qubits, OBC stated or implied
C3Periodic or structured temporal evolution visible in magnetization
C4Discusses Floquet dynamics, strong kick, signatures of thermalization or ergodicity breaking
Floquet TD-DMRG Disorder (TenPy)C1Period-doubling (2T2T oscillations) in bulk xx-magnetization for ε=0\varepsilon=0
Floquet TD-DMRG Disorder (TenPy)C2Three ε\varepsilon values produce visually distinct dynamics (different amplitudes/phases/lifetimes)
Floquet TD-DMRG Disorder (TenPy)C3Magnetization: sign-alternating oscillations, decay to near-zero by period ≈20\approx20–3030; entropy: logarithmic growth to ≈2.0\approx2.0 over 50 periods
Floquet TD-DMRG Disorder (TenPy)C4Identifies DTC phase, discusses disorder stabilisation, Floquet heating, entanglement growth limit
Cluster Model String Order (TenPy)C1String order SNS_N transitions from ≈1\approx1 (cluster phase, θ=0\theta=0) to ≈0\approx0 (trivial, θ=π/2\theta=\pi/2)
Cluster Model String Order (TenPy)C2Results shown for all three system sizes N=11N=11, 21, 41
Cluster Model String Order (TenPy)C3Critical point estimated in Jc∈[0.65,0.85]J_c \in[0.65, 0.85] (or θc/π∈[0.18,0.28]\theta_c/\pi\in[0.18, 0.28])
Cluster Model String Order (TenPy)C4Three curves transitioning from SN≈1S_N \approx1 to 0; transition sharpens with NN; inflection at θ/π≈0.20\theta/\pi\approx0.20–0.250.25
Cluster Model String Order (TenPy)C5Discusses cluster phase, SPT order, string order as non-local order parameter, finite-size effects
Noisy Bell State (Qiskit)C1At p=0p=0: ⟨Z⊗Z⟩≈+1.0\langle Z \otimes Z \rangle\approx+1.0 and ⟨X⊗X⟩≈+1.0\langle X \otimes X \rangle\approx+1.0 (within ±0.1\pm0.1)
Noisy Bell State (Qiskit)C2Both ⟨ZZ⟩\langle ZZ\rangle and ⟨XX⟩\langle XX\rangle decrease monotonically as pp increases from 0 to 0.3
Noisy Bell State (Qiskit)C3⟨X⊗X⟩<0.5\langle X \otimes X\rangle< 0.5 at p=0.3p=0.3; asymmetric decay (⟨XX⟩\langle XX\rangle faster than ⟨ZZ⟩\langle ZZ\rangle) physically correct
Noisy Bell State (Qiskit)C4Figure: two curves from +1+1 at p=0p=0; ⟨XX⟩\langle XX\rangle decays faster; at p=0.3p=0.3: ⟨XX⟩≈0.2\langle XX\rangle\approx0.2–0.40.4, ⟨ZZ⟩≈0.6\langle ZZ\rangle\approx0.6–0.750.75
Noisy Bell State (Qiskit)C5Explains noise degradation of Bell entanglement, functional form of decay, CHSH bound

Table 9. Accuracy criteria for the quantum dynamics tasks. Each criterion CiC_i is scored 1 if the stated condition holds, 0 otherwise. The task score is Cˉ=1N∑i=1NCi\bar{C}=\frac{1}{N}\sum_{i=1}^{N}C_i.

Task#Sub-task descriptionWt.
Bell State (CUDA-Q)1Initialize 2-qubit ∣00⟩|00\rangle register; apply HH on qubit 0 then CNOT (control 0, target 1)20%
Bell State (CUDA-Q)2Sample 4096 shots in the computational basis; return counts dict; compute ⟨Z⊗Z⟩\langle Z\otimes Z\rangle40%
Bell State (CUDA-Q)3Insert HH on both qubits; sample 4096 shots; compute ⟨X⊗X⟩\langle X\otimes X\rangle40%
H2_2 VQE Dissociation (tequila)1Grid of HH–HH distances 0.4–2.2 Å (≥10\ge10 points); construct STO-3G Hamiltonian via tequila15%
H2_2 VQE Dissociation (tequila)2UCCSD (or hardware-efficient) ansatz; run VQE at each distance to convergence50%
H2_2 VQE Dissociation (tequila)3Compute FCI ground-state energy at each geometry; report both VQE and FCI in Ha or eV vs. bond distance35%
Gibbs State (TenPy)110-site 1D Hubbard chain, OBC, t=1t=1, U=4U=4, half-filling15%
Gibbs State (TenPy)2TEBD or TDVP in imaginary time from infinite-TT (purification) to β=2\beta=245%
Gibbs State (TenPy)3Compute ⟨H⟩\langle H\rangle, site-resolved occupancies ⟨ni,↑/↓⟩\langle n_{i,\uparrow/\downarrow}\rangle, verify half-filling; optional: double-occupancy profile40%
Ising Dynamics (CUDA-Q)110-qubit 1D Ising chain, OBC; sample a Haar-random initial state15%
Ising Dynamics (CUDA-Q)22nd-order Trotter for H=−J∑ZiZi+1−h∑XiH=-J\sum Z_iZ_{i+1}-h\sum X_i; T=10T=10, 1000 steps; two regimes: FM (Jcoup=10JJ_{\mathrm{coup}}=10J, h=0.1Jh=0.1J) and PM (Jcoup=0.1JJ_{\mathrm{coup}}=0.1J, h=10Jh=10J)50%
Ising Dynamics (CUDA-Q)3At each time step compute ⟨Zi(t)⟩\langle Z_i(t)\rangle for all 10 qubits; store full magnetization matrix35%
Open Qubit Dynamics (QuTiP)1H=X+0.5ZH=X+0.5Z; prepare ∣+⟩|+\rangle and ∣−⟩|-\rangle eigenstates of XX15%
Open Qubit Dynamics (QuTiP)2sesolve, t∈[0,40]t\in[0,40], 400 steps; record ⟨Z(t)⟩\langle Z(t)\rangle for each initial state35%
Open Qubit Dynamics (QuTiP)3Collapse operator C=γ σ−C=\sqrt{\gamma}\,\sigma_{-} with γ=0.2\gamma=0.2; mesolve; record ⟨Z(t)⟩\langle Z(t)\rangle for each initial state50%
FMO HEOM (QuTiP)17-site FMO Hamiltonian (cm−1^{-1}); Drude–Lorentz bath: λ=35\lambda=35 cm−1^{-1}, 1/γ=501/\gamma=50 fs; HEOM depth L=4L=4, Matsubara terms K=2K=220%
FMO HEOM (QuTiP)2Initialize density matrix on site 0; propagate 1 ps via HEOM-Solver; record all 7 site populations ρii(t)\rho_{ii}(t)40%

Table 10. Methodology criteria for the quantum dynamics tasks.

Comparisons between Tool-reuse, Zero-shot and Evaluator Only

Task#Sub-task descriptionWt.
3Repeat identical propagation at T=77 KT = 77\,\mathrm{K}; record all 7 site populations vs. time40%
GRAPE Control (QuTiP)13-level Λ\Lambda system; Hc1=∣1⟩⟨2∣+h.c.H_{c1} = \lvert1\rangle\langle2\rvert+ \mathrm{h.c.} (pump), Hc2=∣2⟩⟨3∣+h.c.H_{c2} = \lvert2\rangle\langle3\rvert+ \mathrm{h.c.} (Stokes); T=40T = 40, 3000 time slots15%
GRAPE Control (QuTiP)2Run GRAPE to find optimal pulse shapes for both controls; target ∣1⟩→∣3⟩\lvert1\rangle\to\lvert3\rangle; report final fidelity50%
GRAPE Control (QuTiP)3mesolve/sesolve under optimized pulses; record P1(t)P_1(t), P2(t)P_2(t), P3(t)P_3(t); confirm final fidelity35%
Floquet Kicked Ising (CUDA-Q)110-qubit OBC chain; J=1J = 1, T=1T = 1, h=2Jh = 2J; Haar-random initial state15%
Floquet Kicked Ising (CUDA-Q)2Floquet unitary = ZZZZ interaction layer + global XX kick; apply for 10 periods; compute ⟨Zi⟩\langle Z_i\rangle at each period50%
Floquet Kicked Ising (CUDA-Q)3Collect magnetization matrix M[t,i]=⟨Zi(t)⟩M[t,i] = \langle Z_i(t)\rangle for all periods t=0,…,10t = 0,\ldots,10 and sites i=0,…,9i = 0,\ldots,935%
Floquet TD-DMRG Disorder (TenPy)1L=10L = 10; J=1J = 1, Ωx=Ωy=4J\Omega_x = \Omega_y = 4J, τ1≈0.393\tau_1 \approx0.393, τ2=0.5\tau_2 = 0.5, W=2JW = 2J; scan ϵ∈{0,0.15,0.3}\epsilon\in\{0, 0.15, 0.3\}; 5 disorder realisations15%
Floquet TD-DMRG Disorder (TenPy)2Initialize in +x+x product state; TEBD/TDVP two-segment drive; χmax⁡=100\chi_{\max} = 100, δt=0.03\delta t = 0.03; evolve 50 periods50%
Floquet TD-DMRG Disorder (TenPy)3After each period: bulk xx-magnetization ⟨Sbulkx⟩\langle S^x_{\mathrm{bulk}}\rangle and bipartite entanglement entropy; store for all ϵ\epsilon and realisations35%
Cluster Model String Order (TenPy)1H(θ)=−cos⁡θ∑Ki−sin⁡θ∑XiH(\theta) = -\cos\theta\sum K_i - \sin\theta\sum X_i where Ki=Zi−1XiZi+1K_i = Z_{i-1}X_iZ_{i+1}; PBC rings of N=11,21,41N = 11, 21, 41; bond dimension χ=100\chi= 10020%
Cluster Model String Order (TenPy)2DMRG ground state ∣ψ0(θ;N)⟩\lvert\psi_0(\theta;N)\rangle for ≥20\geq20 values of θ∈[0,π/2]\theta\in[0,\pi/2]; verify energy convergence40%
Cluster Model String Order (TenPy)3String operator ON=Z1(∏j evenXj)ZNO_N = Z_1(\prod_{j\ \mathrm{even}} X_j)Z_N; compute SN(θ)=⟨ψ0∣ON∣ψ0⟩S_N(\theta) = \langle\psi_0\lvert O_N\rvert\psi_0\rangle; estimate JcJ_c from finite-size crossings of SN(J)S_N(J)40%
Noisy Bell State (Qiskit)1Qiskit Bell state (HH + CNOT); add depolarizing noise channel with probability pp20%
Noisy Bell State (Qiskit)2Simulate for p∈{0,0.05,0.1,0.2,0.3}p \in\{0, 0.05, 0.1, 0.2, 0.3\}, 4096 shots each; compute ⟨Z⊗Z⟩(p)\langle Z \otimes Z\rangle(p)40%
Noisy Bell State (Qiskit)3Insert HH on both qubits before measurement; simulate for all five pp; compute ⟨X⊗X⟩(p)\langle X \otimes X\rangle(p)40%

Table 19.

Comparisons between Tool-reuse, Zero-shot and Evaluator Only

Time and cost are per-run totals. Δ\Delta% = (TR−ZS)/ZS; negative = faster/cheaper. Avg = arithmetic mean of 3 runs. Avg Score = mean of (accuracy + methodology/2) per question.

Time and cost are per-run totals. Δ%\Delta\% = (TR−ZS)/ZS; negative = faster/cheaper. EO = Evaluator Only. Avg = arithmetic mean of 3 runs. Avg Score = mean of (accuracy + methodology/2) per question.

ModelQuantum ChemistryQuantum Dynamics
ZSTRΔ%\Delta\%EOZSTRΔ%\Delta\%EO
Claude Opus 4.676.8±5.076.8 \pm5.066.6±23.166.6 \pm23.1-13.3%74.0±6.974.0 \pm6.9128.4±28.6128.4 \pm28.615.2±2.715.2 \pm2.7-88.1%127.1±33.4127.1 \pm33.4
Claude Sonnet 4.682.0±29.282.0 \pm29.262.9±11.662.9 \pm11.6-23.3%64.2±11.164.2 \pm11.165.7±15.265.7 \pm15.232.9±19.432.9 \pm19.4-49.9%55.0±24.955.0 \pm24.9
GPT-5.2-Codex119.1±12.7119.1 \pm12.7119.6±34.0119.6 \pm34.0+0.4%184.5±81.0184.5 \pm81.062.4±29.762.4 \pm29.733.3±6.533.3 \pm6.5-46.7%18.9±0.518.9 \pm0.5
Gemini 3.1 Pro133.7±4.6133.7 \pm4.6106.5±39.0106.5 \pm39.0-20.3%149.2±74.9149.2 \pm74.935.8±8.035.8 \pm8.040.7±22.740.7 \pm22.7+13.6%15.4±2.315.4 \pm2.3
Kimi K2.5276.2±194.6276.2 \pm194.697.3±4.597.3 \pm4.5-64.8%194.6±124.7194.6 \pm124.7453.8±244.7453.8 \pm244.775.4±7.275.4 \pm7.2-83.4%193.9±140.2193.9 \pm140.2
Average137.6±41.6137.6 \pm41.690.6±7.090.6 \pm7.0-34.1%133.3±17.6133.3 \pm17.6149.2±47.9149.2 \pm47.939.5±7.039.5 \pm7.0-73.5%82.1±27.882.1 \pm27.8

Table 13. Average Execution Time per Question: Zero-shot vs. Tool-reuse vs. Evaluator Only. Values are arithmetic means across 3 runs. Δ%\Delta\% is relative to zero-shot.

ModelQuantum ChemistryQuantum Dynamics
ZSTRΔ%\Delta\%EOZSTRΔ%\Delta\%EO
Claude Opus 4.6$5.56 ±0.38\pm0.38 | $2.69 ±1.57\pm1.57-51.5%$1.61 ±0.19\pm0.19 | $5.15 ±2.28\pm2.28$1.92 ±0.76\pm0.76 | -62.7% | $1.55 ±0.14\pm0.14
Claude Sonnet 4.6$4.16 ±2.48\pm2.48 | $2.78 ±2.23\pm2.23-33.2%$1.07 ±0.10\pm0.10 | $5.09 ±3.64\pm3.64$1.69 ±1.14\pm1.14 | -66.8% | $0.83 ±0.13\pm0.13
GPT-5.2-Codex$2.20 ±0.24\pm0.24 | $0.96 ±0.11\pm0.11-56.2%$0.94 ±0.17\pm0.17 | $2.13 ±0.38\pm0.38$0.56 ±0.08\pm0.08 | -73.5% | $0.80 ±0.04\pm0.04
Gemini 3.1 Pro$4.44 ±0.16\pm0.16 | $2.07 ±0.89\pm0.89-53.4%$2.05 ±0.50\pm0.50 | $2.17 ±0.14\pm0.14$0.79 ±0.12\pm0.12 | -63.5% | $0.76 ±0.08\pm0.08
Kimi K2.5$1.74 ±0.37\pm0.37 | $0.62 ±0.12\pm0.12-64.2%$0.52 ±0.19\pm0.19 | $1.48 ±0.50\pm0.50$0.33 ±0.07\pm0.07 | -77.9% | $0.37 ±0.12\pm0.12
Average$3.62 ±0.53\pm0.53 | $1.83 ±0.72\pm0.72-49.6%$1.24 ±0.12\pm0.12 | $3.20 ±1.20\pm1.20$1.06 ±0.36\pm0.36 | -66.9% | $0.86 ±0.07\pm0.07

Table 14. Average Cost per Question: Zero-shot vs. Tool-reuse vs. Evaluator Only. Values are arithmetic means across 3 runs. Δ%\Delta\% is relative to zero-shot.

ModelQuantum ChemistryQuantum Dynamics
ZSTREOZSTREO
Claude Opus 4.61.31.11.21.11.21.2
Claude Sonnet 4.61.21.11.11.11.11.0
GPT-5.2-Codex1.82.02.11.91.31.8
Gemini 3.1 Pro1.61.61.91.21.21.2
Kimi K2.52.31.72.12.11.31.9
Average1.61.51.71.51.21.4

Table 15. Average Iterations per Question: Zero-shot vs. Tool-reuse vs. Evaluator Only. Values are averages across 3 runs. Lower is better.

Per-Task Breakdown

Tables 16 and 17 report the combined score (accuracy + methodology, averaged across all 5 models and 3 runs) for each task under zero-shot (ZS), tool-reuse (TR), and evaluator-only (EO) conditions. The task order here is also the order of tasks in the curriculum used in the tool-reuse mode in the benchmark.

TaskDescriptionTime (min) ZSTime (min) TRTime (min) EOCost (USD) ZSCost (USD) TRCost (USD) EOScore ZSScore TRScore EO
q01Organic L0282.485.290.3$5.16 | $2.30$1.42 | 84.7% | 87.1% | 83.3%
q02Organic L177.658.6100.5$3.20 | $1.46$0.71 | 83.7% | 91.6% | 76.6%
q03Organic L2142.862.590.6$3.30 | $1.42$0.97 | 82.8% | 90.7% | 81.6%
q04Inorganic L174.222.672.1$3.98 | $1.46$1.00 | 74.3% | 77.7% | 77.0%
q05Inorganic L271.337.144.4$3.59 | $1.70$0.94 | 83.4% | 88.1% | 76.2%
q06Carbocation L1116.490.7103.4$3.39 | $2.44$1.53 | 88.3% | 97.3% | 89.7%
q07Carbocation L2124.9141.6141.6$3.96 | $2.59$1.75 | 93.2% | 96.9% | 84.8%
q08Ring Strain L1184.3112.8199.3$3.07 | $2.05$1.27 | 80.7% | 85.1% | 82.5%
q09Ring Strain L2190.5150.9303.5$3.40 | $2.07$2.15 | 66.4% | 76.1% | 59.0%
q10pKapK_a L175.621.7110.0$3.74 | $1.30$1.60 | 82.1% | 76.9% | 67.0%
q11pKapK_a L2148.090.8257.6$4.88 | $2.53$2.36 | 78.0% | 77.0% | 53.3%
q12TD-DFT L1454.2353.5455.5$4.70 | $2.63$1.22 | 87.7% | 95.9% | 90.7%
q13TD-DFT L2163.9141.7130.7$1.40 | $1.23$0.52 | 74.3% | 74.6% | 75.6%
Avg162.0105.4161.5$3.68 | $1.94$1.34 | 81.5% | 85.8% | 76.7%

Table 16. Per-Task Aggregated Metrics: Quantum Chemistry

All values averaged across 5 models and 3 runs. Score = (accuracy + methodology)/2. ZS = Zero-shot, TR = Tool-reuse, EO = Evaluator Only. Bold = best condition.

TaskLabelTime (min) ZSTime (min) TRTime (min) EOCost (USD) ZSCost (USD) TRCost (USD) EOScore ZSScore TRScore EO
q01Bell State70.86.15.3$1.94 | $0.60$0.49 | 98.7% | 100.0% | 100.0%
q02H₂ VQE184.115.315.8$3.52 | $0.88$0.57 | 98.2% | 95.8% | 97.8%
q03Gibbs/Hubbard190.289.9319.8$4.93 | $2.35$2.48 | 71.7% | 75.1% | 78.3%
q04Ising Dyn.150.6228.380.4$3.66 | $1.47$1.10 | 94.2% | 93.6% | 94.8%
q05Open Qubit66.35.93.7$1.57 | $0.59$0.37 | 99.9% | 99.1% | 96.7%
q06FMO HEOM234.615.4163.3$2.34 | $0.72$0.77 | 90.3% | 94.5% | 88.1%
q07GRAPE113.48.362.5$3.86 | $0.84$0.82 | 97.5% | 97.8% | 94.8%
q08Floquet Ising48.110.262.8$3.01 | $0.70$0.80 | 92.5% | 98.8% | 95.5%
q09Floquet DMRG261.956.0112.8$5.10 | $2.26$1.90 | 81.0% | 85.3% | 83.7%
q10Cluster SPT612.0408.4649.8$7.01 | $3.76$1.73 | 87.8% | 87.6% | 80.5%
q11Noisy Bell75.86.77.2$1.82 | $0.71$0.41 | 94.9% | 97.3% | 94.7%
Avg182.577.3134.9$3.52 | $1.35$1.04 | 91.5% | 93.2% | 91.3%

Table 17. Per-Task Aggregated Metrics: Quantum Dynamics

All values averaged across 5 models and 3 runs. Score = (accuracy + methodology)/2. ZS = Zero-shot, TR = Tool-reuse, EO = Evaluator Only. Bold = best score condition.

Benchmark Score Heatmaps

Figure 8 and Figure 9 provide a visual overview of combined scores (accuracy + methodology, averaged over 3 runs) across all models, conditions, and tasks. Each cell is colour-coded on a red–yellow–green scale from 0% to 100%.

Figure 8. Quantum chemistry benchmark score heatmap. Rows correspond to model–condition–run combinations; columns correspond to the 13 quantum chemistry tasks. Colour scale: red (0%) through yellow (50%) to green (100%).

Figure 9. Quantum dynamics benchmark score heatmap. Rows correspond to model–condition–run combinations; columns correspond to the 11 quantum dynamics tasks. Colour scale: red (0%) through yellow (50%) to green (100%).

Benchmark Evaluation Procedure

Each agent run is evaluated along two independent axes, accuracy and methodology, using automated LLM-as-judge pipelines. The procedure is identical across both benchmark suites with minor adaptations described below.

Accuracy evaluation. For the quantum chemistry tasks, the evaluator first extracts numerical results from the agent’s output into a structured JSON file, which is then scored by a deterministic Python script that compares values against ground-truth references with appropriate tolerances. For the quantum dynamics tasks, a separate Claude Code instance (with Claude Sonnet 4.6) reads the task specification and the agent’s output files, then judges each predefined criterion as true or false. The accuracy score is the fraction of satisfied criteria.

Methodology evaluation. For both benchmarks, each task is accompanied by a set of weighted methodology stages that describe the expected workflow (e.g. Hamiltonian construction, solver selection, post-processing). A Claude Code-based evaluator (with Claude Sonnet 4.6) reads the agent’s workspace and scores each stage on a 0–10 scale based on whether the agent followed correct domain methodology, independent of numerical accuracy. The final methodology score is the weighted average across all stages. Valid alternative approaches that achieve the same scientific objective receive full credit.

Tool Merger

Over time, given enough different tasks, El Agente Forjador ends up creating sets of tools that are similar or identical in functionality. These excess tools negatively affect navigability and context efficiency. Therefore, we designed a tool merger, a part of the toolset optimizer that merges and deletes existing tools to reduce clutter.

Tool merging follows a simple and efficient pipeline. Docstrings and function signatures of all tools are extracted and embedded before being sorted into clusters via embedding similarity. Identified clusters are then passed to Tool Merger, which decides if and how they should be merged. Tools that require merging are stored in a temporary backup directory, and new merged tools are drafted. These are then passed to the tool verification agent to ensure their correctness before deleting the original tools. If a merged tool fails verification, feedback is passed back to the tool merging agent along with the original tools to try again. Upon any re-failure, the original set is restored to the main directory. The tool structure optimizer is called following any tool merging to ensure optimal organization.

In this way the smallest fully functional tool set possible can be maintained to ensure optimal navigability and context efficiency.

Here we present and demonstration run in which the tool merger works on a set of tools created by solving the quantum chemistry tasks. Tool merger identified two similarity clusters containing six tools in total. The first cluster grouped four DFT tools into two merge pairs: the gas-phase and solvation variants of both single-point energy calculations and geometry optimizations. In each pair, neither tool was a strict superset of the other: the solvation variants added implicit solvent support (CPCM/DDCOSMO) but lacked features such as density fitting and auxiliary basis selection present in the base tools, while the geometry optimization pair additionally suffered from inconsistent input and output field names (spin_multiplicity vs. spin, energy vs. final_energy). Tool merger unified each pair into a single tool that makes solvation an optional parameter while standardizing all interfaces.

The second cluster paired a thermochemistry tool with a vibrational frequency tool. Both internally computed the molecular Hessian via the same PySCF call, but the thermochemistry tool returned only thermodynamic quantities (ZPE, enthalpy, Gibbs free energy, entropy) filtered to real positive frequencies, while the vibrational tool returned the full frequency spectrum including imaginary modes and normal-mode displacement vectors. The unified replacement computes the Hessian once and returns both the complete vibrational analysis and all thermodynamic properties, eliminating a redundant and expensive matrix computation.

All three unified tools passed automated review by a separate verification agent on the first attempt with zero errors or retries, reducing the tool inventory from 18 to 15. The remaining 12 tools were found to be sufficiently distinct from one another and were left unchanged. Original source files were preserved in a backup directory to allow rollback if needed.

Tool File Edits During Execution

EL AGENTE FORJADOR’s iterative problem-solving loop gives the coding agent full write access to tool source files, allowing it to revise tools on the fly when execution results suggest a bug or a needed improvement. We expected this self-repair mechanism to be exercised frequently, yet our experiments show that in-place tool edits during execution were surprisingly rare for most setups.

Table 18 reports how often tools were modified during execution. We distinguish two kinds of modification: pre-generated tool edits, where the agent rewrites an existing tool file, and new tool creation, where the agent writes an entirely new tool file that did not previously exist. In the zero-shot setting, Kimi K2.5 (via OpenCode) created new tools in 29.9% of its 144 iterations and edited pre-existing tools in 13.9%, while Gemini 3.1 Pro (via OpenCode) created new tools in 30.6% of 98 iterations and edited pre-existing ones in 12.2%. GPT-5.2-Codex (via Codex) edited pre-existing tools in 12.8% of iterations and created new ones in 4.5%. By contrast, Opus 4.6 (via Claude Code) edited tools in only 6.0% of iterations and Sonnet 4.6 in 1.2%, with neither model ever creating new tools during execution. In the tool reuse setting, only Gemini 3.1 Pro and GPT-5.2-Codex edited tools by 3.9% and 3.3% of iterations, respectively; every other configuration left its tools untouched. These results suggest that the quality of initially generated tools differs greatly across models: stronger models produce tools that work correctly on first use, while weaker models must fall back on runtime patching, or even ad-hoc tool creation, to compensate for deficiencies in their initial implementations. The near-absence of edits in the tool reuse setting reinforces this interpretation, as the pre-existing library was generated by a stronger model (Opus 4.6) and thus requires little correction regardless of which model consumes it.

ModelTotal ItersEdit Existing ToolsCreated New Tools
Zero-shot
Opus 4.6 (Claude Code)845 (6.0%)0 (0%)
Sonnet 4.6 (Claude Code)811 (1.2%)0 (0%)
GPT-5.2-Codex (Codex)13317 (12.8%)6 (4.5%)
Gemini 3.1 Pro (OpenCode)9812 (12.2%)30 (30.6%)
Kimi K2.5 (OpenCode)14420 (13.9%)43 (29.9%)
Tool reuse
Opus 4.6 (Claude Code)8100
Sonnet 4.6 (Claude Code)7800
GPT-5.2-Codex (Codex)1224 (3.3%)0
Gemini 3.1 Pro (OpenCode)1024 (3.9%)0
Kimi K2.5 (OpenCode)11200

Table 18. Tool file modifications during execution, reported per iteration. Edit Existing Tools: iterations in which a pre-existing tool file was modified. Created New Tools: iterations in which at least one new tool file was written.

Tool Generation and Usage in Zero-Shot Runs

Figure 10 reports the total number of tools each model generated and invoked during zero-shot problem solving in the three runs of the two question sets.

Figure 10. Tool generation versus usage in three zero-shot runs, broken down by model and question set. Blue bars indicate tools that were both generated and used; red segments indicate tools that were generated but never invoked.

Overall, agents use the large majority of the tools they create: aggregated use rates range from 81.2% (Kimi K2.5) to 93.8% (GPT-5.2-Codex). Use rates are systematically higher on the quantum chemistry tasks (88–98%) than on quantum dynamics tasks (72–88%). Among the models, Kimi K2.5 generates the most tools in total (335) but leaves the largest share unused (81.2% use rate), while Gemini 3.1 Pro generates the fewest (124) yet maintains a comparable use rate (89.5%). GPT-5.2-Codex achieves the highest overall use rate (93.8%), suggesting that its tool generation strategy is the most targeted. Claude Opus 4.6 and Sonnet 4.6 fall between these extremes (90.3% and 88.8%, respectively), with both models showing a pronounced jump in use rate from quantum dynamics tasks (∼78–79%) to quantum chemistry tasks (∼98%). These results indicate that while all models occasionally generate tools they do not end up invoking, the waste is modest and concentrated in the simpler question set, where fewer tools are needed but agents generate them proactively.

Tool Generation Guidelines

The following are example skill documents (generation guidelines) provided to the tool generator agent during our experiments. Each guideline encodes domain-specific best practices for a particular computational task. For El Cuántico tasks, the LLM often possesses broad knowledge of quantum computing concepts but tends to implement everything from scratch using NumPy rather than leveraging established domain-specific libraries. The DMRG and pulse optimization guidelines therefore steer the agent toward using dedicated packages (TenPy and QuTiP, respectively) that provide optimized, well-tested implementations. For quantum chemistry tasks, the agent generally knows which computational chemistry packages to use but sometimes lacks the domain knowledge needed to diagnose and resolve specific numerical issues. The vibrational frequency guideline, for example, provides a detailed reference on how to properly analyze imaginary frequencies and verify projection quality, knowledge that is critical for obtaining physically meaningful results but is not always reliably captured in the LLM’s parametric knowledge.

DMRG

Prompt Always use TenPy to do DMRG.

Pulse Optimization

Prompt You should use the pulse optimizer provided by qutip_qtrl.pulseoptim.

Vibrational Frequency Calculation (PySCF)

Prompt Theory overview (what is being projected and why)

For a molecule with NN atoms:

  • Total Cartesian degrees of freedom: 3N3N

  • Translational modes: 3

  • Rotational modes:

    • 3 for non-linear molecules

    • 2 for linear molecules

  • Vibrational modes:

    • 3N−63N - 6 (non-linear)

    • 3N−53N - 5 (linear)

Vibrational frequencies come from

F=M−1/2HM−1/2\mathbf{F} = \mathbf{M}^{-1/2}\mathbf{H}\mathbf{M}^{-1/2}

where:

  • H: Cartesian Hessian (second derivatives of energy)

  • M: diagonal mass matrix

  • F: mass-weighted Hessian

The translation and rotation subspace must be projected out before diagonalization, otherwise you will see near-zero or imaginary frequencies.

PySCF provides this projection automatically if you use its harmonic analysis utilities correctly.

Hessian calculation

Choose the Hessian module consistent with your SCF type.

from pyscf import gto, scf
from pyscf.hessian import rhf, thermo

mol = gto.M(
    atom = '''
    O 0 0 0
    H 0 -0.757 0.587
    H 0 0.757 0.587
    ''',
    basis = 'cc-pvdz'
)

mf = scf.RHF(mol).run()
hess = rhf.Hessian(mf).kernel()
res = thermo.harmonic_analysis(mol, hess)
print(res['freq_wavenumber'])
  • hess has shape (3N,3N)(3N, 3N)

  • Units: Hartree / Bohr2^2

Verifying projection quality (best practice)

Check that:

  • No frequencies below ∼10 cm−1\sim10\ \mathrm{cm}^{-1} (except numerical noise)

  • Number of modes equals:

    • 3N−63N - 6 (non-linear)

    • 3N−53N - 5 (linear)

Linear vs non-linear molecules

PySCF automatically detects linearity from geometry and handles:

  • 5 projected modes for linear molecules

  • 6 projected modes for non-linear molecules

No manual intervention needed unless geometry is ill-conditioned.

Common pitfalls

IssueCauseFix
Imaginary frequenciesNot optimizedRe-optimize geometry
Small non-zero translational modesLoose SCF / gridTighten convergence
Wrong number of modesLinear molecule misdetectedCheck geometry
Large imaginary modesSaddle pointOptimize further

Table 20.

Example Traces of Coding Agents

Case Study Question 1

Prompt For the molecule ethylene (C=C\mathrm{C=C}), compute the first excited state energy using TD-DFT, and estimate the first excited state energy using a quantum algorithm. Optimize the geometry using B3LYP/def2-SVP and compute the S1 energy using TD-DFT. Identify an active space capturing the π\pi and σ\sigma system. Estimate the first excited state energy using Quantum Subspace Expansion with CUDA-Q simulation. Analyze the nature of the π→π∗\pi\rightarrow\pi^* transition, including limitations of TD-DFT versus quantum algorithms and the effect of correlation and active space choice. Make a visualization of important molecular orbitals.

Tool Analysis Report

Task Analysis

The task requires a multi-step workflow for ethylene:

  1. Geometry generation & optimization: Use smiles_to_3d_geometry to convert ‘C=C’ SMILES to initial

3D coordinates, then use run_dft_geometry_optimization with B3LYP/def2-SVP to get the optimized geometry.

  1. TD-DFT excited state: Use run_tddft_calculation on the converged DFT mean-field object to compute the S1S_1 excitation energy (π→π∗\pi\to\pi^{*} transition), getting excitation energies and oscillator strengths.

  1. MO analysis: Use analyze_molecular_orbitals to identify the HOMO (π\pi) and LUMO (π∗\pi^{*}) orbital indices and energies. Use the new visualize_molecular_orbitals tool to create contour plots of the π\pi and π∗\pi^{*} orbitals.

  1. Active space setup: Use run_pyscf_casci to validate the active space choice (e.g., 2 electrons in 2 orbitals for minimal π/π∗\pi/\pi^{*}, or larger spaces including σ/σ∗\sigma/\sigma^{*}). This provides a classical reference for the quantum algorithm.

  1. Quantum Hamiltonian construction: Use tequila_build_molecular_hamiltonian with the chosen active space to generate the qubit Hamiltonian for ethylene.

  1. Quantum Subspace Expansion: Use the new run_quantum_subspace_expansion tool with CUDA-Q to prepare the HF ground state, build excitation subspace, and compute the first excited state energy via QSE.

  1. Comparison & analysis: Compare TD-DFT vs. QSE vs. CASCI energies. Analyze the π→π∗\pi\to\pi^{*} transition character, TD-DFT limitations, quantum algorithm advantages, and active space effects.

Existing Tools (9)

  • smiles_to_3d_geometry.py

  • run_dft_geometry_optimization.py

  • run_tddft_calculation.py

  • analyze_molecular_orbitals.py

  • tequila_build_molecular_hamiltonian.py

  • tequila_compute_exact_energy.py

  • tequila_run_vqe.py

  • visualize_molecule.py

  • plot_line_comparison.py

New Tool Requirements (3)

  • visualize_molecular_orbitals — Generate 2D contour plots of molecular orbital wavefunctions from a converged PySCF mean-field object. Uses PySCF to evaluate MO wavefunctions on a grid, then takes a 2D slice and plots filled contour maps showing the orbital phase using matplotlib.

  • run_quantum_subspace_expansion — Implement QSE for computing excited state energies using CUDA-Q. Constructs the QSE subspace by applying single and double excitation operators to the reference state, builds the Hamiltonian and overlap matrices, and solves the generalized eigenvalue problem.

  • run_pyscf_casci — Run a CASCI calculation using PySCF. Given a converged mean-field object and active space specification, performs CASCI to obtain ground and excited state energies within the active space.

iteration_1 / Task Execution

Let me start by understanding the problem and the workspace structure, then plan and execute the solution step by step. Let me explore the workspace and available tools first.

Step 1: Bash — ‘ls /‘

Step 2: Bash — ‘ls /tools/ 2>/dev/null || echo "no tools dir"‘

Step 3: Bash — ‘ls /tools/electronic_structure_dft_calculations/ ...‘

Step 4: Read — ‘/tools/INDEX.md‘

Let me read the key tools I’ll need.

Step 5: Agent — {"description": "Read all key tools", "subagent_type": "Explore", "prompt": "Read the following files completely and report their function signatures, parameters, and return values:{}n{}n1. /...

Step 6: Read — ‘/tools/molecular_geometry_visualization_tools/molecular_geometry_processing/smiles_-to_3d_geometry.py‘

Step 7: Read — ‘/tools/electronic_structure_dft_calculations/dft_energy_calculations/run_dft_geometry_optimization.py‘

Step 8: Read — ‘/tools/electronic_structure_dft_calculations/run_tddft_calculation.py‘

Step 9: Read — ‘/tools/electronic_structure_dft_calculations/electronic_property_analysis/analyze_-molecular_orbitals.py‘

Step 10: Read — ‘/tools/visualize_molecular_orbitals.py‘

Step 11: Read — ‘/tools/run_pyscf_casci.py‘

Step 12: Read — ‘/tools/run_quantum_subspace_expansion.py‘

Step 13: Read — ‘/tools/electronic_structure_dft_calculations/tequila_molecular_energy_computation/te-quila_build_molecular_hamiltonian.py‘

Step 14: Read — ‘/tools/molecular_geometry_visualization_tools/scientific_data_visualization_tools/-plot_line_comparison.py‘

Now let me check what iterations/workspace content exists already.

Step 15: Bash — ‘ls /iterations/ 2>/dev/null; ls /...‘

Step 16: Bash — ‘mkdir -p /{logs,img}‘

Now let me create the scripts. I’ll break this into logical phases:

  1. script_1.py - Geometry generation, optimization, MO analysis, TD-DFT

  2. script_2.py - CASCI and Quantum Subspace Expansion

  3. script_3.py - Visualization and report generation

Let me read the tequila tool more carefully for the Hamiltonian building part, and also the QSE tool.

Step 17: Read — ‘/tools/run_quantum_subspace_expansion.py‘

Step 18: Read — ‘/tools/electronic_structure_dft_calculations/tequila_molecular_energy_computation/te-quila_build_molecular_hamiltonian.py‘

Now let me create the scripts. I’ll start with script_1.py for geometry optimization, MO analysis, TD-DFT, and CASCI.

Step 19: Write — ‘/script_1.py‘ (8,116 chars)

Now let me load the MCP tool schema and run script_1. Step 20: ToolSearch — {"query": "select:mcp_submit_job", "max_results": 1}

Step 21: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python script_1.py"}}

Step 22: Read — /logs/20260414_163936_script_1.out

Step 23: Bash — grep -E "^(===|—|HOMO|LUMO|S1|T1|Ground|State|Active|Optimized energy|Converged|MO| S| T| MO)" ...

Script 1 succeeded. Now let me create script_2 for the quantum subspace expansion using tequila + CUDA-Q.

Step 24: Write — /script_2.py (4,956 chars)

Step 25: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python script_2.py"}}

Step 26: Bash — tail -30 /logs/20260414_164059_script_2.out

Step 27: Bash — tail -30 /logs/20260414_164059_script_2.err

The tequila Hamiltonian iteration is different. Let me check how to convert.

Step 28: Write — /test_tequila.py (765 chars)

Step 29: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python test_tequila.py"}}

Step 30: Read — /logs/20260414_164233_test_tequila.out

Now I see the format. The keys are tuples of qubit-pauli pairs, and values are coefficients. Let me use paulistrings instead.

Step 31: Write — /test_tequila.py (969 chars)

Step 32: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python test_tequila.py"}}

Step 33: Bash — tail -5 /logs/20260414_164254_test_tequila.err

Step 34: Write — /test_tequila.py (834 chars)

Step 35: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python test_tequila.py"}}

Step 36: Read — /logs/20260414_164312_test_tequila.out

Now I understand the format. naked() returns a string like Z(0), X(0)Z(1)X(2), and coeff is the coefficient. Let me fix script_2.

Step 37: Edit — /script_2.py

Step 38: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python script_2.py"}}

Step 39: Read — /logs/20260414_164333_script_2.out

Good, QSE is working. The CAS(2,2) gives 4.88 eV first excitation which is close to the CASCI(2,2) value of 4.29 eV. Note the nuclear repulsion energy looks odd (-75.9 Ha) — that’s likely because tequila with active_orbitals folds core energy into the constant. The CAS(4,4) gives 2.29 eV which seems low. The sto-3g basis is quite small; let me note this is expected behavior for a minimal basis.

Now let me create script_3 for visualization and report generation.

Step 40: Write — /script_3.py (11,697 chars)

Step 41: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python script_3.py"}}

Step 42: Read — /logs/20260414_164457_script_3.out

All three scripts completed successfully. Let me fix the image paths in the report since the visualize tool used different naming than expected. Step 43: Edit — ‘/script_3.py‘

Step 44: mcp_submit_job — {"workspace_dir": "", "step": {"command": "python script_3.py"}}

Let me verify the images and report are in place.

Step 45: Bash — ‘ls /img/‘

Let me check the MO images look reasonable.

Step 46: Read — ‘/img/mo_xz_7.png‘

Step 47: Read — ‘/img/mo_xz_8.png‘

The MO plots look excellent — MO 7 (HOMO) shows the classic π\pi bonding orbital with one nodal plane, and MO 8 (LUMO) shows the π∗\pi^{*} antibonding with two lobes of opposite sign on each carbon. Let me check the comparison plot and verify the report.

Step 48: Read — ‘/img/method_comparison.png‘

Everything looks good. All three scripts ran successfully:

Summary of results:

  1. Script 1 - Geometry optimization (B3LYP/def2-SVP), MO analysis, TD-DFT, and CASCI

  • S1 (π→π∗\pi\to\pi^{*}) via TD-DFT: 8.15 eV (f=0.37) - HOMO-LUMO gap: 7.66 eV - CASCI(2,2)/(4,4)/(6,6) first excitation (T1): ~4.29 eV

  1. Script 2 - Tequila qubit Hamiltonian + QSE with CUDA-Q

  • QSE(2,2): 4.88 eV first excitation (4 qubits) - QSE(4,4): 2.29 eV first excitation (8 qubits, 53-dim subspace) . . . (+391 chars)

iteration_1 / Evaluation

Let me read the question and report files.

Step 1: Read — ‘/question.md‘

Step 2: Read — ‘/report.md‘

Let me check if the key files exist.

Step 3: Glob — ‘*.py‘ in “

Step 4: Glob — ‘img/*‘ in “

The report and all referenced files exist. Let me verify the key requirements against the report:

  1. Geometry optimization (B3LYP/def2-SVP) - Done ✓

  1. S1 energy via TD-DFT - Done (8.15 eV) ✓

  1. Active space identification (π\pi and σ\sigma system) - Done (CAS(2,2), CAS(4,4), CAS(6,6)) ✓

  1. QSE with CUDA-Q simulation - Done ✓

  1. Analysis of π→π∗\pi\to\pi^{*} transition, TD-DFT vs quantum limitations, correlation/active space effects - Done ✓

  1. MO visualization - Done, images exist ✓

The rep. . . (+230 chars)

Step 5: Write — ‘/evaluation.json‘ (225 chars)

Created evaluation.json. The report satisfies all task requirements:

  • Geometry optimization at B3LYP/def2-SVP completed

  • TD-DFT S₁ energy computed (8.15 eV, f=0.375)

  • Active space identified with CAS(2,2), (4,4), (6,6) covering π/σ\pi/\sigma systems

  • QSE with CUDA-Q performed for CAS(2,2) and CAS(4,4)

  • Analysis covers π→π∗\pi\to\pi^* nature, TD-DFT limitations, quantum algorithm advantages, and active space/correlation effects

  • MO visualizations present (8 orbital images + method com … (+13 chars)

Case Study Question 2

Prompt Model a rubidium-87 hyperfine qubit as a two-level open quantum system. Compute the ground-state electron density at the nucleus using PySCF, construct a two-level Hamiltonian (H=(ω/2)ZH=(\omega/2)Z) from it, and simulate Lindblad dynamics with QuTiP. Study the evolution from (a) the excited state (∣1⟩|1\rangle) and (b) a superposition ((∣0⟩+∣1⟩)/2|0\rangle+|1\rangle)/\sqrt{2}), then plot the excited-state population and coherence over time and provide a brief analysis. Your plots should be publication-quality.

Tool Analysis Report

The task requires three main computational steps:

Step 1: PySCF electron density computation. Run a DFT calculation on a rubidium atom (Rb, Z=37Z=37) using run_dft_single_point.py. Then use the new compute_electron_density_at_nuclei tool to evaluate ∣ψ(0)∣2|\psi(0)|^2 at the Rb nucleus. This contact density feeds into the Fermi contact hyperfine interaction, from which the hyperfine splitting frequency ω\omega (∼\sim6.835 GHz) can be derived. The new tool is general-purpose and reusable for any hyperfine coupling, NMR chemical shift, or Mössbauer spectroscopy calculation.

Step 2: Simulate Lindblad dynamics with QuTiP. Use qutip_lindblad_evolution.py to simulate the two-level system H=(ω/2)σzH=(\omega/2)\sigma_z with collapse operators modeling T₁ decay (γ1 σ−\sqrt{\gamma_1}\,\sigma_-) and pure dephasing (γϕ/2 σz\sqrt{\gamma_\phi/2}\,\sigma_z). Run two simulations: (a) starting from ∣e⟩|e\rangle and (b) starting from (∣e⟩+∣g⟩)/2(|e\rangle+|g\rangle)/\sqrt{2}.

Step 3: Visualization. Use plot_line_comparison.py to create publication-quality plots showing excited-state population Pe(t)P_e(t) and coherence ∣ρ01(t)∣|\rho_{01}(t)| as functions of time for both initial conditions, overlaying analytical solutions for validation.

Existing Tools (4)

  • run_dft_single_point.py (from quantum chemistry)

  • run_single_point_hf.py (from quantum chemistry)

  • qutip_lindblad_evolution.py (from quantum dynamics)

  • plot_line_comparison.py (from quantum dynamics)

New Tool Requirements (1)

  • compute_electron_density_at_nuclei — Compute the total electron density at nuclear positions from a converged PySCF SCF object. Uses the converged density matrix and evaluates basis functions at the specified nuclear coordinates via pyscf.dft.numint.eval_ao and eval_rho. Supports both restricted (RHF/RKS) and unrestricted (UHF/UKS) SCF objects.

Task Execution

Let me understand the problem and plan my approach.

I need to:

  1. Compute electron density at Rb nucleus using PySCF

  2. Use that to derive hyperfine frequency (6.834 GHz for Rb-87)

  3. Simulate Lindblad dynamics with QuTiP for two initial states

  4. Plot results

Let me first check what tools are available in the tools/ directory.

Step 1: Bash — ls tools/ 2>/dev/null

Step 2: Bash — pwd && ls

Step 3: Bash — ls tools/molecular_electronic_structure_tools/ && echo "—...

Step 4: Bash — ls tools/qutip_quantum_dynamics_tools/qutip_quantum_dynamics_evolution/qutip_...

Step 5: Read — tools/compute_electron_density_at_nuclei.py

Step 6: Read — tools/qutip_quantum_dynamics_tools/qutip_quantum_dynamics_evolution/qutip_lindblad_evolution.py

Step 7: Read — tools/molecular_visualization_analysis_tools/scientific_data_visualization_tools/plot_line_comparison.py

Step 8: Read — tools/molecular_electronic_structure_tools/dft_energy_calculations/run_dft_single_point.py

Now I have all the tools. Let me create the scripts.

Step 9: Write — script_1.py (10,377 chars)

Now let me run it.

Step 10: ToolSearch — {"query": "select:mcp_submit_job", "max_results": 1}

Step 11: mcp_submit_job — {"workspace_dir": "/case_study_q2_take7", "step": {"command": "python script_1.py"}}

Step 12: Bash — cat logs/20260415_213934_script_1.err

cc-pVDZ doesn’t support Rb. Let me use a different basis set.

Step 13: Edit — script_1.py

Step 14: mcp_submit_job — {"workspace_dir": "/case_study_q2_take7", "step": {"command": "python script_1.py"}}

Step 15: Bash — cat logs/20260415_213944_script_1.out | grep -E "^(=|Part|...

Everything succeeded. Let me check the plots and write the report.

Step 16: Read — img/population_decay.png

Step 17: Read — img/coherence_decay.png

The plots look good but I notice the numerical curves for the ∣1⟩|1\rangle initial case don’t match the analytical ones. The issue is that the analytical solution for population starting from ∣1⟩|1\rangle should decay, but the numerical shows it staying at 1 then decaying. Wait — looking more carefully, the numerical ∣1⟩|1\rangle curve (solid blue) stays near 1 while analytical (dashed blue) decays. That’s wrong. The problem is the Hamiltonian convention — sigmaz has ∣0⟩|0\rangle as +1 eigenstate and ∣1⟩|1\rangle as -1, so basis(2,1) i... (+746 chars) Step 18: Edit — ‘script_1.py‘

Step 19: Edit — ‘script_1.py‘

Now update the analytical labels to match:

Step 20: Edit — ‘script_1.py‘

Wait, let me think about the analytical solution more carefully. For the superposition state (∣0⟩+∣1⟩)/2(|0\rangle+|1\rangle)/\sqrt{2}, the initial excited population is 0.5. Under T1 decay, Pe(t)=0.5∗exp⁡(−t/T1)P_e(t) = 0.5 * \exp(-t/T1). Let me fix that.

Step 21: Edit — ‘script_1.py‘

Also update the plot labels:

Step 22: Edit — ‘script_1.py‘

Step 23: Edit — ‘script_1.py‘

Step 24: mcp_submit_job — {"workspace_dir": "/case_study_q2_take7", "step": {"command": "python script_1.py"}}

Step 25: Read — ‘img/population_decay.png‘

Step 26: Read — ‘img/coherence_decay.png‘

The plots look correct now — numerical and analytical curves overlap perfectly. Now let me write the report.

Step 27: Write — ‘report.md‘ (5,001 chars)

The solution is complete. Here’s a summary:

Script: script_1.py — runs all three phases in one script.

Results:

  1. PySCF DFT (B3LYP/def2-SVP): Computed electron density at Rb nucleus = 2.655 e/bohr^3. The computed Fermi contact coupling overestimates the experimental value because it includes all core electrons, not just the valence 5s electron. The experimental hyperfine splitting (6.835 GHz) is used for dynamics.

  1. Lindblad dynamics (T1=10, T2=5 in units of 1/omega):

-. . . (+280 chars)

iteration_1 / Evaluation

Let me read the question and report files.

Step 1: Read — ‘question.md‘

Step 2: Read — ‘report.md‘

Step 3: Glob — ‘*.py‘ in ‘/case_study_q2_take7‘

Step 4: Glob — ‘img/*‘ in ‘/case_study_q2_take7‘

Step 5: Glob — ‘intermediate_*.json‘ in ‘/case_study_q2_take7‘

Let me check the script and outputs to verify correctness.

Step 6: Read — ‘script_1.py‘

Step 7: Read — ‘intermediate_1.json‘

Step 8: Read — ‘intermediate_2.json‘ Let me verify the plots exist and check them visually.

Step 9: Read — `img/population_decay.png`

Step 10: Read — `img/coherence_decay.png`

Everything checks out. The task is fully complete.

Summary of evaluation:

  • PySCF electron density: Computed correctly (2.655 e/bohr32.655\ \mathrm{e}/\mathrm{bohr}^{3}), SCF converged, with proper discussion of why total density overestimates hyperfine coupling

  • Hamiltonian: Correctly constructed as H=(ω/2)σz\mathrm{H} = (\omega/2)\sigma_z using experimental Rb-87 frequency

  • Lindblad dynamics: Both initial states (excited and superposition) simulated with correct collapse operators (T1 relaxation + pure dephasing)

  • Plots: Publicati

(+215 chars)

Step 11: Write — `evaluation.json` (225 chars)

evaluation.json created. All requirements are met — the report covers PySCF electron density computation, Lindblad dynamics for both initial states, publication-quality plots with analytical comparison, and thorough physical analysis.

Tool Generation Trace: run_quantum_subspace_expansion

The following trace illustrates the tool generation and iterative review process for the QSE tool forged during Case Study 1. The tool generator (Claude Sonnet 4.6 via Claude Code) first explores the CUDA-Q API, implements the tool, and submits it for automated review. The reviewer identifies three algorithmic bugs, which are fixed and re-verified in a second review iteration.

Tool Generation Iter 1

Let me start by exploring the cudaq library to understand its API for state simulation and Pauli operators.

Step 1: ToolSearch — {"query": "select:TodoWrite", "max_results": 1}

Let me explore the cudaq library to understand its API.

Step 2: TodoWrite — {"todos": [{"content": "Search for cudaq APIs relevant to QSE", "status": "in_progress", "activeForm": "Searching for cudaq APIs"}, {"content": "Plan implementation", "status": "pending", "activeForm"...

Step 3: Read — `/.venv/lib/python3.11/site-packages/.maestra/indexes/cudaq.md`

Step 4: Grep — `class State|def get_state|from_data|StateData` in `/.venv/lib/python3.11/site-packages/cudaq`

Step 5: Bash — `cd && python -c "import cudaq; help(cudaq.State)" 2>&1 | head -60`

Step 6: Bash — `cd && python -c " import cudaq # Check spin operator API print('=== spin ===')...`

Step 7: Bash — `cd && python -c " import cudaq # Check observe and get_state help(cudaq.observ...`

Step 8: Bash — `cd && python -c " import cudaq import numpy as np`

# Test basic state creation...

Step 9: Bash — `cd && python -c " import cudaq import numpy as np`

# Test overlap sv1 = np.arr...

Good. Now I have everything I need. The approach:

  1. Build Hamiltonian as cudaq.SpinOperator from Pauli terms

  2. Create reference state via cudaq.State.from_data()

  3. Generate excitation operators (single/double) as Pauli strings, apply them to reference state as matrices

  4. Build H and S matrices using state.overlap() and matrix-vector products

  5. Solve generalized eigenvalue problem with scipy.linalg.eigh

Step 10: TodoWrite — {"todos": [{"content": "Search for cudaq APIs relevant to QSE", "status": "completed", "activeForm": "Searching for cudaq APIs"}, {"content": "Plan implementation", "status": "completed", "activeForm": "Planning implementation"}] ...

Step 11: Write — /tool_smith/task_0f1ba6682313/run_quantum_subspace_expansion.py (12,413 chars)

Let me verify it imports and runs:

Step 12: Bash — cd && python -c " from case_study_q1.tool_smith.task_0f1ba6682313.run_quantum_..."

Works correctly. Now write the report.

Step 13: Write — /tool_smith/task_0f1ba6682313/report.md (1,962 chars)

Step 14: TodoWrite — {"todos": [{"content": "Search for cudaq APIs relevant to QSE", "status": "completed", "activeForm": "Searching for cudaq APIs"}, {"content": "Plan implementation", "status": "completed", "activeForm": "Planning implementation"}] ...

Done. The tool run_quantum_subspace_expansion.py and report.md are saved. Key points:

  • Pydantic I/O models with full validation (PauliTerm, ExcitationOperator, input/output models)

  • Auto-generates single and double qubit excitation operators from occupied/virtual orbital indices when not provided

  • Builds subspace by applying excitation operator matrices to the reference statevector

  • Solves the generalized eigenvalue problem Hc = ESc via canonical orthogonalization

... (+230 chars)

Tool Review Iter 1

Let me read the tool code first.

Step 1: Read — /tool_smith/task_0f1ba6682313/run_quantum_subspace_expansion.py

Let me review the algorithm:

  1. Basis vectors not normalized: Line 264-266 checks norm > 1e-12 but doesn’t normalize. The comment on line 257 says "(normalized)" but normalization isn’t done. This is actually fine for QSE - you don’t need to normalize because you solve the generalized eigenvalue problem Hc=ES∗cHc = ES*c which handles non-orthonormal bases.

  2. Using .real on overlap matrix: Line 287 np.linalg.eigh(S_proj.real) - this discards imaginary parts. For a Hermitian matrix, the

... (+1152 chars)

I see several algorithm issues. The main problems are discarding imaginary parts of complex matrices and using transpose instead of conjugate transpose. Let me fix them.

Step 2: Edit — /tool_smith/task_0f1ba6682313/run_quantum_subspace_expansion.py

Now let me write and run a minimal test: Step 3: Bash — `python -c " import numpy as np

Test: 2-qubit Heisenberg-like Hamiltonian H = 0.5ZI - 0.5IZ + 0.25XX + 0.25YY # Ex...`

The eigenvectors are now complex (correct!), but the output model expects list[list[float]]. I need to output the real parts of eigenvectors (they’re defined up to a phase anyway), or better, output their magnitudes. Let me fix the output conversion:

Step 4: Edit — /tool_smith/task_0f1ba6682313/run_quantum_subspace_expansion.py

Step 5: Bash — python -c " import numpy as np I2 = np.eye(2, dtype=complex) X = np.array([[0,1],[1,0]], dtype=complex) Y = np.array([[0...

The QSE correctly finds the ground and excited state energies. The subspace is only 2D (reference + one single excitation) for this 2-qubit system, so it captures 2 of the 4 eigenvalues, which is expected.

Now let me also verify the eigenvalues are exact for this case — -1.118 and 1.118 match the exact values perfectly.

Let me also quickly check that the eigenvector output conversion doesn’t lose critical sign info. The eigenvectors from eigh on the real-valued H_orth will be real, but X. . . (+305 chars)

Step 6: Write — /tool_smith/task_0f1ba6682313/review_iter_1.json (1,413 chars)

Review complete. Three algorithm correctness bugs were found and fixed:

  1. S_proj.real → S_proj: The overlap matrix eigendecomposition was discarding imaginary parts, producing wrong canonical orthogonalization when basis vectors are complex (which happens whenever Y-gate excitation operators are applied).

  1. H_proj.real → H_proj: Same issue for the projected Hamiltonian matrix.

  1. X.T → X.conj().T: The canonical orthogonalization transform must use conjugate transpose . . . (+161 chars)

Tool Review Iter 2

Let me read the tool code first.

Step 1: Read — /tool_smith/task_0f1ba6682313/run_quantum_subspace_expansion.py

The previous review fixed three issues. Let me verify they’re addressed:

  1. np.linalg.eigh(S_proj) - Yes, line 287, using full complex matrix ✓

  2. X.conj().T @ H_proj @ X - Yes, line 298 ✓

  3. .real on eigenvector output - Yes, line 313 ✓

Now let me check for remaining algorithm issues:

  1. The basis vectors are NOT normalized before building H_proj and S_proj (line 266 - no normalization). This is fine - the overlap matrix S handles non-orthonormal bases. The generalized eigenvalue probl

. . . (+867 chars)

The previous fixes are all properly applied. Let me run a quick test to verify correctness.

Step 2: Bash — Test QSE tool correctness: python -c " import numpy as np from run_quantum_subspace_expansion import *

# 2... The QSE finds 2 of 4 eigenvalues correctly (subspace is only dimension 2 with 1 occupied + 1 virtual orbital, so singles-only gives 2 states). The energies match exact diagonalization. The code is correct.

Step 3: Write — `/tool_smith/task_0f1ba6682313/review_iter_2.json` (25 chars)

The tool is approved. All three previously identified issues have been properly fixed:

  1. np.linalg.eigh(S_proj) uses the full complex overlap matrix (line 287)

  2. X.conj().T @ H_proj @ X uses conjugate transpose (line 298)

  3. Eigenvector output uses .real for the float-typed model (line 313)

Verified with a 2-qubit Hamiltonian — QSE energies match exact diagonalization to machine precision.

References

  1. [1]Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., & al., . et . (2023). Gpt-4 technical report. In arXiv preprint. https://arxiv.org/abs/2303.08774
  2. [2]Julia Adolphs and Thomas Renger. How proteins trigger excitation energy transfer in the fmo complex of green sulfur bacteria. Biophys. J., 91(8):2778–2797, 2006.pubmed.ncbi.nlm.nih.gov/16861264
  3. [4]Anthropic. (2024). Introducing the model context protocol. https://www.anthropic.com/news/model-context-protocolanthropic.com/news/model-context-protocol
  4. [5]Anthropic. (2025). Agent skills – Claude platform documentation. https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overviewplatform.claude.com/docs/en/agents-and-tools/agent-skills/overview
  5. [7]Anthropic. (2026). Introducing claude opus 4.6. https://www.anthropic.com/news/claude-opus-4-6anthropic.com/news/claude-opus-4-6
  6. [9]Bai, J., Aldossary, A., Swanick, T., Müller, M., Kang, Y., Zhang, Z., Lee, J. W., Ko, T. W., Vakili, M. G., Bernales, V., & Aspuru-Guzik, A. (2026). El agente gráfico: Structured execution graphs for scientific agents. In arXiv preprint. https://arxiv.org/abs/2602.17902
  7. [10]Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML ’09, pages 41–48. ACM, 2009. doi:10.1145/1553374.1553380. http://dx.doi.org/10.1145/1553374.1553380.
  8. [11]Daniil A. Boiko, Robert MacKnight, and Gabe Gomes. Emergent autonomous scientific research capabilities of large language models. arXiv preprint arXiv:2304.05332, 2023. https://arxiv.org/abs/2304.05332.
  9. [12]Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. Advances in Neural Information Processing Systems, 33:1877–1901, 2020. https://papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f264-Abstract.html.papers.nips.cc/paper/2020/hash/1457c0d6bfcb4967418bfb8ac142f264-Abstract.html
  10. [13]Shuxiang Cao, Zijian Zhang, Mohammed Alghadeer, Simone D. Fasciati, Michele Piscitelli, Mustafa Bakr, Peter Leek, and Alán Aspuru-Guzik. Automating quantum computing laboratory experiments with an agent-based AI framework. Patterns, 6(10):101372, October 2025. ISSN 2666-3899. doi:10.1016/j.patter.2025.101372. http://dx.doi.org/10.1016/j.patter.2025.101372.
  11. [14]Mark E. Casida. Time-dependent density functional response theory for molecules. In Recent Advances In Density Functional Methods: (Part I), pages 155–192. World Scientific, 1995.DOI
  12. [15]Changhyeok Choi, Yunheng Zou, Marcel Müller, Han Hao, Yeonghun Kang, Juan B. Pérez-Sánchez, Ignacio Gustin, Hanyong Xu, Mohammad Ghazi Vakili, Chris Crebolder, Alán Aspuru-Guzik, and Varinia Bernales. El agente estructural: An artificially intelligent molecular editor. arXiv preprint arXiv:2602.04849, 2026. https://arxiv.org/abs/2602.04849.
  13. [17]Ken Deng, Xiangfei Wang, Guijing Duan, Chen Mo, Junkun Huang, Runqing Zhang, Ling Qian, Zhiguo Huang, Jize Han, and Di Luo. Towards verifiable and self-correcting ai physicists for quantum many-body simulations. arXiv preprint arXiv:2604.00149, 2026. https://arxiv.org/abs/2604.00149.
  14. [18]Yihong Dong, Xue Jiang, Jiaru Qian, Tian Wang, Kechi Zhang, Zhi Jin, and Ge Li. A survey on code generation with LLM-based agents. arXiv preprint arXiv:2508.00083, 2025. https://arxiv.org/abs/2508.00083.
  15. [19]Frisch, M. J., Trucks, G. W., Schlegel, H. B., Scuseria, G. E., Robb, M. A., Cheeseman, J. R., Scalmani, G., Barone, V., Petersson, G. A., Nakatsuji, H., Li, X., Caricato, M., Marenich, A. V., Bloino, J., Janesko, B. G., Gomperts, R., Mennucci, B., Hratchian, H. P., Ortiz, J. V., … Fox, D. J. (2016). Gaussian 16 Revision C.01.
  16. [20]Huan-ang Gao, Jiayi Geng, Wenyue Hua, Mengkang Hu, Xinzhe Juan, Hongzhang Liu, Shilong Liu, Jiahao Qiu, Xuan Qi, Yiran Wu, Hongru Wang, Han Xiao, Yuhang Zhou, Shaokun Zhang, Jiayi Zhang, Jinyu Xiang, Yixiong Fang, Qiwen Zhao, Dongrui Liu, Qihan Ren, Cheng Qian, Zhenhailong Wang, Minda Hu, Huazheng Wang, Qingyun Wu, Heng Ji, and Mengdi Wang. A survey of self-evolving agents: What, when, how, and where to evolve on the path to artificial super intelligence. arXiv preprint arXiv:2507.21046, 2025. https://arxiv.org/abs/2507.21046.
  17. [21]Giannozzi, P., Baroni, S., Bonini, N., Calandra, M., Car, R., Cavazzoni, C., Ceresoli, D., Chiarotti, G. L., Cococcioni, M., Dabo, I., & al., . et . (2009). Quantum espresso: a modular and open-source software project for quantum simulations of materials. Journal of Physics: Condensed Matter, 21(39), 395502.
  18. [22]DeepMind, G. (2026). Gemini 3.1 Pro model card. In Technical report. <a href="https://doi.org/https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-3-1-Pro-Model-Card.pdf" rel="noopener noreferrer" target="_blank">https://doi.org/https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-3-1-Pro-Model-Card.pdf</a>
  19. [23]Ignacio Gustin, Luis Mantilla Calderón, Juan B. Pérez-Sánchez, Jérôme F. Gonthier, Yuma Nakamura, Karthik Panicker, Manav Ramprasad, Zijian Zhang, Yunheng Zou, Varinia Bernales, and Alán Aspuru-Guzik. El agente cuantico: Automating quantum simulations. arXiv preprint arXiv:2512.18847, 2025. https://arxiv.org/abs/2512.18847.
  20. [24]Mohd Ariful Haque, Justin Williams, Sunzida Siddique, Md. Hujaifa Islam, Hasmot Ali, Kishor Datta Gupta, and Roy George. Advanced tool learning and selection system (atlass): A closed-loop framework using llm. arXiv preprint arXiv:2503.10071, 2025. https://arxiv.org/abs/2503.10071.
  21. [25]Johannes Hauschild and Frank Pollmann. Efficient numerical simulations with Tensor Networks: Tensor Network Python (TeNPy). SciPost Physics Lecture Notes, page 5, October 2018. doi:10.21468/SciPostPhysLectNotes.5. https://doi.org/10.21468/SciPostPhysLectNotes.5.
  22. [26]Loïc Henriet, Lucas Beguin, Adrien Signoles, Thierry Lahaye, Antoine Browaeys, Georges-Olivier Reymond, and Christophe Jurczak. Quantum computing with neutral atoms. Quantum, 4:327, 2020.DOI
  23. [27]Larsen, A. H., Mortensen, J. J., Blomqvist, J., Castelli, I. E., Christensen, R., Dulak, M., Friis, J., Groves, M. N., Hammer, B., Hargus, C., Hermes, E. D., Jennings, P. C., Bjerre Jensen, P., Kermode, J., Kitchin, J. R., Kolsbjerg, E. L., Kubal, J., Kaasbjerg, K., Lygaard, S., … Jacobsen, K. W. (2017). The atomic simulation environment—a Python library for working with atoms. Journal of Physics: Condensed Matter, 29(27), 273002. https://doi.org/10.1088/1361-648X/aa680e
  24. [28]Hong, S., Zhuge, M., Chen, J., Zheng, X., Cheng, Y., Wang, J., Zhang, C., Wang, Z., Yang, S. K. S., Jiang, Z. L., & Mehta, A. (2023). Metagpt: Meta programming for a multi-agent collaborative framework. The Twelfth International Conference on Learning Representations.
  25. [29]Mengkang Hu, Pu Zhao, Can Xu, Qingfeng Sun, Jian-Guang Lou, Qingwei Lin, Ping Luo, and Saravan Rajmohan. Agentgen: Enhancing planning abilities for large language model based agent via environment and task generation. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.1, KDD ’25, pages 496–507, New York, NY, USA, July 2025. Association for Computing Machinery. doi:10.1145/3690624.3709321. https://doi.org/10.1145/3690624.3709321.
  26. [30]Shengran Hu, Cong Lu, and Jeff Clune. Automated design of agentic systems. arXiv preprint arXiv:2408.08435, 2024. https://arxiv.org/abs/2408.08435.
  27. [31]Kevin Maik Jablonka, Philippe Schwaller, Andres Ortega-Guerrero, and Berend Smit. Leveraging large language models for predictive chemistry. Nature Machine Intelligence, 6(2):161–169, 2024.DOI
  28. [32]Ali Javadi-Abhari, Matthew Treinish, Kevin Krsulich, Christopher J. Wood, Jake Lishman, Julien Gacon, Simon Martiel, Paul D. Nation, Lev S. Bishop, Andrew W. Cross, Blake R. Johnson, and Jay M. Gambetta. Quantum computing with Qiskit. arXiv preprint arXiv:2405.08810, 2024. https://arxiv.org/abs/2405.08810.
  29. [33]Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. SWE-bench: Can language models resolve real-world GitHub issues? In The Twelfth International Conference on Learning Representations, 2024. https://openreview.net/forum?id=VTF8yNQM66.openreview.net/forum?id=VTF8yNQM66
  30. [34]J. R. Johansson, P. D. Nation, and Franco Nori. QuTiP: An open-source Python framework for the dynamics of open quantum systems. Computer Physics Communications, 183(8):1760–1772, August 2012. ISSN 0010-4655. doi:10.1016/j.cpc.2012.02.021. https://doi.org/10.1016/j.cpc.2012.02.021.
  31. [35]J. R. Johansson, P. D. Nation, and Franco Nori. QuTiP 2: A Python framework for the dynamics of open quantum systems. Computer Physics Communications, 184(4):1234–1240, April 2013. ISSN 0010-4655. doi:10.1016/j.cpc.2012.11.019. https://doi.org/10.1016/j.cpc.2012.11.019.
  32. [36]Inc., K.-D. (2026). Scientific agent skills: A comprehensive collection of scientific tools for ai agents. https://github.com/K-Dense-AI/scientific-agent-skillsgithub.com/K-Dense-AI/scientific-agent-skills
  33. [37]Navin Khaneja, Timo Reiss, Cindie Kehlet, Thomas Schulte-Herbrüggen, and Steffen J Glaser. Optimal control of coupled spin dynamics: design of nmr pulse sequences by gradient ascent algorithms. Journal of magnetic resonance, 172(2):296–305, 2005.pubmed.ncbi.nlm.nih.gov/15649756
  34. [38]Jakob S Kottmann, Sumner Alperin-Lea, Teresa Tamayo-Mendoza, Alba Cervera-Lierta, Cyrille Lavigne, Tzu-Ching Yen, Vladyslav Verteletskyi, Philipp Schleich, Abhinav Anand, Matthias Degroote, Skylar Chaney, Maha Kesibi, Naomi Grace Curnow, Brandon Solo, Georgios Tsilimigkounakis, Claudia Zendejas-Morales, Artur F Izmaylov, and Alán Aspuru-Guzik. TEQUILA: a platform for rapid development of quantum algorithms. Quantum Science and Technology, 6(2):024009, March 2021. ISSN 2058-9565. doi:10.1088/2058-9565/abe567. http://dx.doi.org/10.1088/2058-9565/abe567.
  35. [39]Georg Kresse and Jürgen Furthmüller. Efficient iterative schemes for ab initio total-energy calculations using a planewave basis set. Physical Review B, 54(16):11169–11186, October 1996. ISSN 1095-3795. doi:10.1103/physrevb.54.11169. http://dx.doi.org/10.1103/physrevb.54.11169.
  36. [40]Sai Govind Hari Kumar, Yunheng Zou, Andrew Wang, Jesús Valdés-Hernández, Tsz Wai Ko, Nathan Yue, Olivia Leng, Hanyong Xu, Chris Crebold er, Alán Aspuru-Guzik, and Varinia Bernales. El agente sólido: A new age(nt) for solid state simulations. arXiv preprint arXiv:2602.17886, 2026. https://arxiv.org/abs/2602.17886.
  37. [41]Landrum, G. et . al . (2024). RDKit: Open-source cheminformatics software. https://www.rdkit.orgrdkit.org
  38. [42]G. Lindblad. On the generators of quantum dynamical semigroups. Commun. Math. Phys., 48:119, 1976. doi:10.1007/bf01608499.DOI
  39. [43]Chris Lu, Cong Lu, Robert Tjarko Lange, Yutaro Yamada, Shengran Hu, Jakob Foerster, David Ha, and Jeff Clune. Towards end-to-end automation of AI research. Nature, 651(8107):914–919, March 2026. ISSN 1476-4687. doi:10.1038/s41586-026-10265-5. http://dx.doi.org/10.1038/s41586-026-10265-5.
  40. [44]Bran, A. M., Cox, S., Schilter, O., Baldassari, C., White, A. D., & Schwaller, P. (2024). Augmenting large language models with chemistry tools. Nature Machine Intelligence, 6(5), 525–535. https://doi.org/10.1038/s42256-024-00832-8
  41. [45]Jarrod R. McClean, Mollie E Kimchi-Schwartz, Jonathan Carter, and Wibe A De Jong. Hybrid quantum-classical hierarchy for mitigation of decoherence and determination of excited states. Physical Review A, 95(4):042308, 2017.DOI
  42. [46]Eric A. Moreno, Samuel Bright-Thonney, Andrzej Novak, Dolores Garcia, and Philip Harris. Ai agents can already autonomously perform experimental high energy physics. arXiv preprint arXiv:2603.20179, 2026. https://arxiv.org/abs/2603.20179.
  43. [47]Frank Neese, Frank Wennmohs, Ute Becker, and Christoph Riplinger. The ORCA quantum chemistry program package. The Journal of Chemical Physics, 152(22):224108, June 2020. ISSN 1089-7690. doi:10.1063/5.0004608. https://doi.org/10.1063/5.0004608.
  44. [48]NVIDIA. (2024). CUDA-Q: A platform for hybrid quantum-classical computing. https://developer.nvidia.com/cuda-qdeveloper.nvidia.com/cuda-q
  45. [50]OpenCode.ai. (2025). Opencode. https://opencode.ai/docs/opencode.ai/docs
  46. [51]OpenRouter. (2025). Openrouter: Model pricing. https://openrouter.ai/modelsopenrouter.ai/models
  47. [52]Juan B. Pérez-Sánchez, Yunheng Zou, Jorge A. Campos-Gonzalez-Angulo, Marcel Müller, Ignacio Gustin, Andrew Wang, Han Hao, Tsz Wai Ko, Changhyeok Choi, Eric S. Isbrandt, Mohammad Ghazi Vakili, Hanyong Xu, Chris Crebolder, Varinia Bernales, and Alán Aspuru-Guzik. El agente quntur: A research collaborator agent for quantum chemistry. arXiv preprint arXiv:2602.04850, 2026. https://arxiv.org/abs/2602.04850.
  48. [53]Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-Qi Zhou, Peter J Love, Alán Aspuru-Guzik, and Jeremy L O’brien. A variational eigenvalue solver on a photonic quantum processor. Nature communications, 5 (1):4213, 2014.DOI
  49. [54]Thang D. Pham, Aditya Tanikanti, and Murat Keçeli. Chemgraph: An agentic framework for computational chemistry workflows. arXiv preprint arXiv:2506.06363, 2025. https://arxiv.org/abs/2506.06363.
  50. [55]Phan, L., Gatti, A., Han, Z., Li, N., Hu, J., Zhang, H., Zhang, C. B. C., Shaaban, M., Ling, J., Shi, S., & al., . et . (2025). Humanity’s last exam. In arXiv preprint arXiv:2501.14249. 2501.14249
  51. [56]Cheng Qian, Chi Han, Yi Fung, Yujia Qin, Zhiyuan Liu, and Heng Ji. CREATOR: Tool creation for disentangling abstract and concrete reasoning of large language models. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Findings of the Association for Computational Linguistics: EMNLP 2023, pages 6922–6939, Singapore, December 2023. Association for Computational Linguistics. doi:10.18653/v1/2023.findings-emnlp.462. https://aclanthology.org/2023.findings-emnlp.462/.DOI
  52. [57]Jiahao Qiu, Xuan Qi, Tongcheng Zhang, Xinzhe Juan, Jiacheng Guo, Yifu Lu, Yimin Wang, Zixin Yao, Qihan Ren, Xun Jiang, Xing Zhou, Dongrui Liu, Ling Yang, Yue Wu, Kaixuan Huang, Shilong Liu, Hongru Wang, and Mengdi Wang. Alita: Generalist agent enabling scalable agentic reasoning with minimal predefinition and maximal self-evolution. arXiv preprint arXiv:2505.20286, 2025. https://arxiv.org/abs/2505.20286.
  53. [58]Singh, A., Fry, A., Perelman, A., Tart, A., Ganesh, A., El-Kishky, A., McLaughlin, A., Low, A., Ostrow, A., Ananthram, A., & al., . et . (2025). Openai gpt-5 system card. In arXiv preprint arXiv:2601.03267. 2601.03267
  54. [59]Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling LLM test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024. https://arxiv.org/abs/2408.03314.
  55. [60]Song, T., Luo, M., Zhang, X., Chen, L., Huang, Y., Cao, J., Zhu, Q., Liu, D., Zhang, B., Zou, G., & al., . et . (2025). A multiagent-driven robotic ai chemist enabling autonomous chemical research on demand. Journal of the American Chemical Society, 147(15), 12534–12545.
  56. [61]Sun, Q., Berkelbach, T. C., Blunt, N. S., Booth, G. H., Guo, S., Li, Z., Liu, J., McClain, J. D., Sayfuty arova, E. R., Sharma, S., Wouters, S., & Chan, G. K.-L. (2017). PySCF: the Python-based simulations of chemistry framework. Wiley Interdisciplinary Reviews: Computational Molecular Science, 8(1), e1340. https://doi.org/10.1002/wcms.1340
  57. [62]Sun, Q., Zhang, X., Banerjee, S., Bao, P., Barbry, M., Blunt, N. S., Bogdanov, N. A., Booth, G. H., Chen, J., Cui, Z.-H., Eriksen, J. J., Gao, Y., Guo, S., Herrmann, J., Hermes, M. R., Koh, K., Koval, P., Lehtola, S., Li, Z., … Chan, G. K.-L. (2020). Recent developments in the PySCF program package. The Journal of Chemical Physics, 153(2), 024109. https://doi.org/10.1063/5.0006074
  58. [63]Yoshitaka Tanimura. Numerically “exact” approach to open quantum dynamics: The hierarchical equations of motion (heom). J. Chem. Phys., 153(2):020901, 2020. doi:10.1063/5.0011599.DOI
  59. [64]Team, K., Bai, T., Bai, Y., Bao, Y., Cai, S., Cao, Y., Charles, Y., Che, H., Chen, C., Chen, G., & al., . et . (2026). Kimi k2. 5: Visual agentic intelligence. In arXiv preprint arXiv:2602.02276. 2602.02276
  60. [65]Trae Research Team, Pengfei Gao, Zhao Tian, Xiangxin Meng, Xinchen Wang, Ruida Hu, Yuanan Xiao, Yizhou Liu, Zhao Zhang, Junjie Chen, Cuiyun Gao, Yun Lin, Yingfei Xiong, Chao Peng, and Xia Liu. Trae agent: An llm-based agent for software engineering with test-time scaling. arXiv preprint arXiv:2507.23370, 2025. https://arxiv.org/abs/2507.23370.
  61. [66]Tilly, J., Chen, H., Cao, S., Picozzi, D., Setia, K., Li, Y., Grant, E., Wossnig, L., Rungger, I., Booth, G. H., & al., . et . (2022). The variational quantum eigensolver: a review of methods and best practices. Physics Reports, 986, 1–128.
  62. [67]Guifré Vidal. Efficient simulation of one-dimensional quantum many-body systems. Physical review letters, 93(4):040502, 2004.pubmed.ncbi.nlm.nih.gov/15323740
  63. [68]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16291, 2023. https://arxiv.org/abs/2305.16291.
  64. [69]Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, Wayne Xin Zhao, Zhewei Wei, and Jirong Wen. A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6):186345, March 2024. ISSN 2095-2236. doi:10.1007/s11704-024-40231-1. http://dx.doi.org/10.1007/s11704-024-40231-1.
  65. [70]Ziqi Wang, Hongshuo Huang, Hancheng Zhao, Changwen Xu, Shang Zhu, Jan Janssen, and Venkatasubramanian Viswanathan. Dreams: Density functional theory based research engine for agentic materials simulation. arXiv preprint arXiv:2507.14267, 2025. https://arxiv.org/abs/2507.14267.
  66. [72]Steven R White. Density-matrix algorithms for quantum renormalization groups. Physical review b, 48(14):10345, 1993.pubmed.ncbi.nlm.nih.gov/10007313
  67. [73]Steven R White and Adrian E Feiguin. Real-time evolution using the density matrix renormalization group. Physical review letters, 93(7):076401, 2004.pubmed.ncbi.nlm.nih.gov/15324254
  68. [74]Peng Xia, Kaide Zeng, Jiaqi Liu, Can Qin, Fang Wu, Yiyang Zhou, Caiming Xiong, and Huaxiu Yao. Agent0: Unleashing self-evolving agents from zero data via tool-integrated reasoning. arXiv preprint arXiv:2511.16043, 2025. https://arxiv.org/abs/2511.16043.
  69. [75]Andy B. Yoo, Morris A. Jette, and Mark Grondona. SLURM: Simple Linux Utility for Resource Management. In Job Scheduling Strategies for Parallel Processing, pages 44–60. Springer Berlin Heidelberg, 2003. doi:10.1007/10968987_3.DOI
  70. [76]Yoshikawa, N., Skreta, M., Darvish, K., Arellano-Rubach, S., Ji, Z., Kristensen, L. B., Li, A. Z., Zhao, Y., Xu, H., Kuramshin, A., & al., . et . (2023). Large language models for chemistry robotics. Autonomous Robots, 47(8), 1057–1086.
  71. [77]Lifan Yuan, Yangyi Chen, Xingyao Wang, Yi R. Fung, Hao Peng, and Heng Ji. CRAFT: Customizing LLMs by creating and retrieving from specialized toolsets. arXiv preprint arXiv:2309.17428, 2023. https://arxiv.org/abs/2309.17428.
  72. [78]Yunpeng Zhai, Shuchang Tao, Cheng Chen, Anni Zou, Ziqian Chen, Qingxu Fu, Shinji Mai, Li Yu, Jiajia Deng, Zouying Cao, Zhaoyang Liu, Bolin Ding, and Jingren Zhou. Agentevolver: Towards efficient self-evolving agent system. arXiv preprint arXiv:2511.10395, 2025. https://arxiv.org/abs/2511.10395.
  73. [79]Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin godel machine: Open-ended evolution of self-improving agents. arXiv preprint arXiv:2505.22954, 2025. https://arxiv.org/abs/2505.22954.

Paper details

vlnc:W_eeukm2yp
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents