Pith. sign in

REVIEW 3 major objections 47 references

For AI to write working radiation-transport simulations from plain English, structured domain knowledge beats extra reasoning; residual errors are wrong physics tallies, not bad syntax.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-14 15:41 UTC pith:UDQQVVYT

load-bearing objection Solid empirical systems paper: structured PHITS knowledge, not model scale, is what moves full input generation from 0% to ~57%, with agents adding a smaller, costlier bump. the 3 major comments →

arxiv 2607.09789 v1 pith:UDQQVVYT submitted 2026-07-08 cs.AI cond-mat.mtrl-sci

PHITSBench: an execution-scored benchmark for AI-assisted PHITS radiation-transport input generation using natural language

Xianglin Ji , Svetlana V. Boriskina This is my paper
classification cs.AI cond-mat.mtrl-sci
keywords PHITSMonte Carlo radiation transportlarge language modelsbenchmarkinput file generationagentic systemsknowledge catalogexecution-scored evaluation
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

PHITS is a widely used Monte Carlo radiation-transport code whose input language is specialized, parser-sensitive, and poorly represented in public training data. This paper introduces PHITSBench: 282 tasks that score AI-generated inputs by actually running PHITS and comparing transport observables to reference solutions, not by text similarity. On editing and repair of existing decks, a frontier model already does well. On full generation from a natural-language physics description alone, the same model scores zero successes until a compact, machine-readable knowledge catalog is added, which lifts single-shot success to 57 percent; agentic run-and-repair loops add a further gain to roughly two-thirds to three-quarters of tasks. The leftover failures are mostly valid-looking inputs that score the wrong physical quantity. The authors conclude that progress on this class of scientific simulation hinges as much on machine-readable knowledge, curated expert examples, and execution-based evaluation as on larger foundation models.

Core claim

On the hardest track—building a complete PHITS simulation from a natural-language description—structured domain knowledge is the dominant driver of success: zero-shot performance is 0/86 at the paper’s CMS ≥ 0.95 threshold, the user manual alone reaches 28/86 (33%), and adding a structured PHITS knowledge catalog reaches 49/86 (57%). Agentic execution and repair raise the rate further to 66–73%, at higher cost. Remaining failures after successful execution are dominated by incorrect selection or configuration of tallies and observables, not syntax errors.

What carries the argument

PHITSBench and its Composite Metric Score (CMS): tasks are solved only when PHITS executes cleanly and the generated transport observables match reference tallies under a priori-weighted measures of shape, integral, and peak; CMS ≥ 0.95 is the success threshold used throughout.

Load-bearing premise

The hand-built, expert-audited knowledge catalog and the fixed CMS threshold with its track-specific weights are treated as a fair general measure of correct simulation generation, even though catalog quality was not systematically ablated and results come from a single model family with single non-deterministic runs.

What would settle it

Rebuild or ablate the knowledge catalog (or reweight CMS) and re-run the same Reproduce tasks: if success no longer jumps from near zero to ~57% with catalog injection, or if residual failures stop being dominated by tally/observable misconfiguration, the central hierarchy of causes collapses.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Near-term AI help for PHITS will be most reliable on edit and repair of existing decks rather than unaided full generation.
  • A maintained, machine-readable PHITS knowledge base (keywords, defaults, parser constraints, common errors) is a high-leverage community asset.
  • Curated expert examples of tally and observable choices are needed beyond parser documentation, because residual failures are domain-judgment errors.
  • Execution-scored environments with a computable reward (CMS) can support reinforcement learning for radiation-transport input generation.
  • The same pattern—structured knowledge first, agents second—likely applies to other under-documented scientific codes with specialized input languages.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Similar under-documented legacy simulation codes (other MC transport packages, older multiphysics decks) will show the same zero-shot failure and large gains from compact machine-readable catalogs.
  • If residual failures stay concentrated in tally configuration, preference or supervised fine-tuning on expert-chosen observables may outperform further agent scaffolding alone.
  • Packaging PHITSBench as a Gym-style environment with CMS as reward would make the ‘knowledge vs reasoning vs repair’ hierarchy directly trainable and re-testable by others.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 0 minor

