Where LLMs Should Stop: Confining Non-Determinism in Scientific Workflows

Introduction

There is a persistent fantasy in the discourse around AI for science: that a sufficiently capable language model will read a research question, reason its way to an experiment, run it, and hand back results. The fantasy is appealing precisely because it imagines the model doing everything. The trouble is that "everything" includes steps where non-determinism is not a feature but a defect. Reproducibility, the bedrock of computational science, is fundamentally at odds with a system that can answer the same prompt two different ways.

The paper "From Research Question to Scientific Workflow: Leveraging Agentic AI for Science Automation" by Balis, Orzechowski, Kica, Dygas, and Kuszewski (AGH University of Krakow and Sano Centre for Computational Medicine) takes the opposite stance from the everything-end-to-end fantasy. Its central argument is architectural rather than scale-driven: identify the one step where probabilistic interpretation genuinely helps, confine the language model to it, and route everything downstream through deterministic machinery. The result is a system that turns natural language research questions into executable workflows while guaranteeing that identical interpreted intents always produce identical workflows.

This is a more disciplined and, I think, more honest vision of agentic science than most. Let me work through what they built and why the boundary they draw matters.

The Semantic Gap That Workflow Systems Left Open

Scientific workflow management systems such as Pegasus, Nextflow, Snakemake, and Galaxy are mature and effective at one thing: running a workflow once you have specified it. Given a directed acyclic graph (DAG) of processing steps, they handle scheduling, fault tolerance, data staging, and resource allocation across distributed infrastructure. That problem is, to a large extent, solved.

What remains stubbornly manual is specifying the workflow in the first place. The authors use a concrete and illustrative example: a researcher who wants to "compare mutational patterns in European and African populations across chromosomes 1 through 5" must translate that sentence into a concrete DAG. That translation requires two distinct kinds of expertise:

• Domain knowledge: which VCF data files correspond to "European" (the population code EUR), what genomic region conventions apply, how chromosomes map to data partitions.
• Infrastructure knowledge: how many vCPUs are available, what an appropriate parallelism level is, how to size tasks for the target cluster.

The paper identifies three consequences of leaving this gap unfilled. It creates a barrier to entry, since scientists without infrastructure expertise cannot use these systems unassisted. It is error-prone, because confusing a population code propagates silently into the results. And it undermines reproducibility, because when the translation logic lives only in someone's head, repeating an experiment means reconstructing undocumented decisions.

The naive fix, just letting an LLM generate the workflow directly, makes the third problem worse. The authors cite empirical evidence on this point. Alam and Roy report that GPT-4o reaches 93% structural accuracy on Galaxy workflows with few-shot prompting, yet no generated workflow executes without manual correction. Yildiz and Peterka find that few-shot prompting raises configuration accuracy from roughly 30% to 80%, but cross-platform translation remains unreliable. Direct generation buys you plausible-looking DAGs that do not run and do not reproduce.

The Three-Layer Decomposition

The architecture splits the problem into three layers, and the split is the contribution.

The semantic layer is the only place the LLM operates. It interprets natural language into a structured intent: a parameter set capturing populations, chromosomes, and genomic regions, without committing to any execution details. The model does interpretation, nothing else.

The deterministic layer takes a validated intent and transforms it into an executable DAG through validated generators. Because these are conventional, deterministic generators, the same intent always yields the same workflow. This is the architectural move that the tweet emphasized and that I want to underline: non-determinism is confined to intent extraction. It does not leak into the artifact that gets executed and archived.

The knowledge layer is where domain experts author Skills: markdown documents encoding vocabulary mappings ("European" maps to EUR), parameter constraints, and optimization strategies. A geneticist writes the population mappings; a data engineer documents staging patterns. Crucially, Skills require no machine learning expertise, are version-controlled, and can be audited directly by the people who own the domain knowledge.

