arxiv: 2605.00651 · v1 · submitted 2026-05-01 · ⚛️ physics.ins-det

Recognition: unknown

EQSANS-CLI: A natural-language, agent-ready command-line tool for small-angle neutron scattering data reduction at EQ-SANS

Changwoo Do

Authors on Pith no claims yet

Pith reviewed 2026-05-09 14:38 UTC · model grok-4.3

classification ⚛️ physics.ins-det

keywords SANS data reductioncommand-line interfaceneutron scatteringagent interfacedata processing workflowheadless modeworking tableEQ-SANS

0 comments

The pith

A command-line tool unifies SANS reduction steps so agents can execute full pipelines from natural language.

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

The paper establishes that a shared command-handler layer and persistent working table can organize the repetitive SANS workflow of run classification, reference matching, reduction, absolute scaling, and stitching into one coherent system. All input paths, including interactive terminal and headless JSON, converge on the same handler, while parameter changes automatically trigger re-reductions. This architecture supports an autopilot command that chains the entire process from an IPTS number to stitched I(Q) curves. A Slack bot demonstration shows that loading one skill document into an external agent's prompt is enough for the agent to drive complete reductions through natural language from a mobile device. The design keeps the CLI as the authoritative executor rather than embedding workflow logic in the agent.

Core claim

EQSANS-CLI uses a command-handler layer that receives all inputs, a working table that stores every reduction decision as editable rows, dual input surfaces that compile to the same entry point, and a status-driven re-reduction model. These elements allow an /autopilot command to perform the full sequence from IPTS number through classification, matching, reduction, scaling, and stitching to absolute I(Q) curves. The headless JSON mode, paired with a single skill document, enables an external agent to translate natural-language intent into commands that complete reductions without further human intervention on the tool side.

What carries the argument

A shared command-handler layer that all inputs converge on, combined with a persistent working table that records reduction decisions as editable rows and triggers re-reductions on status changes.

If this is right

An /autopilot command executes the entire pipeline from IPTS number to stitched I(Q) curves in one step.
Changes to any reduction parameter automatically trigger re-reduction through the status-driven model.
The headless interface allows external agents to control reductions by mapping natural language to the stable command contract.
Complete data reductions become possible from a mobile device once the agent receives a single skill document.

Where Pith is reading between the lines

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

The same handler-and-table pattern could apply to other neutron instruments whose reduction steps follow similar repetitive sequences.
Keeping all decisions visible and editable in the working table reduces the risk of hidden assumptions when agents generate commands.
Mobile natural-language access could shorten the time between data collection and initial analysis during beam time.

Load-bearing premise

The SANS reduction workflow at EQ-SANS is repetitive and standardized enough that a command-handler plus working-table architecture can capture all necessary decisions without frequent custom overrides or loss of scientific flexibility.

What would settle it

A full reduction run performed solely through natural-language commands to the Slack bot on a dataset with multiple instrument configurations and non-default parameter choices, where the process completes without manual corrections or overrides, would support the claim; failure on such a case would challenge it.

Figures

Figures reproduced from arXiv: 2605.00651 by Changwoo Do.

**Figure 1.** Figure 1: Architecture of EQSANS-CLI. Two client types reach the tool through two binaries: a view at source ↗

**Figure 2.** Figure 2: Interactive terminal interface of EQSANS-CLI. The interface displays the current session view at source ↗