Summary. The manuscript introduces PHITSBench, an execution-scored suite of 282 PHITS tasks in three tracks (Edit n=65, Repair n=131, Reproduce n=86) derived from the PHITS 3.34 example library. Success is defined by a Composite Metric Score (CMS) that combines binary execution success with physics-fidelity agreement between generated and reference tally outputs (Eq. 1; Tables 1–2). Five GPT-5.4 configurations are compared: zero-shot Baseline, +PDF manual, +Cat+PDF (structured knowledge catalog plus manual), Codex CLI, and a custom three-role multi-agent system. On Reproduce, success (CMS≥0.95) rises from 0/86 (Baseline) to 28/86 (+PDF) to 49/86 (+Cat+PDF), with agentic methods reaching 57–63/86 at higher cost; residual failures are mostly wrong tally/observable configuration rather than syntax. An independent four-problem physics check outside the benchmark is also reported.

Significance. If the reported hierarchy holds, the paper supplies a concrete, execution-grounded benchmark for a legacy scientific input language that is underrepresented in public training data, and it provides evidence that machine-readable domain knowledge and execution feedback can matter as much as raw model scale for radiation-transport input generation. Strengths include a priori CMS weights with a stated sensitivity check, a clear failure taxonomy (19/29 residual agent failures are wrong tallies), cost reporting, a reasoning-effort control (medium→xhigh only +3 tasks), and an independent physics validation against NIST/reference data. These are useful contributions for AI-for-science and nuclear-engineering tooling communities.

major comments (3)
  1. Central claim (Abstract; §3.2; Fig. 4; Conclusions): the dominant 0%→57% Reproduce gain is attributed to the structured catalog. Sections 2.1 and 2.3 indicate that both the 86 Reproduce tasks and the catalog were derived from the same PHITS 3.34 ecosystem (example library + source/parser + manual) with expert audit. The manuscript does not demonstrate catalog–task hold-out, nor an ablation that removes catalog rules that encode the same defaults/units/tally conventions used by the hand-written references. Without that separation, the knowledge-injection hierarchy risks partly measuring catalog–benchmark alignment. Please either (i) document construction chronology and hold-out, (ii) report a leave-out / reduced-catalog ablation on Reproduce, or (iii) substantially qualify the claim that structured knowledge is the dominant generalizable driver.
  2. §2.4 and Table 3 / Fig. 4: all primary rankings rest on single non-deterministic GPT-5.4 runs per configuration, with no multi-seed variance, confidence intervals, or bootstrap over tasks. For a 9–16 pp agentic increment and a 21-task catalog increment that underwrite the paper’s hierarchy, single-run point estimates are too thin. At minimum, report repeated runs (or task-level bootstrap) for the Reproduce track on Baseline, +Cat+PDF, and one agentic method, or mark the ranking as exploratory and soften quantitative claims.
  3. §2.2 (CMS definition) and §3.5: CMS≥0.95 is defined against PHITSBench reference tallies, so high CMS can reward matching the reference’s observable choices rather than independent physical correctness. The four-problem external validation is valuable but small, agent-only, and one case (lead attenuation) already shows a tally-selection discrepancy that CMS-style reference matching would not necessarily penalize. Please expand independent validation (more problems and/or single-shot +Cat+PDF as well as agents) or more carefully bound what CMS success implies for physical correctness outside the benchmark.

Circularity Check

0 steps flagged

No derivation circularity: PHITSBench is an empirical systems ablation, not a first-principles claim that folds its target into fitted inputs.

full rationale