The end-to-end pipeline runs through four agents: a Conductor, a Workflow Composer, a Deployment Service, and an Execution Sentinel, with human-in-the-loop validation and deferred workflow generation. The system was implemented on the 1000 Genomes population genetics workflow using the Hyperflow WMS on Kubernetes.

The empirical results are the part worth committing to memory. In an ablation study over 150 queries:

• Skills raise full-match intent accuracy from 44% to 83%.
• Skill-driven deferred workflow generation reduces data transfer by 92%.
• The end-to-end pipeline completes queries on Kubernetes with LLM overhead below 15 seconds and cost under $0.001 per query.

Why the Skills Abstraction Is the Quiet Innovation

The headline number, 44 to 83 percent, is impressive, but I think the more durable idea is the framing of Skills as persistent, auditable artifacts rather than ephemeral prompt context.

Consider the alternative the literature actually uses: few-shot examples injected at prompt time. As the authors note, this knowledge is tied to a single prompt rather than maintained as a lasting artifact. When you fix a vocabulary error in a few-shot example, that fix exists only in whatever prompt template you happened to edit. There is no version history, no review process, no single source of truth that every invocation consults.

Skills invert this. By moving domain knowledge into version-controlled markdown documents, the authors make it subject to the same engineering discipline as code: diffs, reviews, blame, rollback. When a geneticist corrects a population mapping, the correction is auditable and propagates to every future query. This is a governance property, not just a performance one, and governance is exactly what science needs from its tooling.

There is a second, underappreciated point: Skills are dual-purpose. They encode not only vocabulary for correct translation but also optimization strategies applied at execution time. The 92% data transfer reduction comes from a skill that encodes selective data extraction. So the same artifact that makes the system correct also makes it efficient, and both behaviors are inspectable by domain experts rather than buried in model weights.

My Take: A Principled Boundary, With Caveats

What I find genuinely valuable here is the explicit boundary between probabilistic interpretation and reproducible computation. Much of the agentic AI field is busy pushing the boundary outward, letting models reason, act, and verify in long autonomous loops. This paper pushes it inward, and the result is a system whose worst-case failure is bounded: if the LLM misinterprets a query, a human catches it at the intent stage, and once the intent is validated, nothing downstream can surprise you. That is a far more defensible posture for science than end-to-end autonomy.

I do want to register the limitations honestly.

• The evaluation is single-domain. The system is demonstrated on one workflow (1000 Genomes) and one WMS (Hyperflow on Kubernetes). The 44-to-83 jump is encouraging, but 83% full-match intent accuracy still means roughly one in six queries is not fully correct. The human-in-the-loop validation is doing real work here, and the paper's value depends on that loop being cheap.

• Skills shift the bottleneck, they do not remove it. Someone must author and maintain them. For a well-documented dataset like 1000 Genomes the mappings are tractable; for frontier domains where the vocabulary itself is contested, writing a clean Skill may be as hard as the original translation.

• Intent expressiveness is a ceiling. The structured intent schema is fixed by the deterministic generators. Genuinely novel research questions that fall outside the parameter space the generators support cannot be expressed, no matter how good the LLM is at interpretation. This is the classic tradeoff: determinism downstream costs you flexibility upstream.

Conclusion

The lasting contribution of this work is not a model or a benchmark; it is a placement decision. By confining LLM non-determinism to intent extraction and routing everything else through validated, deterministic generators backed by auditable domain Skills, the authors show that you can have natural-language workflow specification without sacrificing reproducibility. Identical intents yield identical workflows, full stop.

The open questions I would want answered next are about generalization and maintenance. How does the Skills abstraction scale across dozens of domains, and what does the authoring burden look like at that scale? Can intent schemas evolve gracefully as new research questions arrive, or does every novel question demand new generator code? And how does the human-in-the-loop cost behave when intent accuracy plateaus below 100%? The architecture is sound. Whether it composes into a general infrastructure for agentic science, rather than a well-engineered point solution, is the question the field should now be testing.