**Figure 3.** Figure 3: summarizes the /autopilot pipeline. The command chains the four reduction phases— Loading (load IPTS, match runs, apply user-specified customizations), Configurations (apply presets, LLM-assisted configuration suggestion where necessary), Reduce (reduce standards, calibrate absolute scale, re-reduce with calibrated scale, reduce samples), and Stitch/Share (build stitch table, apply smart overlaps, stitch,… view at source ↗

**Figure 4.** Figure 4: Setting up the Slack-resident agent for EQSANS-CLI. The user instructs the OpenClaw view at source ↗

**Figure 5.** Figure 5: Loading catalogue information from the desired IPTS. view at source ↗

**Figure 6.** Figure 6: Asking AI agent to reduce data with specific workflow instructions. view at source ↗

read the original abstract

Small-angle neutron scattering (SANS) data reduction at user facilities follows a largely repetitive workflow. Runs are first classified in the catalog and matched to transmission, background, and empty-beam references within the same instrument configuration. The data are then reduced, placed on an absolute scale using a standard, and stitched across configurations. Although these steps are individually well understood, they remain weakly connected, producing a coordination burden that scales with the number of runs and configurations. This paper describes EQSANS-CLI, a command-line tool that organizes this workflow into a coherent, scriptable, and agent-addressable system. The design rests on four principles: a shared command-handler layer that all input paths converge on; a persistent \emph{working table} that holds every reduction decision as editable rows; two input surfaces (an interactive terminal and a headless JSON mode) that compile to the same handler entry point; and a status-driven re-reduction model that treats parameter changes as first-class events. An \texttt{/autopilot} command chains the full pipeline from the IPTS number to stitched $I(Q)$ curves in one invocation. A Slack bot demonstrates that the headless interface, together with a single skill document loaded into an external agent's system prompt, is sufficient to drive complete reductions by natural language from a mobile device. The architecture is intentionally minimal on the agent side: the CLI is the authoritative executor, and the agent's only job is to translate human intent into commands on a stable contract.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

EQSANS-CLI wraps the standard EQ-SANS reduction steps into a shared handler with a persistent working table and minimal agent contract, but the paper offers no evidence that this covers real workflows without overrides.

read the letter

The paper describes a command-line tool that organizes the repetitive SANS reduction workflow at EQ-SANS into one system. Runs get classified, matched to references, scaled, and stitched, all driven through a shared command handler and a persistent working table that stores every decision as editable rows. Status changes trigger re-reductions automatically. An autopilot command chains the full pipeline from IPTS number to stitched I(Q), and a Slack bot shows the headless JSON mode working with natural language from an external agent using just one skill document. The design keeps the agent side minimal so the CLI stays authoritative. That architecture is the main contribution and it directly targets the coordination burden the abstract identifies. The shared handler and status-driven model are sensible ways to keep interactive and scripted paths consistent while allowing parameter edits without full restarts. The minimal agent contract is a practical choice that avoids loading the LLM with instrument specifics. These pieces fit together cleanly on paper and could reduce manual steps for routine cases at the instrument. The limitation is the missing verification. The manuscript outlines the design and states that the Slack bot demonstrates complete reductions, yet it includes no skill document, sample dialogues, test cases, or records of how non-standard situations were handled inside the table. Without those, it is impossible to judge whether run classification, reference matching, scaling choices, or q-range decisions always fit the contract or whether users still need ad-hoc overrides. The stress-test concern stands because the sufficiency claim rests on description rather than shown outcomes. This paper is for instrument staff and users who maintain or script data reduction at neutron facilities, and for developers who want patterns for agent-assisted scientific workflows. A reader building similar tools might borrow the working-table or status-driven ideas. It does not introduce new physics or analysis methods, so the scientific return is narrow. It deserves a serious referee in a venue that covers scientific computing or facility software. The architecture is coherent and the problem is genuine, even if the evidence needs strengthening. I would send it for review with a request for concrete examples and edge-case handling rather than desk-reject it.

Referee Report

2 major / 1 minor

Summary. The paper presents EQSANS-CLI, a command-line tool for small-angle neutron scattering data reduction at EQ-SANS. It organizes the workflow of run classification, reference matching, reduction, absolute scaling, and stitching using four design principles: a shared command-handler layer, a persistent working table holding all reduction decisions, dual input surfaces (interactive terminal and headless JSON mode) that converge on the same handler, and a status-driven re-reduction model. An /autopilot command executes the full pipeline from IPTS number to stitched I(Q), and a Slack bot is cited as demonstrating that the headless interface plus one skill document in an external agent's prompt suffices for natural-language control from a mobile device, with the CLI remaining the authoritative executor.

Significance. If the sufficiency claim holds, the work could meaningfully lower coordination overhead in repetitive SANS reduction pipelines at user facilities and enable reliable natural-language access without exposing the agent to low-level details. The minimal-agent-side design, which keeps the CLI as the single source of truth, is a clear architectural strength that supports reproducibility and reduces the risk of agent-induced errors.

major comments (2)

[Abstract] Abstract: The assertion that 'the headless interface, together with a single skill document loaded into an external agent's system prompt, is sufficient to drive complete reductions by natural language' is load-bearing yet unsupported. No skill document, example dialogues, or records of how the working table resolves non-standard cases (anomalous transmission runs, configuration mismatches, q-range choices, or re-reduction triggers) are provided, leaving the claim as an untested architectural description rather than a verified outcome.
[Design principles] Design principles paragraph: The working-table contract is presented as capturing every reduction decision, but the manuscript supplies no concrete specification of the table schema, the set of editable fields, or the command-handler logic that would guarantee all decisions (run classification, reference matching, absolute scaling, stitching parameters) can be expressed without ad-hoc overrides or loss of scientific flexibility.

minor comments (1)

[Abstract] Abstract: The phrase 'agent-ready' is introduced without a brief definition or scope; a one-sentence clarification of what the term entails (e.g., stable JSON contract, no custom scripting required) would help readers immediately grasp the contribution.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive comments and for recognizing the architectural strengths of the minimal-agent design. We address each major comment below and will incorporate revisions to strengthen the manuscript.

read point-by-point responses

Referee: [Abstract] Abstract: The assertion that 'the headless interface, together with a single skill document loaded into an external agent's system prompt, is sufficient to drive complete reductions by natural language' is load-bearing yet unsupported. No skill document, example dialogues, or records of how the working table resolves non-standard cases (anomalous transmission runs, configuration mismatches, q-range choices, or re-reduction triggers) are provided, leaving the claim as an untested architectural description rather than a verified outcome.

Authors: We agree that the manuscript would be strengthened by explicit supporting material for the sufficiency claim. The Slack bot demonstration establishes that the headless JSON interface plus one skill document enables natural-language operation, with the CLI remaining the single source of truth. To address the concern, we will add the skill document as supplementary material and include example dialogues in the revised manuscript. These examples will cover standard pipelines as well as non-standard cases, showing how the agent instructs edits to the working table (e.g., overriding transmission matching or q-range selection) followed by status-driven re-reduction. This keeps the agent-side requirements minimal while making the outcome verifiable. revision: yes
Referee: [Design principles] Design principles paragraph: The working-table contract is presented as capturing every reduction decision, but the manuscript supplies no concrete specification of the table schema, the set of editable fields, or the command-handler logic that would guarantee all decisions (run classification, reference matching, absolute scaling, stitching parameters) can be expressed without ad-hoc overrides or loss of scientific flexibility.

Authors: The working table is intended to serve as the single contract for all decisions, with command handlers routing every action through table edits before triggering re-reduction. We acknowledge that the manuscript presents this at a conceptual level without a detailed schema. The table includes fields for run classification, reference matching (transmission, background, empty beam), absolute scaling parameters, stitching ranges, and status flags; all commands (classify, match, scale, stitch, edit) operate exclusively on these fields. We will add a new subsection with the explicit schema, a list of editable fields, and handler logic examples to demonstrate that scientific flexibility is retained without ad-hoc overrides. revision: yes

Circularity Check

0 steps flagged

No circularity: software-architecture description with no derivations or self-referential claims

full rationale

The manuscript describes a command-line tool and its architecture (shared handler, working table, headless JSON mode, status-driven re-reduction) without any equations, fitted parameters, predictions, or mathematical derivations. No self-citations appear as load-bearing premises, and the central sufficiency claim for natural-language reductions is presented as an architectural outcome rather than a result derived from prior work by the same authors or reduced to its own inputs by construction. The paper is self-contained as a design document whose assertions rest on the described components rather than any circular reduction.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is a software-tool description paper with no mathematical model, physical derivation, or empirical fit; the ledger is therefore empty.

pith-pipeline@v0.9.0 · 5571 in / 1174 out tokens · 52607 ms · 2026-05-09T14:38:44.927311+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

17 extracted references · 1 canonical work pages

[1]

Beaucage, P. A. & Martin, T. B. (2023).Chem. Mater

2023
[2]

R., Hill, J

Dalesio, L. R., Hill, J. O., Kraimer, M., Lewis, S., Murray, D., Hunt, S., Watson, W., Clausen, M. & Dalesio, J. (1994).Nucl. Instrum. Methods Phys. Res. A,352, 179–184

1994
[3]

Ding, L., Carrillo, J.-M. Y. & Do, C. (2026).Digital Discovery,5, 901–909

2026
[4]

Ding, L., Chen, W.-R. & Do, C. (2024).J. Appl. Crystallogr.57(4), 1047–1058

2024
[5]

Ding, L. & Do, C. (2026).J. Appl. Crystallogr.59(2), 578–585

2026
[6]

EQSANS-CLI: Interactive terminal application for EQ-SANS data reduction

Do, C., (2026). EQSANS-CLI: Interactive terminal application for EQ-SANS data reduction. https://github.com/cw-do/eqsanscli

2026
[7]

& Heller, W

Do, C., Nagy, G. & Heller, W. T. (2025b).ESAC v1: Enhanced AI-Powered Chatbot for EQ-SANS Experiment Automation Improvements and Updates. Tech. Rep. ORNL/TM-2025/4360. Oak Ridge National Laboratory

2025
[8]

T., Cuneo, M., Debeer-Schmitt, L., Do, C., He, L., Heroux, L.et al.(2018).J

Heller, W. T., Cuneo, M., Debeer-Schmitt, L., Do, C., He, L., Heroux, L.et al.(2018).J. Appl. Crystallogr.51(2), 242–248. here.now, (2024). here.now: Temporary file sharing service.https://here.now

2018
[9]

Li, T. & Li, J. (2025).Photon Sci

2025
[10]

Ai agents can already autonomously perform experimental high energy physics,

Moreno, E. A., Bright-Thonney, S., Novak, A., Garcia, D. & Harris, P. (2026).arXiv, p. 2603.20179. OpenRouter, (2026). OpenRouter: unified API for AI models.https://openrouter.ai/

work page arXiv 2026
[11]

H., Chan, H., Vriza, A., Zhou, T., Sastry, V

Prince, M. H., Chan, H., Vriza, A., Zhou, T., Sastry, V. K., Dearing, M. T.et al.(2023).arXiv

2023
[12]

& Granroth, G

Proffen, T. & Granroth, G. E. (2019).Neutron News. SasView Project, (2024). SasView: Small Angle Scattering Analysis.https://www.sasview.org/

2019
[13]

OpenClaw: open-source personal AI assistant framework.https://github

Steinberger, P., (2026). OpenClaw: open-source personal AI assistant framework.https://github. com/openclaw/openclaw

2026
[14]

R., Ford, R., Liu, Y., Martin, T

Sutherland, D. R., Ford, R., Liu, Y., Martin, T. B. & Beaucage, P. A. (2024).arXiv

2024
[15]

& Wang, X

Xiao, Z., Zhang, L., Zhang, G. & Wang, X. (2024).arXiv

2024
[16]

Yao, X., Avery, B., Bobrek, M., Debeer-Schmitt, L., Geng, X., Gregory, R.et al.(2021).Appl. Sci. 11(3)

2021
[17]

K., Gao, C

Zhao, J. K., Gao, C. Y. & Liu, D. (2010).J. Appl. Crystallogr.43, 1068–1077. 18

2010