This paper reports measured success rates of GPT-5.4 configurations on an execution-scored PHITS input-generation benchmark. There is no claimed mathematical derivation, uniqueness theorem, or fitted-parameter-as-prediction chain to walk. CMS is defined a priori as a weighted combination of binary execution success and reference-tally agreement (Eq. 1; Table 2 weights chosen by tally information content, not tuned on results); success is CMS≥0.95, with a stated sensitivity check that ±0.10 weight shifts do not change method ranking. The central hierarchy (Baseline 0% → +PDF 33% → +Cat+PDF 57% → agentic 66–73% on Reproduce) is an empirical ablation under fixed tasks and a fixed model, not a reduction of the target to the intervention by construction. Catalog construction from PHITS source/parser rules plus expert audit, and tasks drawn from the official example library, raise ordinary benchmark-validity questions about generalization and catalog quality (which the paper itself flags in §4.3), but that is not circularity in the sense of X defined as Y, a fit renamed as a prediction, or a load-bearing self-cited uniqueness result. Independent four-problem physics checks against NIST/nuclear data further treat the outputs as externally falsifiable simulations. Score 0; no circular steps.

Axiom & Free-Parameter Ledger

4 free parameters · 4 axioms · 2 invented entities

The central claim is empirical and rests on evaluation design choices (CMS weights/threshold, task filtering to transport-scorable examples, a custom catalog) and standard assumptions about PHITS execution and LLM APIs—not on new physical entities. Free parameters are scoring and agent-budget knobs chosen by the authors; axioms are domain and evaluation assumptions; no new particles or forces are postulated.

free parameters (4)
  • CMS success threshold = 0.95
    Tasks count as solved only if CMS≥0.95; this binary cutoff shapes all headline success rates.
  • Track-specific EX/PF weights = Reproduce (0.5,0.5); Edit (0.2,0.8); Repair (0.3,0.7)
    Reproduce uses (0.5,0.5); Edit (0.2,0.8); Repair (0.3,0.7). Chosen a priori; ranking claimed robust to ±0.10 but absolute success counts depend on them.
  • Physics-fidelity component weights by tally resolution = Table 2 scheme
    L2/integral/peak weights (e.g., 60/25/15 for n>20 bins) are hand-set from information-content judgment (Table 2).
  • Custom multi-agent repair budget = 5 iterations
    Maximum of five repair iterations and tiered reasoning (medium vs xhigh) affect cost/performance tradeoff vs unrestricted Codex CLI.
axioms (4)
  • domain assumption Agreement of generated PHITS tally outputs with hand-modified or official-example reference simulations (via CMS) is a valid proxy for physically correct input generation.
    Load-bearing evaluation premise in §2.2; partially stress-tested by independent NIST-style checks in §3.5.
  • domain assumption Restricting the benchmark to transport mode (icntl=0) with scorable tallies fairly represents common PHITS user workflows.
    Stated in §2.1 when excluding vacuum/plot/source-check modes.
  • ad hoc to paper A single non-deterministic GPT-5.4 run per configuration is sufficient to rank methods for the paper’s qualitative conclusions.
    Explicitly noted in §2.4; no multi-seed confidence intervals on success rates.
  • domain assumption PHITS 3.34 parser behavior and the expert-audited catalog correctly encode the constraints needed for valid inputs.
    Catalog construction from source/parser analysis plus manual audit (§2.3); quality dependence listed as a limitation (§4.3).
invented entities (2)
  • Composite Metric Score (CMS) no independent evidence
    purpose: Combine binary execution success with multi-component physics-fidelity agreement into a single task score and success threshold.
    Methodological construct defined in Eq. (1) and Tables 1–2; not an external physical entity. Independent handle is only via PHITS runs against references.
  • Structured PHITS knowledge catalog no independent evidence
    purpose: Provide machine-readable keywords, defaults, parser constraints, and dependencies beyond the human PDF manual.
    Custom artifact (~7,300 lines) built for this study; performance gains are relative to this catalog’s content and organization.

pith-pipeline@v1.1.0-grok45 · 22098 in / 3442 out tokens · 40638 ms · 2026-07-14T15:41:54.671617+00:00 · methodology

0 comments
read the original abstract

We introduce PHITSBench, an execution-scored benchmark for the Monte Carlo Particle and Heavy Ion Transport code System (PHITS). PHITSBench comprises 282 transport-scorable tasks spanning three common workflow categories: parameter editing (Edit), syntax repair (Repair ), and complete simulation generation from natural-language descriptions (Reproduce). Each task is evaluated using a Composite Metric Score that combines execution success with agreement between generated and reference transport observables. Using PHITSBench, we evaluate five GPT-5.4-based configurations ranging from zero-shot prompting to knowledge-augmented and agentic workflows. Without domain-specific knowledge, the model performs well on editing and repair tasks (95% and 70% success, respectively) but fails to generate correct simulations from scratch (0% success on the Reproduce track). A structured, machine-readable PHITS knowledge catalog, supplied alongside the user manual, raises single-shot Reproduce-task success to 57%. Agentic execution provides a further improvement to 66-73%, but at increased computational cost. Failure analysis shows that the remaining errors are dominated by incorrect selection and configuration of physical observables rather than syntax generation. These results suggest that future progress in AI-assisted radiation-transport modeling will depend as much on machine-readable knowledge bases, curated domain-training datasets, and execution-grounded evaluation environments as on advances in foundation models themselves.

Figures

Figures reproduced from arXiv: 2607.09789 by Svetlana V. Boriskina, Xianglin Ji.

Figure 1
Figure 1. Figure 1: PHITS at a glance. (a) A PHITS input file consists of a sequence of named keyword sections defining simulation parameters, particle sources, materials, geometry, and tally requests. (b) During execution, particles are emitted from the specified source, transported through the geometry, and scored according to user-defined [T-*] tally definitions. In the example shown, a neutron source emits neutrons that p… view at source ↗
Figure 2
Figure 2. Figure 2: Representative examples of tasks in each benchmark track. Edit (left): the model receives a valid PHITS input file together with a natural-language modification request and must generate an updated input whose transport results match the modified reference simulation. Repair (center): the model receives a deliberately corrupted PHITS input file and the corresponding PHITS error message and must generate a … view at source ↗
Figure 3
Figure 3. Figure 3: Single-shot success rate(CMS ≥ 0.95) across all three benchmark tracks for the non-agentic methods. The Edit track is effectively saturated even in the zero-shot baseline, and the Repair track benefits substantially from progressive knowledge injection (+18%). In contrast, the same progression improves Reproduce performance only to 49 of 86 tasks (57%), highlighting the remaining gap that motivates the use… view at source ↗
Figure 4
Figure 4. Figure 4: Success rate (CMS ≥ 0.95) on the 86 Reproduce-track tasks across the five evaluated methods (green bars, left axis). Structured knowledge injection (+Cat+PDF relative to the Baseline) accounts for the largest overall performance improvement, while Agentic execution provides a further increase in success rate. The red line (right axis) shows the estimated per-task inference cost at GPT-5.4 list pricing (sin… view at source ↗
Figure 5
Figure 5. Figure 5: Dominant root causes of the 29 Reproduce-track failures of the Custom Multi-Agent system (CMS < 0.95). Most failures (25 of 29) occur after successful PHITS execution (EX = 1) and therefore reflect incorrect selection or configuration of physical observables rather than syntax generation errors. Only four failures arise from execution errors (EX = 0). Incorrect tally configuration is the dominant residual … view at source ↗
Figure 6
Figure 6. Figure 6: Independent validation of AI-generated PHITS simulations using four canonical radiation-transport benchmarks not included in PHITSBench. The left panel shows the natural language prompts. The center panels show the simulated particle tracks and geometry, while the right panels compare the resulting observables with reference values. Green (a,c,d) indicates agreement within Monte Carlo statistical uncertain… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

47 extracted references · 9 linked inside Pith

  1. [1]

    Recent improvements of the particle and heavy ion transport code system—PHITS version 3.33

    Sato T, Iwamoto Y, Hashimoto S, et al. Recent improvements of the particle and heavy ion transport code system—PHITS version 3.33. Journal of Nuclear Science and Technology. 2024;61(1):127–135. Describes PHITS version 3.33; the present work uses version 3.34

    2024

  2. [2]

    MCNP version 6.2 release notes

    Werner CJ, Bull JS, Solomon CJ, et al. MCNP version 6.2 release notes. Los Alamos National Laboratory; 2018. LA-UR-18-20808. Available from:https://www.osti.gov/ biblio/1419730

    arXiv 2018

  3. [3]

    GEANT4—a simulation toolkit

    Agostinelli S, Allison J, Amako K, et al. GEANT4—a simulation toolkit. Nuclear Instru- ments and Methods in Physics Research A. 2003;506(3):250–303

    2003

  4. [4]

    FLUKA: A multi-particle transport code (program version 2005)

    Ferrari A, Sala PR, Fassò A, et al. FLUKA: A multi-particle transport code (program version 2005). CERN; 2005. CERN-2005-010, INFN/TC-05/11, SLAC-R-773. Available from:https://cds.cern.ch/record/898301

    2005

  5. [5]

    Evaluating large language models trained on code [Arxiv:2107.03374 [cs.lg]]; 2021

    Chen M, Tworek J, Jun H, et al. Evaluating large language models trained on code [Arxiv:2107.03374 [cs.lg]]; 2021. Available from:https://arxiv.org/abs/2107.03374

    Pith/arXiv arXiv 2021

  6. [6]

    SWE-bench: Can language models resolve real-world GitHub issues? In: The Twelfth International Conference on Learning Representations (ICLR); 2024

    Jimenez CE, Yang J, Wettig A, et al. SWE-bench: Can language models resolve real-world GitHub issues? In: The Twelfth International Conference on Learning Representations (ICLR); 2024. Available from:https://openreview.net/forum?id=VTF8yNQM66

    2024

  7. [7]

    DS-1000: A natural and reliable benchmark for data science code generation

    Lai Y, Li C, Wang Y, et al. DS-1000: A natural and reliable benchmark for data science code generation. In: Proceedings of the 40th International Conference on Machine Learning (ICML); 2023. Available from:https://proceedings.mlr.press/v202/lai23b.html

    2023

  8. [8]

    Invited paper: VerilogEval: Evaluating large language models for Verilog code generation

    Liu M, Pinckney N, Khailany B, et al. Invited paper: VerilogEval: Evaluating large language models for Verilog code generation. In: 2023 IEEE/ACM International Conference on Computer-Aided Design (ICCAD); 2023

    2023

  9. [9]

    BigCodeBench: Benchmarking code generation with diversefunctioncallsandcomplexinstructions.In:TheThirteenthInternationalConference on Learning Representations (ICLR); 2025

    Zhuo TY, Vu MC, Chim J, et al. BigCodeBench: Benchmarking code generation with diversefunctioncallsandcomplexinstructions.In:TheThirteenthInternationalConference on Learning Representations (ICLR); 2025. Available from:https://openreview.net/ forum?id=YrycTjllL0

    2025

  10. [10]

    SciCode: A research coding benchmark curated by scientists

    Tian M, Gao L, Zhang SD, et al. SciCode: A research coding benchmark curated by scientists. In: Advances in Neural Information Processing Systems (NeurIPS) 37, Datasets and Benchmarks Track; 2024. Available from:https://openreview.net/forum? id=ADLaALtdoG

    2024

  11. [11]

    Automating Monte Carlo simulations in nuclear engineering with domain knowledge-embedded large language model agents

    Ndum Ndum Z, Tao J, Ford J, et al. Automating Monte Carlo simulations in nuclear engineering with domain knowledge-embedded large language model agents. Energy and AI. 2025;21:100555. Agent framework referred to as AutoFLUKA

    2025

  12. [12]

    A self-correcting multi-agent LLM framework for language-based physics simulation and explanation

    Park D, Moon H, Ryu S. A self-correcting multi-agent LLM framework for language-based physics simulation and explanation. npj Artificial Intelligence. 2026;2(1):10

    2026

  13. [13]

    Evaluating the performance of large language 19 models for geometry and simulation file generation in physics-based simulations

    Shafiq O, Rahmat A, Alexiadis A, et al. Evaluating the performance of large language 19 models for geometry and simulation file generation in physics-based simulations. Applied Sciences. 2025;15(22):12114

    2025

  14. [14]

    OpenFOAMGPT: A retrieval-augmented large language model (LLM) agent for OpenFOAM-based computational fluid dynamics

    Pandey S, Xu R, Wang W, et al. OpenFOAMGPT: A retrieval-augmented large language model (LLM) agent for OpenFOAM-based computational fluid dynamics. Physics of Fluids. 2025;37(3):035120

    2025

  15. [15]

    MetaOpenFOAM: An LLM-based multi-agent framework for CFD [Arxiv:2407.21320 [physics.flu-dyn]]; 2024

    Chen Y, Zhu X, Zhou H, et al. MetaOpenFOAM: An LLM-based multi-agent framework for CFD [Arxiv:2407.21320 [physics.flu-dyn]]; 2024. Available from:https://arxiv.org/ abs/2407.21320

    Pith/arXiv arXiv 2024

  16. [16]

    CFDLLMBench: A benchmark suite for evaluating large language models in computational fluid dynamics [Arxiv:2509.20374 [cs.lg]]; 2025

    Somasekharan N, Yue L, Cao Y, et al. CFDLLMBench: A benchmark suite for evaluating large language models in computational fluid dynamics [Arxiv:2509.20374 [cs.lg]]; 2025. Available from:https://arxiv.org/abs/2509.20374

    Pith/arXiv arXiv 2025

  17. [17]

    MooseAgent: A LLM based multi-agent framework for automating MOOSE simulation ; 2025

    Zhang T, Liu Z, Xin Y, et al. MooseAgent: A LLM based multi-agent framework for automating MOOSE simulation ; 2025. Available from:https://arxiv.org/abs/2504. 08621

    2025

  18. [18]

    AutoSAM: an agentic framework for automating input file generation for the SAM code with multi-modal retrieval-augmented generation

    Abulawi Z, Ndum Ndum Z, Cervi E, et al. AutoSAM: an agentic framework for automating input file generation for the SAM code with multi-modal retrieval-augmented generation

  19. [19]

    Available from:https://arxiv.org/abs/2603.24736

    arXiv

  20. [20]

    SIMCODE: A benchmark for natural language to ns-3 network simulation code generation ; 2025

    Ahmed T, Azwad MM, Choudhury S. SIMCODE: A benchmark for natural language to ns-3 network simulation code generation ; 2025. Available from:https://arxiv.org/ abs/2507.11014

    Pith/arXiv arXiv 2025

  21. [21]

    Evaluating LLM-generated code for domain- specific languages: Molecular dynamics with LAMMPS ; 2026

    Holbrook EW, Verduzco JC, Strachan A. Evaluating LLM-generated code for domain- specific languages: Molecular dynamics with LAMMPS ; 2026. Available from:https: //arxiv.org/abs/2603.20630

    Pith/arXiv arXiv 2026

  22. [22]

    GRACE: an agentic AI for particle physics experiment design and simulation ; 2026

    Hill J, Ryoo HJ. GRACE: an agentic AI for particle physics experiment design and simulation ; 2026. Available from:https://arxiv.org/abs/2602.15039

    arXiv 2026

  23. [23]

    Exploring the capabilities of the frontier large language models for nuclear energy research ; 2025

    Almeldein A, Alnaggar M, Archibald R, et al. Exploring the capabilities of the frontier large language models for nuclear energy research ; 2025. Available from:https://arxiv. org/abs/2506.19863

    Pith/arXiv arXiv 2025

  24. [24]

    DocPrompting: Generating code by retrieving the docs

    Zhou S, Alon U, Xu FF, et al. DocPrompting: Generating code by retrieving the docs. In: The Eleventh International Conference on Learning Representations (ICLR); 2023. Available from:https://arxiv.org/abs/2207.05987

    Pith/arXiv arXiv 2023

  25. [25]

    DocCGen: Document-based controlled code generation

    Pimparkhede S, Kammakomati M, Tamilselvam S, et al. DocCGen: Document-based controlled code generation. In: Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP 2024); 2024. p. 18681–18697. Available from: https://arxiv.org/abs/2406.11925

    Pith/arXiv arXiv 2024

  26. [26]

    MetaGPT: Meta programming for a multi-agent collabo- rative framework

    Hong S, Zhuge M, Chen J, et al. MetaGPT: Meta programming for a multi-agent collabo- rative framework. In: The Twelfth International Conference on Learning Representations (ICLR); 2024. Available from:https://openreview.net/forum?id=VtmBAGCN7o

    2024

  27. [27]

    AutoGen: Enabling next-gen LLM applications via multi-agent conversation

    Wu Q, Bansal G, Zhang J, et al. AutoGen: Enabling next-gen LLM applications via multi-agent conversation. In: Conference on Language Modeling (COLM); 2024. Available from:https://openreview.net/forum?id=BAakY1hNKS

    2024

  28. [28]

    SciAgents: Automating scientific discovery through bioinspired multi-agent intelligent graph reasoning

    Ghafarollahi A, Buehler MJ. SciAgents: Automating scientific discovery through bioinspired multi-agent intelligent graph reasoning. Advanced Materials. 2025;37(22):2413523

    2025

  29. [29]

    SWE-agent: Agent-computer interfaces enable automated software engineering

    Yang J, Jimenez CE, Wettig A, et al. SWE-agent: Agent-computer interfaces enable automated software engineering. In: Advances in Neural Information Processing Sys- tems (NeurIPS); Vol. 37; 2024. Available from:https://openreview.net/forum?id= mXpq6ut8J3

    2024

  30. [30]

    ReAct: Synergizing reasoning and acting in language models

    Yao S, Zhao J, Yu D, et al. ReAct: Synergizing reasoning and acting in language models. In: The Eleventh International Conference on Learning Representations (ICLR); 2023. Available from:https://openreview.net/forum?id=WE_vluYUL-X

    2023

  31. [31]

    Self-refine: Iterative refinement with self-feedback

    Madaan A, Tandon N, Gupta P, et al. Self-refine: Iterative refinement with self-feedback. In: Advances in Neural Information Processing Systems (NeurIPS); Vol. 36; 2023. Available from:https://openreview.net/forum?id=S37hOerQLB

    2023

  32. [32]

    Reflexion: Language agents with verbal reinforcement 20 learning

    Shinn N, Cassano F, Berman E, et al. Reflexion: Language agents with verbal reinforcement 20 learning. In: Advances in Neural Information Processing Systems (NeurIPS); Vol. 36; 2023. Available from:https://openreview.net/forum?id=vAElhFcKW6

    2023

  33. [33]

    Large language models cannot self-correct reasoning yet

    Huang J, Chen X, Mishra S, et al. Large language models cannot self-correct reasoning yet. In: The Twelfth International Conference on Learning Representations (ICLR); 2024. Available from:https://openreview.net/forum?id=IkmD3fKBPQ

    2024

  34. [34]

    Is self-repair a silver bullet for code generation? In: The Twelfth International Conference on Learning Representations (ICLR); 2024

    Olausson TX, Inala JP, Wang C, et al. Is self-repair a silver bullet for code generation? In: The Twelfth International Conference on Learning Representations (ICLR); 2024. Available from:https://openreview.net/forum?id=y0GJXRungR

    2024

  35. [35]

    When can LLMs actually correct their own mistakes? A critical survey of self-correction of LLMs

    Kamoi R, Zhang Y, Zhang N, et al. When can LLMs actually correct their own mistakes? A critical survey of self-correction of LLMs. Transactions of the Association for Computational Linguistics. 2024;12:1417–1440

    2024

  36. [36]

    LiveCodeBench: Holistic and contamination free evaluation of large language models for code

    Jain N, Han K, Gu A, et al. LiveCodeBench: Holistic and contamination free evaluation of large language models for code. In: The Thirteenth International Conference on Learn- ing Representations (ICLR); 2025. Available from:https://openreview.net/forum?id= chfJJYC3iL

    2025

  37. [37]

    CodeBLEU: a method for automatic evaluation of code synthesis [Arxiv:2009.10297 [cs.se]]; 2020

    Ren S, Guo D, Lu S, et al. CodeBLEU: a method for automatic evaluation of code synthesis [Arxiv:2009.10297 [cs.se]]; 2020. Available from:https://arxiv.org/abs/2009.10297

    Pith/arXiv arXiv 2009

  38. [38]

    Codex CLI: Command-line coding agent [https://github.com/openai/codex]; 2025

    OpenAI. Codex CLI: Command-line coding agent [https://github.com/openai/codex]; 2025

    2025

  39. [39]

    OpenAI Agents SDK [https://github.com/openai/openai-agents-python]

    OpenAI. OpenAI Agents SDK [https://github.com/openai/openai-agents-python]

  40. [40]

    Berger MJ, Coursey JS, Zucker MA, et al. ESTAR, PSTAR, and ASTAR: Computer programs for calculating stopping-power and range tables for electrons, protons, and helium ions [National institute of standards and technology, gaithersburg, md]; 2017. Version 2.0.1, NIST Standard Reference Database 124; Available from:https://physics.nist. gov/Star

    2017

  41. [41]

    XCOM: Photon cross section database (version 1.5) [National institute of standards and technology, gaithersburg, md]; 2010

    Berger MJ, Hubbell JH, Seltzer SM, et al. XCOM: Photon cross section database (version 1.5) [National institute of standards and technology, gaithersburg, md]; 2010. NIST Standard Reference Database 8 (XGAM); Available from:https://physics.nist.gov/ xcom

    2010

  42. [42]

    Nuclear data sheets for A = 137

    Browne E, Tuli JK. Nuclear data sheets for A = 137. Nuclear Data Sheets. 2007; 108(10):2173–2318

    2007

  43. [43]

    Benchmark study of particle and heavy-ion trans- port code system using shielding integral benchmark archive and database for accelerator- shielding experiments

    Çelik Y, Iwamoto Y, Hashimoto S, et al. Benchmark study of particle and heavy-ion trans- port code system using shielding integral benchmark archive and database for accelerator- shielding experiments. Journal of Nuclear Science and Technology. 2022;59(5):665–675

    2022

  44. [44]

    Validation of the physical and RBE-weighted dose estimator based on PHITS coupled with a microdosimetric kinetic model for proton therapy

    Takada K, Sato T, Kumada H, et al. Validation of the physical and RBE-weighted dose estimator based on PHITS coupled with a microdosimetric kinetic model for proton therapy. Journal of Radiation Research. 2018;59(1):91–99

    2018

  45. [45]

    Improvements in the particle and heavy-ion transport code system (PHITS) for simulating neutron-response functions and detection efficiencies of a liquid organic scintillator

    Satoh D, Sato T. Improvements in the particle and heavy-ion transport code system (PHITS) for simulating neutron-response functions and detection efficiencies of a liquid organic scintillator. Journal of Nuclear Science and Technology. 2022;59(8):1047–1060

    2022

  46. [46]

    A PHITS-based computational model of a TRIGA-fueled subcritical reactor for gamma dose mapping

    Cruz JRP, Astronomo AA, Santos GN, et al. A PHITS-based computational model of a TRIGA-fueled subcritical reactor for gamma dose mapping. Nuclear Engineering and Technology. 2024;56(12):5339–5345

    2024

  47. [47]

    Dose estimation for astronauts using dose conversion coeffi- cients calculated with the PHITS code and the ICRP/ICRU adult reference computational phantoms

    Sato T, Endo A, Sihver L, et al. Dose estimation for astronauts using dose conversion coeffi- cients calculated with the PHITS code and the ICRP/ICRU adult reference computational phantoms. Radiation and Environmental Biophysics. 2011;50(1):115–123. 21

    2011