Process-Reward Tactic Evolution for Long-Horizon Bioinformatics Workflows Lingzhi Yang Yubo Fan Song Wu Gilchan Park Stony Brook University Vanderbilt University Stony Brook University Brookhaven National Lab
Abstract
arXiv:2606.20839v1 [cs.AI] 18 Jun 2026
LLM agents can write code and call tools, but reliable bioinformatics work requires longhorizon interaction with workflow software, typed data objects, provenance, and biological checks. We study this setting through Galaxy workflow execution. The agent must explore task data, construct or adapt an executable workflow DAG, bind inputs and dataset collections, monitor execution, debug failures, and validate biological outputs. We propose Process-Reward Tactic Evolution, a Galaxy-based training framework that turns verified workflow rollouts into reusable BioWorkflow Tactics. During training, agents practice on curriculum-organized Galaxy tasks in BioAgent Gym; process verifiers score workflow construction, software interaction, execution, and biological correctness; successful and failed traces are distilled into a tactic library. At inference, the trained executor, PRTE Agent, uses this library to execute held-out BioWorkflow Bench and BioAgent Bench tasks in isolated environments. The paper evaluates whether process-supervised tactic accumulation improves long-horizon bioinformatics workflow completion, biological correctness, and execution efficiency over no-memory and reflection-style baselines.
1
Introduction
LLM agents are increasingly evaluated in longhorizon scientific settings where success depends on files, software state, tool calls, and execution traces rather than a single textual answer (Chen et al., 2025; Shen et al., 2026). Bioinformatics workflow construction is a demanding instance: real analyses involve typed datasets, workflow graphs, provenance, biological assertions, and live execution on platforms such as Galaxy (Mitchener et al., 2025; Fa et al., 2026). Existing reflection, memory, skill, and prompt-evolution methods show that agents can improve by accumulating external
process state (Shinn et al., 2023; Zhao et al., 2024; Wang et al., 2024; Xu et al., 2025; Agrawal et al., 2026), but they rarely train on realistic scientific workflow execution where intermediate software states are observable and consequential. We ask how an agent can learn executable bioinformatics workflows from repeated, verifiable Galaxy interactions. Unlike biomedical QA, correctness is distributed across documentation lookup, input staging, datatype binding, workflow import, invocation, job completion, artifact collection, and biological validation. Useful learning must therefore be procedural: a later agent should recover tactics for schema inspection, collection wiring, graph repair, output accounting, and domain-specific workflow families, not only remember that a past task succeeded. We propose Process-Reward Tactic Evolution, a Galaxy-based training framework for workflow agents. Agents practice on curriculum-organized tasks in BioAgent Gym with public documentation, sandboxed notebooks, BioBlend, gxformat2, and usegalaxy execution backends (Galaxy Project, 2026; BioBlend, 2026; Galaxy Project, 2026). Process verifiers score workflow construction, software interaction, execution, repair, leakage safety, and biological correctness (Sohn et al., 2026; Lee et al., 2026b; Rosset et al., 2026). A semanticgradient updater converts successful and failed public trajectory segments into scoped tactics with applicability conditions, executable procedures, postconditions, failure signatures, and public evidence. At inference time, isolated workers retrieve the trained tactics and execute held-out workflow tasks. We evaluate on BioWorkflow Bench, a Galaxy benchmark derived from public workflow resources with 26 training tasks and 35 held-out test tasks (Galaxy Project, 2026; Alam and Roy, 2025; Cynthia and Roy, 2025), and on BioAgent Bench as an external bioinformatics-agent benchmark (Fa et al., 2026). Our contributions are to formulate Galaxy
workflow construction as a long-horizon agenttraining problem, introduce process-supervised tactic evolution with gated tactic-library growth, and show improved long/xlong BioWorkflow performance, biological correctness, and execution efficiency over no-memory and reflection/promptevolution baselines.
2
Method
2.1
Problem and Overview
We study executable bioinformatics workflow construction as an agent-environment problem. Unlike short-answer biomedical QA, a Galaxy task is solved only when the agent builds, imports, runs, repairs, and validates a workflow through a real software backend. Formally, a task-output pair is x = (u, I, Dpub , b), y = (W, D̂, A, Π, τ, r).
(1)
Here u is the biological objective, I is the input manifest, Dpub is public documentation, and b contains backend constraints. The output includes an executable Galaxy workflow W , produced datasets D̂, biological assertions A, provenance Π, an execution trace τ , and process scores r. We use Galaxy because it offers maintained tools, importable workflow graphs, public IWC/GTN resources, and reproducible APIs (Galaxy Project, 2026; BioBlend, 2026; Galaxy Project, 2026). The workflow W = (V, E, ϕ, ψ, δ) is a typed DAG: nodes are tools, inputs, and outputs; edges carry datasets or collections; ϕ gives tool identities; ψ stores parameters; and δ stores datatype and collection constraints. Process-Reward Tactic Evolution (PRTE) keeps the execution environment stable across agents and improves an external tactic state Ω from real Galaxy rollouts. Figure 1 shows the training and inference split. 2.2
Tactic State
PRTE represents learned experience as a tactic library rather than a single reflection string. This follows memory and skill-library agents, but specializes the stored units to verifier-backed scientific workflow procedures (Wang et al., 2024; Zhou et al., 2025; Liu et al., 2026; Liang et al., 2026). We write Ω = (L, GΩ , ρ), (2) where L is a set of tactic files, GΩ is a dependency graph, and ρ is a retrieval function. A tactic states
Figure 1: Overview of Process-Reward Tactic Evolution. Training executes curriculum-organized Galaxy rollouts, scores them with process rewards, and updates an external tactic state. Inference retrieves the trained tactic library for isolated workers executing held-out Galaxy workflow tasks.
when it applies, what operation to perform, what postcondition should hold, which failure signature it repairs, and what public evidence supports it. Typical tactics cover schema inspection, pairedcollection wiring, gxformat2 checking, Galaxy invocation repair, artifact accounting, and task-family biological checks. 2.3
Process-Supervised Updates
Training proceeds over curriculum batches Sk . Each batch uses one tactic snapshot, runs isolated Galaxy rollouts, and then updates the tactic state: Bk = {τx,j : x ∈ Sk , j = 1, . . . , gk (x)}, Ωk+1 = U (Ωk ; {(τi , ri )}i∈Bk ).
(3)
The curriculum starts with small workflows, documentation lookup, local checks, and importable graphs, then adds longer dependency chains, live invocation, queue behavior, artifact recovery, and biological validation. Following process-reward and verifier-harness work, the updater receives intermediate evidence rather than only final success (Sohn et al., 2026; Lee et al., 2026b; Rosset et al., 2026). Each trajectory is scored as r(τ ) = (rdoc , rchk , rimp , rinv , rjob , rart , rbio , rrep , rlife , rsafe ).
(4)
These channels measure documentation use, local validation, import, invocation, job completion, artifact collection, biological correctness, repair progress, lifecycle discipline, and leakage safety. The scalar training signal and group-relative credit
are
Benchmark
P
j wj clip[0,1] (rij )
Ri − µB P , Ai = Ri = . σB + ϵ j wj (5) The update U has three stages. A reviewer extracts public positive and negative evidence from each trajectory. A semantic-gradient updater compares successful and failed excerpts to propose tactic patches. A gate accepts a patch only if it has applicability, executable procedure, verification check, failure signature, and public evidence. Hidden gold workflows and private assertions are never written into Ω. 2.4
Tactic-Aware Inference
Held-out inference freezes the trained tactic state. A worker retrieves a budgeted tactic bundle Bx = Hydrate Closure(ρ(x, L), GΩ ), Bmax , (6) then executes the task in an isolated notebook and Galaxy account. It stages data, writes or adapts workflow artifacts, runs local checks, imports and invokes the graph, polls jobs, repairs allowed failures, collects outputs, and submits evidence. A controller monitors usage windows, authentication, backend instability, resumes, timeouts, and cleanup, but it does not choose tools, edit graphs, or provide biological answers.
3
Experiments
3.1
Tasks and Environment
We evaluate in a Galaxy-centered bioinformatics environment. Each run uses a local sandbox with Python notebooks, BioBlend, gxformat2, task manifests, public documentation, and a usegalaxy execution backend. The agent must stage inputs, construct or adapt a workflow, import and invoke it, monitor execution, collect artifacts, and write evaluator-readable evidence. The training split contains 26 workflow tasks and the held-out split contains 35 tasks, which we call test35. The held-out set is balanced across small, medium, long, and xlong workflow sizes. Appendix B lists the training and test tasks and the public Galaxy documentation used by the agents. 3.2
Benchmarks
We use two complementary benchmarks. BioWorkflow Bench is our main benchmark for longhorizon Galaxy workflow construction. It con-
BioWorkflow Bench BioAgent Bench
Split
Tasks
Tools
Avg. tools
train26 test35 total61 full
26 35 61 10
322 455 777 62
12.38 13.00 12.74 6.20
Avg. depth 10.62 11.34 11.03 5.80
Table 1: Benchmark statistics. BioWorkflow Bench test35 refers to the final 35-task held-out complexitybalanced test split; BioAgent Bench full refers to the adopted 10-task external benchmark set. Metric definitions and task-level details are provided in Appendix B.
tains executable workflow tasks derived from public workflow resources and records graph statistics such as tool count and workflow depth. BioAgent Bench is an external 10-task bioinformatics-agent benchmark (Fa et al., 2026); it is shorter, but it provides an outside point of comparison for result matching, final-result completion, and step-level completion. The benchmark statistics in Table 1 make this contrast explicit: our held-out split contains deeper and more structurally varied workflow graphs, while BioAgent Bench anchors the comparison to an existing external suite. 3.3
Evaluated Agents
We evaluate eight agents on BioWorkflow Bench test35. The no-training group includes ReAct, MultiAgent, and Agent Harness/Biomni. The training group includes Reflexion, Agent Workflow Memory, Agentic Memory, GEPA-style prompt evolution, and PRTE Agent. All agents use the same model family, sandbox interface, public task bundles, and evaluator. For BioAgent Bench, we evaluate the four agents for which comparable tasklevel evidence is available: ReAct, MultiAgent, Agent Harness/Biomni, and PRTE Agent. For converted BioWorkflow rows, we use the same quick10-to-test35 conversion protocol documented with the result tables; actual test35 rows are explicitly marked in the captions. 3.4
Metrics
BioWorkflow Bench reports workflow completion, biological correctness, and a weighted final score: Final = 0.6 · Workflow + 0.4 · Biology.
(7)
Workflow completion measures whether the agent constructs and executes the requested Galaxy workflow process. Biology measures whether the outputs and assertions match the intended biological analysis. We also report token consumption, API rounds, execution time, and milestone progress for an xlong Hi-C case study.
GEPA
No Process
Process Reward
0.5
0.6 Overall final score
BioWorkflow Bench final score
ReAct MultiAgent Agent Harness Reflexion AWM Agentic-Memory GEPA PRTE Agent
0.8
0.4 0.2
0.45
0 Small
Medium
Long
XLong
Overall
Figure 2: BioWorkflow Bench test35 final weighted scores by complexity group and overall. The three notraining agents use orange/yellow shades; Reflexion, AWM, and Agentic-Memory use green shades; GEPA uses blue; and the Process-Reward Tactic Evolution agent is denoted as PRTE Agent in purple.
4
Main Results
4.1
Overall BioWorkflow Performance
Memory and training help on BioWorkflow Bench, but their value depends on whether the learned state can support long workflow execution. GEPA obtains the highest small and medium scores, where a strong global instruction can cover many tasks. The pattern reverses as workflow horizon grows: PRTE Agent obtains the best long, xlong, and overall final scores, as shown in Figure 2. Its overall score is 0.5013, compared with 0.4953 for GEPA, 0.4586 for Agent Workflow Memory, and 0.3926 for Agent Harness/Biomni. The overall gain is not uniform; it is concentrated in the hardest workflow regimes. The detailed decomposition in Table 2 shows that PRTE Agent improves over GEPA on long workflows (0.3182 vs. 0.3059 final) and xlong workflows (0.3922 vs. 0.3090 final). The xlong gain comes mainly from biological correctness, where PRTE Agent reaches 0.4502 while GEPA reaches 0.3808. This supports the intended role of tactics: they preserve platform procedures while leaving more model context for biological reasoning and output validation. 4.2
External BioAgent Bench Comparison
The learned tactic state also transfers to a shorter external benchmark. On BioAgent Bench, PRTE Agent reaches 10/10 final-result completion, 8/10 result match, and the highest average step score (Table 3). Agent Harness/Biomni also reaches 10/10 final completion and 8/10 result match, while PRTE Agent has a slightly higher step-level score and combined mean. This confirms that the gains are not only an artifact of our own benchmark construc-
0.4
empty
batch1
batch2
batch3
batch4
Checkpoint
Figure 3: Ablation training curve across checkpoints. The plotted value is the overall BioWorkflow Bench final score for each configuration.
tion; the same process memory remains competitive on an external bioinformatics-agent evaluation. 4.3
Ablation Study
Process reward is the part of training that turns repeated rollouts into usable procedural memory. Across checkpoints, outcome-only training improves after the first batch but does not keep improving; its final score ends at 0.4770. GEPA remains strong but flat after its selected seed instruction. The full process-reward agent improves more steadily and finishes at 0.5013. Figure 3 and Table 4 show this trajectory from the same checkpoint scores. The ablation result is therefore structural: repeated outcome labels alone are insufficient for long workflow learning, while process signals provide the updater with enough evidence to write reusable tactics. The checkpoint curves diverge because the training variants write different kinds of state. GEPA evolves a single instruction. The no-process library grows modestly from 6 to 8 tactic files. The process-reward library grows to 26 tactic files and 33.7K approximate tokens (Table 5). The qualitative logs in Appendix C show that these additional files are not merely longer reflections: they include repair procedures and task-family contracts for recurring workflow families such as RNA-seq, Hi-C, pseudobulk analysis, MAG generation, HyPhy comparison, assembly cleanup, and chromatin peak QC. Thus process reward changes the kind of memory written, not only its size. 4.4
Resource Efficiency
Tactics also change the cost profile of held-out execution. No-training agents spend very large token
Group
Small (n = 5)
Agent
Workflow Biology
Medium (n = 10) Final Workflow Biology
Long (n = 10)
Final Workflow Biology
XLong (n = 10) Final Workflow Biology
Overall (n = 35)
Final Workflow Biology
Final
No training ReAct No training MultiAgent No training Agent Harness
0.7691 0.7530 0.7192
0.3132 0.5867 0.2793 0.5635 0.3519 0.5723
0.6984 0.7210 0.7122
0.2928 0.5362 0.2096 0.5164 0.3606 0.5716
0.2794 0.2958 0.2998
0.2287 0.2592 0.1006 0.2177 0.1468 0.2386
0.2233 0.2650 0.2270
0.1485 0.1934 0.1317 0.2117 0.3543 0.2779
0.4531 0.4738 0.4567
0.2362 0.3663 0.1662 0.3507 0.2965 0.3926
Training Training Training Training Training
0.8595 0.8489 0.8590 0.9383 0.8271
0.4785 0.7071 0.6391 0.7650 0.5034 0.7168 0.6976 0.8420 0.6976 0.7753
0.7565 0.7221 0.7465 0.7648 0.7206
0.2458 0.5522 0.5062 0.6357 0.3705 0.5961 0.5970 0.6977 0.5603 0.6565
0.3564 0.2957 0.3810 0.3620 0.3764
0.0846 0.2477 0.2561 0.2799 0.2026 0.3096 0.2217 0.3059 0.2309 0.3182
0.3658 0.3039 0.3539 0.2610 0.3535
0.1614 0.2841 0.3119 0.3071 0.1836 0.2858 0.3808 0.3090 0.4502 0.3922
0.5453 0.4989 0.5460 0.5305 0.5326
0.2089 0.4107 0.3982 0.4586 0.2881 0.4428 0.4424 0.4953 0.4544 0.5013
Reflexion Agent Workflow Memory Agentic Memory GEPA PRTE Agent
Table 2: Detailed BioWorkflow Bench test35 results for all evaluated agents. Each complexity group reports workflow completion, biological correctness, and the weighted final score. Bold marks the best value in each metric column, with ties bolded together. PRTE Agent denotes the Process-Reward Tactic Evolution agent. GEPA and PRTE Agent are actual test35 runs; the other BioWorkflow agents are converted test35 estimates.
Agent
Match Final
ReAct MultiAgent Agent Harness PRTE Agent
Step Combined
2/10 9/10 0.8600 5/10 9/10 0.9260 8/10 10/10 0.9500 8/10 10/10 0.9667
0.6533 0.7753 0.9167 0.9222
Table 3: BioAgent Bench results on the external 10-task benchmark. Match is the result-match rate, Final is the final-result-reached rate, Step is the average step-level completion score, and Combined is their mean. Agent Harness corresponds to Biomni; PRTE Agent denotes the Process-Reward Tactic Evolution agent.
Agent
Token
API Rounds
ReAct 2662.939M / 76.084M MultiAgent 8514.015M / 243.258M Agent Harness / Biomni 2780.308M / 79.437M Reflexion 689.846M / 19.710M Agent Workflow Memory 1474.397M / 42.126M Agentic Memory 739.059M / 21.116M GEPA 765.597M / 21.874M PRTE Agent 963.454M / 27.527M
Execution Time
1,430.0 / 40.9 84.48h / 2.41h 4,973.3 / 142.1 153.84h / 4.40h 1,426.7 / 40.8 63.17h / 1.80h 6,156.7 / 175.9 23.16h / 0.66h 8,220.0 / 234.9 65.55h / 1.87h 3,798.3 / 108.5 26.81h / 0.77h 5,551.0 / 158.6 25.82h / 0.74h 7,746.0 / 221.3 33.37h / 0.95h
Table 6: Test35 resource consumption. Each cell reports total consumption followed by the average per task. Token counts are in millions of tokens and execution time is in hours. 3,000
No Process
Process Reward
empty batch1 batch2 batch3 batch4
0.4799 / 0.4008 / 0.4483 0.5238 / 0.4248 / 0.4842 0.5167 / 0.3964 / 0.4686 0.5258 / 0.3535 / 0.4569 0.5008 / 0.4415 / 0.4770
0.4799 / 0.4008 / 0.4483 0.5305 / 0.3893 / 0.4740 0.5546 / 0.3904 / 0.4889 0.5619 / 0.3925 / 0.4942 0.5326 / 0.4544 / 0.5013
0.4631 / 0.3024 / 0.3982 0.5571 / 0.2912 / 0.4508 0.5504 / 0.3796 / 0.4821 0.5481 / 0.2372 / 0.4237 0.5481 / 0.2372 / 0.4237
Table 4: Training-curve ablation results across checkpoints. Each cell reports Workflow / Biology / Final. Process Reward is the PRTE training configuration with process-reward-guided tactic evolution.
2,500 Cum. Tokens (M)
Checkpoint GEPA
2,000 1,500 1,000
ReAct
Init/Empty
After Batch4
Files Tokens Files Tokens GEPA No Process Process Reward
1 6 6
223 6,669 6,669
1 852 8 11,039 26 33,700
Table 5: Tactics-library size before training and after batch4. GEPA mutates a single instruction file, while No Process and Process Reward maintain tactic Markdown files. Token counts use the same approximate convention as the training analysis.
budgets because they rediscover platform procedures during every task. MultiAgent is the most expensive, with 8.514B total tokens and 4,973 API rounds. PRTE Agent uses 963.454M total tokens on the held-out tasks, averaging 27.527M per task (Table 6). Training agents can have substantial
Reflexion
AWM
A-Memory
GEPA
PRTE
500 0 0
Agent
MultiAgent
Harness
5
10
15
20
25
30
35
Evaluated Tasks
Figure 4: Cumulative token consumption over the ordered test35 tasks. Training agents include their fixed training cost at task count 0; curves stop after crossing the 3B-token plotting range.
API-round counts because they perform detailed tool and workflow interactions, but the important comparison is that tactic-guided execution avoids the very large token growth seen in no-training multi-agent runs. The amortization point matters because training is a fixed upfront cost. For a single short task, training may be unnecessary; for repeated longhorizon workflows in the same software environment, reusable tactics amortize their cost. Figure 4 plots this cumulative token trajectory over ordered
8
matching, invocation, repair, artifact collection, and biological checking. On BioWorkflow Bench and BioAgent Bench, this tactic state improves long and xlong task performance, biological correctness, and execution efficiency. The broader conclusion is that scientific agents need verifier-backed, reusable process memory when they operate in complex software environments.
7
Milestone
6 5 4 3 ReAct
2 1
MultiAgent
Harness
Reflexion
AWM
A-Memory
GEPA
PRTE
0 0
10
20
30
40
50
60
Limitations
Cum. Tokens (M)
Figure 5: Milestone progress on the representative xlong Hi-C task. Each curve shows the cumulative task-execution tokens needed to reach each milestone; training cost is excluded. Curves are truncated at the 60M-token plotting boundary.
held-out tasks. This is the practical regime for bioinformatics platforms, where scientists repeatedly use the same infrastructure, datatypes, wrappers, and debugging patterns across different analyses. 4.5
XLong Case Study
The representative xlong Hi-C case shows why aggregate token use alone is not a sufficient efficiency metric. Several agents stop before graph success even after large token use, so long-horizon progress is not proportional to total reasoning effort. Figure 5 makes this visible by plotting milestone progress, from initialization through data preparation, notebook creation, Galaxy response, toolformat discovery, graph upload, successful graph execution, and final submission. Training cost is excluded so the figure measures only task execution. GEPA reaches all milestones with very low task-token cost on this case, while PRTE Agent also reaches final submission and maintains a more complete execution trajectory than incomplete baselines. The appendix gives the tactics-to-trace comparison and the final Galaxy workflow screenshot.
5
Conclusion
Bioinformatics workflow construction exposes a core limitation of long-horizon LLM agents: without persistent process memory, the agent repeatedly spends context on software recovery rather than scientific reasoning. We introduced ProcessReward Tactic Evolution, a Galaxy-based training framework that converts real workflow rollouts into reusable tactics for workflow authoring, schema
Our experiments are centered on Galaxy, so performance depends on public-server availability, queue behavior, installed tool versions, and dataset accessibility. Some workflows are too backendspecific or long-running for perfectly stable sharedinfrastructure evaluation. Biological assertions are useful but partial; passing them does not replace expert review of downstream scientific interpretation. The tactic updater must also remain conservative, because an incorrect reusable repair can harm future tasks.
Ethics Statement The benchmark tasks, workflow templates, documentation, and input data used in this paper are derived from public bioinformatics resources. The system is intended for workflow-construction research and should not be used as a substitute for expert biological or clinical judgment. We report converted estimates separately from actual test35 runs where applicable. After publication, we plan to release the code, task manifests, prompts, evaluator configuration, and generated tactic artifacts needed to reproduce the experiments, subject to public-service access limits and any required cleanup of authentication material.
References Agrawal, M. et al. 2026. GEPA: Reflective prompt evolution with task-level feedback. Alam, K. and Roy, B. 2025. From prompt to pipeline: Large language models for scientific workflow development in bioinformatics. Galaxy Project. 2026. BioBlend documentation. https: //bioblend.readthedocs.io/. Chen, Z. et al. 2025. ScienceAgentBench: Toward rigorous assessment of language agents for data-driven scientific discovery. Coleman, T. et al. 2022. WfBench: Automated generation of scientific workflow benchmarks.
Cynthia, S. T. and Roy, B. 2025. Towards LLMpowered task-aware retrieval of scientific workflows for Galaxy.
Sohn, J., Sternal, T., Styppa, K., Hoefler, T., and Moor, M. 2026. Process reward agents for steering knowledge-intensive reasoning.
Fa, D., Culjak, M., Pandza, B., and Cupic, M. 2026. BioAgent Bench: An AI agent evaluation suite for bioinformatics.
Su, H., Long, W., and Zhang, Y. 2025. BioMaster: Multi-agent system for automated bioinformatics analysis workflow.
Galaxy Project. 2026. gxformat2 documentation and Galaxy Workflow Format 2. https://gxformat2. readthedocs.io/.
Youtu-Agent Team. 2025. Training-free group relative policy optimization.
Galaxy Project. 2026. Intergalactic Workflow Commission. https://iwc.galaxyproject.org/. Wang, Z. et al. 2025. GeneAgent: Self-verification language agent for gene-set analysis using domain databases. He, X. et al. 2026. EvoTest: Evolutionary test-time optimization for agents. Lee, Y. et al. 2026a. Agentic aggregation for parallel scaling of long-horizon agentic tasks. Lee, Y. et al. 2026b. Meta-Harness: End-to-end optimization of model harnesses. Liang, Y. et al. 2026. SkillNet: Create, evaluate, and connect AI skills.
Wang, G. et al. 2023. Voyager: An open-ended embodied agent with large language models. Wang, Z. Z., Mao, J., Fried, D., and Neubig, G. 2024. Agent workflow memory. Xu, Z. et al. 2025. A-MEM: Agentic memory for language agents. Zhao, A. et al. 2024. ExpeL: LLM agents are experiential learners. Zhou, H. et al. 2025. Memento: Fine-tuning LLM agents without fine-tuning LLMs. Besta, M. et al. 2024. Graph of Thoughts: Solving elaborate problems with large language models. Hu, S., Lu, C., and Clune, J. 2025. Automated design of agentic systems.
Liao, Y., Jiang, S., Wang, Y., and Wang, Y. 2024. ReflecTool: Towards reflection-aware tool-augmented clinical agents.
Galaxy Project. 2026. Planemo documentation. https: //planemo.readthedocs.io/.
Liu, D. et al. 2026. Graph of Skills: Dependency-aware structural retrieval for massive agent skills.
Zhang, J. et al. 2025. AFlow: Automating agentic workflow generation.
Masera, M., Leone, A., Koster, J., and Molineris, I. 2025. Snakemaker: Transforming ad-hoc analyses into sustainable Snakemake workflows with generative AI.
Yao, S. et al. 2023. Tree of Thoughts: Deliberate problem solving with large language models.
Mi, H. et al. 2026. Skill-Pro: Learning reusable procedures for long-horizon agents. Ming, M. et al. 2025. DoVer: Intervention-driven auto debugging for LLM multi-agent systems. Mitchener, L. et al. 2025. BixBench: A comprehensive benchmark for LLM-based agents in computational biology. Ouyang, S. et al. 2026. ReasoningBank: Memory for reusable reasoning in language agents. Rosset, C. et al. 2026. The art of building verifiers for computer-use agents. Shen, Y. et al. 2026. SciAgentGym: Benchmarking multi-step scientific tool use in LLM agents. Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., and Yao, S. 2023. Reflexion: Language agents with verbal reinforcement learning.
Zhou, C. et al. 2026a. Externalization in LLM agents: A unified review of memory, skills, protocols, and harness engineering. Zhou, C. et al. 2026b. Externalization in LLM agents: A unified review of memory, skills, protocols, and harness engineering. Liu, D. et al. 2026b. Graph of Skills: Dependency-aware structural retrieval for massive agent skills. Zhou, H. et al. 2025b. Memento: Fine-tuning LLM agents without fine-tuning LLMs. Lee, Y. et al. 2026c. Meta-Harness: End-to-end optimization of model harnesses. Sohn, J. et al. 2026b. Process reward agents for steering knowledge-intensive reasoning. Anonymous. 2026. Replay-based evaluation for longhorizon language agents. Anonymous. 2026. SkillClaw: Evolving reusable skills for language agents.
A
Related Work
A.1
Long-Horizon Science and Bioinformatics Agents
BixBench, ScienceAgentBench, and SciAgentGym move science-agent evaluation beyond static question answering toward executable, multi-step tasks (Mitchener et al., 2025; Chen et al., 2025; Shen et al., 2026). BioAgent Bench narrows this direction to bioinformatics pipelines with executable traces and perturbation tests (Fa et al., 2026). BioMaster, GeneAgent, and ReflecTool further show that biomedical agents need planning, retrieval, tool use, and self-verification (Su et al., 2025; GeneAgent, 2025; Liao et al., 2024). BioWorkflow is complementary: it centers long-horizon Galaxy workflow-DAG execution and asks whether agents can learn reusable process tactics from repeated verifiable interactions. A.2
Bioinformatics Workflow Automation
Workflow-specific work studies how LLMs retrieve, generate, or convert scientific workflows. Prompt-toPipeline evaluates LLM-generated Galaxy and Nextflow workflows, Galaxy retrieval work ranks reusable workflows for a task, and Snakemaker converts ad hoc analyses into Snakemake workflows (Alam and Roy, 2025; Cynthia and Roy, 2025; Masera et al., 2025). WfBench and community workflow resources such as IWC motivate executable workflow artifacts and benchmarks (Coleman et al., 2022; Galaxy Project, 2026). These systems address workflow access and representation; our agent must also bind inputs, invoke workflows, monitor jobs, inspect artifacts, repair failures, and update tactics from traces. A.3
Memory, Skills, and Weight-Free Agent Learning
BioWorkflow also belongs to externalized agent learning. Reflexion and ExpeL store verbal reflections or distilled insights (Shinn et al., 2023; Zhao et al., 2024); Voyager and Skill-Pro learn reusable skills or procedures (Wang et al., 2023; Mi et al., 2026); Agent Workflow Memory, A-MEM, and ReasoningBank organize workflow, graph, or reasoning memories (Wang et al., 2024; Xu et al., 2025; Ouyang et al., 2026); and Memento, Training-Free GRPO, GEPA, and EvoTest adapt memory, prompt, or agent-system state across trials (Zhou et al., 2025; Training-Free GRPO Team, 2025; Agrawal et al., 2026; He et al., 2026). Graph of Skills and SkillNet emphasize that growing skill libraries require structure, evaluation, and dependency-aware retrieval (Liu et al., 2026; Liang et al., 2026). Our tactic library specializes this direction to scientific workflow software: each tactic is a typed, executable, verifier-backed process unit with applicability conditions, software actions, postconditions, failure signatures, and repair routes grounded in Galaxy evidence. A.4
Process Rewards, Verifiers, and Harnesses
Process-reward and verifier-harness work shows why intermediate evidence matters. Process Reward Agents use step-level rewards, Meta-Harness optimizes harness behavior from source code, scores, and traces, and DoVer validates debugging hypotheses through intervention and replay (Sohn et al., 2026; Lee et al., 2026b; Ming et al., 2025). Agentic Aggregation and verifier-design work similarly treat parallel trajectories and checkers as inspectable evidence for long-horizon agents (Lee et al., 2026a; Rosset et al., 2026). BioWorkflow transfers this principle to bioinformatics workflows, where process evidence comes from BioBlend responses, gxformat2 graph checks, datatype and collection metadata, Galaxy job states, output artifacts, and biological assertions.
B
BioWorkflow Bench Data Preparation
We built BioWorkflow Bench to study executable workflow construction rather than short-answer biomedical reasoning. We first surveyed existing bioinformatics-agent and workflow resources, including BixBench, BioAgent Bench, CWL, WDL, Nextflow, and Galaxy. BixBench emphasizes coding and multiple-choice reasoning, which does not directly match our target of workflow graph construction and live execution. BioAgent Bench provides useful executable bioinformatics tasks and a local sandbox, but the public set contains only ten relatively short tasks. It is therefore valuable as an external comparison but insufficient as the main benchmark for long-horizon workflow learning.
Galaxy provides the strongest basis for our setting. It has a public execution backend through usegalaxy, maintained tool wrappers, BioBlend and gxformat2 APIs, and large public workflow resources. The IWC workflows are especially useful because they contain peer-reviewed Galaxy workflow graphs and reproducibility metadata. GTN materials provide additional training-style workflow examples. These resources allow the agent to operate against a real platform without requiring us to install every bioinformatics tool and database locally. We chose Galaxy over CWL, Nextflow, and WDL for this benchmark because Galaxy combines public tasks, workflow graphs, assertions, documentation, and a free shared execution backend. Containercentered workflow systems are important future targets, but they would substantially increase evaluation complexity because each task may require local container orchestration, reference data, and environmentspecific execution logic. Our current design therefore focuses on Galaxy while keeping the task representation compatible with future workflow-platform expansion. Tables 7 and 8 list the 26 training tasks and 35 held-out test tasks. In these tables, Tools counts unique Galaxy workflow tools, Depth is the longest dependency-chain length in the workflow graph, Inputs counts task inputs, and Asrts counts available assertion checks. BioAgent Bench does not expose the same gold Galaxy workflow DAG metadata as BioWorkflow Bench; in the main text, its tool and depth statistics therefore use the adopted Galaxy-run tool counts and evaluator step-count proxy. Table 9 lists the initial Galaxy documentation projects exposed to the agents.
Src
Size
Topic
IWC IWC IWC IWC IWC GTN GTN IWC IWC GTN IWC GTN IWC IWC IWC IWC GTN IWC IWC IWC IWC GTN IWC IWC IWC IWC
small small small small small small medium medium medium medium medium medium medium medium medium medium medium medium long long long xlong xlong xlong xlong xlong
SRA accession download Raw-read quality control 10X single-cell FASTQ to matrix ChIP-seq single-end processing Flye genome assembly Braker3 genome annotation NGS variant-analysis tutorial RNA-seq single-end quantification RNA-seq differential expression Pseudobulk differential expression CUT&RUN/CUT&TAG analysis Hi-C analysis with HiCExplorer Generic WGS paired-end variants Assembly decontamination Bacterial genome annotation DADA2 paired-end amplicons QCxMS EI+ mass-spectra prediction HyPhy CAPHEINE compare ATAC-seq accessibility profiling SARS-CoV-2 ARTIC PE variation GROMACS dcTMD calculations Differential isoform expression Scanpy single-cell clustering VGP3 HiFi genome assembly VGP6 duplicate-contig purging Metagenome-assembled genomes
Tools Depth Inputs Asrts 3 7 3 7 4 5 13 8 13 10 9 11 12 9 7 11 11 10 21 20 13 35 14 21 16 29
4 6 4 6 3 4 12 6 9 9 8 5 10 10 5 10 13 13 14 17 10 23 26 11 18 20
1 2 4 1 1 3 2 2 5 1 2 9 3 1 1 10 1 6 2 5 2 18 3 4 6 4
3 0 4 6 10 0 45 9 0 0 8 2 0 0 11 0 0 0 11 0 0 5 1 11 13 0
Table 7: Training tasks used by the BioWorkflow Bench curriculum. Tools, Depth, Inputs, and Asrts count workflow tools, longest dependency-chain depth, input datasets, and output assertions. Src
Size
Topic
IWC IWC GTN IWC IWC IWC IWC IWC IWC IWC IWC IWC IWC GTN GTN IWC IWC GTN GTN GTN IWC IWC IWC IWC IWC IWC IWC GTN IWC IWC IWC IWC IWC GTN GTN
small small small small small medium medium medium medium medium medium medium medium medium medium long long long long long long long long long long xlong xlong xlong xlong xlong xlong xlong xlong xlong xlong
Short-read QC and trimming Bacterial genome assembly Single-cell RNA-seq QC BigWig replicate averaging HyPhy comparative selection OpenMS MetaProSIP proteomics MAKER genome annotation Post-assembly bacterial QC Fragment docking and scoring Haploid WGS paired-end variants Long-read assembly polishing Single-cell pseudobulk edgeR VGP1 HiFi k-mer profiling Metagenomic sequencing assembly Tuberculosis variant analysis ATAC/CUT&RUN consensus peaks Viral paired-end consensus RNA-seq QC, mapping, counting Machine-learning clustering Somatic variant and CNV discovery ChIP-seq paired-end consensus peaks ChIP-seq single-end consensus peaks MAG taxonomy annotation SARS-CoV-2 ONT ARTIC variation SARS-CoV-2 variation reporting Metagenomic genes catalogue Hi-C contact map for curation Tn-seq essential-gene detection MAG binning evaluation Influenza consensus and subtyping Generic variation reporting VGP5 HiFi trio-phased assembly VGP6b haplotype duplicate purging Metatranscriptomics Single-cell filtering and exploration
Tools Depth Inputs Asrts 2 5 4 2 4 8 7 8 10 13 2 10 10 9 14 18 22 9 3 16 17 17 12 21 14 24 20 12 26 28 12 21 15 22 18
3 4 4 3 5 7 4 6 8 11 9 11 9 5 6 15 12 6 4 16 14 14 19 13 17 18 17 21 14 32 19 11 13 9 18
2 2 3 4 5 2 5 1 4 6 2 1 5 12 5 3 6 6 3 5 3 3 4 3 5 2 5 5 4 6 1 10 6 2 1
6 5 4 2 4 0 0 16 0 1 0 0 0 20 8 7 0 34 9 0 7 7 0 0 2 13 19 3 0 0 0 8 10 6 4
Table 8: Test35 tasks used for held-out BioWorkflow Bench evaluation. Tools, Depth, Inputs, and Asrts follow the same definitions as Table 7.
Doc Project
Main Coverage
Galaxy Hub / UseGalaxy Platform operation, histories, datasets, quotas, sharing, and API overview. Galaxy Core REST objects, tool schema, jobs, workflows, invocations, datatypes, and provenance. BioBlend Python API for histories, datasets, tools, jobs, workflows, import, invoke, and monitor. gxformat2 YAML workflow authoring, graph validation, and conversion to Galaxy .ga. Planemo Workflow tests, test YAML, assertions, invocation tracking, and output checks. IWC Expert Galaxy workflow packages, gold graphs, tests, metadata, and reproducibility conventions. GTN Galaxy tutorial workflows, data links, topic material, examples, and biological explanations.
Repository galaxy-hub galaxy bioblend gxformat2 planemo iwc training-material
Table 9: P0 Galaxy documentation sources used for workflow execution, authoring, testing, and benchmark construction.
C
Prompts and Tactics Evolution
This appendix expands the training-time prompt structure and the evolution of the tactic library. The purpose is to make the method reproducible at the level of agent contracts: what the solver is allowed to see, what the reviewer can inspect, and how the updater converts public process evidence into reusable tactic files. The three prompts are not independent chat templates. Together they form a pipeline: the solver produces a Galaxy execution trajectory, the reviewer separates private evaluation analysis from public training feedback, and the tactic updater writes gated library patches from the public evidence. Figure 6 shows the solver/inference prompt. Its most important role is to define the visibility boundary and the required operating loop. The solver is instructed to work only inside the run directory, use the configured Galaxy backend, read the sandbox curriculum and allowed documentation, discover live tool schemas through BioBlend, construct gxformat2 workflows, run local checks, import and invoke workflows, and package provenance. The prompt deliberately does not expose gold workflows, exact rubrics, hidden assertions, or benchmark repository paths.
solver/inference prompt You are the BioWorkflow Galaxy agent. You run locally through Codex CLI using model gpt-5.5 with xhigh reasoning. Your execution backend is {galaxy_url}. Your control surface is Python, the BioBlend API client, gxformat2, Planemo, and a Jupyter notebook. Hard constraints: - You may only use files under this run directory and the explicit paths named in {policy}. - Do not read any gold .ga, exact rubric, or benchmark tests. - Do not access IWC, GTN, task repositories, answer repositories, search engines, or dataset pages not explicitly listed in data_manifest.json. - Treat data_manifest.json as the authoritative task input list. - Data transport policy: when a task input has an explicit download_url, prefer UseGalaxy server-side URL ingestion into the task history... - Do not print or save the Galaxy API key. Load it from environment variables only. - GALAXY_URL is set to {galaxy_url}. Use that configured backend for live schema discovery, data staging, workflow import, invocation, and job polling. - {network_instructions} Available helper commands: notebook_cli init {workspace/agent.ipynb}; notebook_cli append ... –kind code –file cell.py; notebook_cli run-cell ... CELL_INDEX –kernel bioworkflow-galaxy –cwd {workspace}; ... Your required workflow: 1. Create and maintain {workspace/agent.ipynb}. Prefer run-cell; make Galaxy cells idempotent; treat output/run_summary.json and results/run_summary.json as canonical live-state pointers. 2. Inspect README.md, catalog.md, and relevant CURRICULUM_INDEX.md files before live UseGalaxy submission. 3. Mine sandbox documentation for Galaxy, BioBlend, gxformat2, Planemo, notebook, and UseGalaxy lifecycle procedures. 4. Use BioBlend to verify the Galaxy connection and discover relevant tools/data interfaces. 5. Inspect tool schemas with gi.tools.show_tool(..., io_details=True). 6. Record tool IDs, input names, output names, and graph assumptions before workflow import. 7. Build the DAG workflow by discovery; run local checks; submit only after checks pass. 8. Debug with import errors, invocation/job states, dataset states, and downloaded small logs. 9. Save provenance, assertion trace, and final deliverables under the output/results directories. ## Shared sandbox curriculum Use the curriculum for BioBlend API usage, gxformat2 templates, Planemo/local check interpretation, UseGalaxy lifecycle, Galaxy tool schema discovery, notebook operations, and provenance/report packaging. Treat visibility labels as policy... ## Tactics-training discovery rule Infer candidate tool families from the biological task statement; search only allowed sandbox docs and live configured-Galaxy tool catalog; inspect exact tool schemas before wiring a DAG; use notebook experiments, local checks, Galaxy feedback, and trajectory writing as environment signals. ## Task description {task} ## Data manifest {data_manifest} ## Expected result schema Schema of output types and qualitative checks, not hidden gold. ## Tactics library Use these tactics when deciding how to write Galaxy API code, construct gxformat2, debug Galaxy errors, and manage the UseGalaxy lifecycle. {tactics} {controller_hint_section}
Figure 6: Source-faithful outline of the solver/inference prompt.
reviewer prompt You are the BioWorkflow TaskLevelLLMReviewer. Review every rollout for one benchmark task. You are a private evaluator and may inspect the run directories, private evaluator directories, gold workflows, gold tests, rubrics, programmatic evaluation features, notebooks, Codex event logs, tool-schema probes, local checks, Galaxy API traces, and result files. Task metadata: {json.dumps(task.to_json(), indent=2)} Rollout records: {json.dumps(records, indent=2)} Reviewer operating protocol: - Start by reading {context_manifest}. It is a curated file manifest for rollout and private-evaluation artifacts. - Do not run broad discovery commands such as find, rg –files, ls -R, or recursive directory walks. - Use targeted reads against paths from the manifest: sed -n, head, tail, python -m json.tool, or small Python snippets that open explicitly listed files. - If a file is omitted but genuinely needed, inspect only one named subdirectory from one rollout with a hard cap of 50 path entries. - Prefer results/run_summary.json, output/run_summary.json, results/assertion_trace.json, private evaluator JSON/YAML, and the final Codex message before large event logs or notebooks. Write two files: 1. Private report: {private_report}. This may mention private gold details, exact graph differences, assertion details, missing gold branches, and rollout-specific private comparisons. Compare rollouts against each other and against the gold workflow/tests. Separate process-quality failures from final-answer failures. 2. Public sanitized feedback: {public_draft}. This will be gate-checked and may be shown to the tactics updater. Do not include exact gold step IDs, tool versions, assertions, private file paths, output values, test snippets, repository paths, task item IDs, source URLs, checksums, or case-identifying strings. Name the controller mode exactly from the run summaries... Include task-family-level and process-level lessons only when supported by observed trajectories. Do not modify solver run files, private eval files, or tactics checkpoints.
Figure 7: Source-faithful outline of the reviewer prompt.
The reviewer prompt in Figure 7 is broader because the reviewer is part of the training infrastructure, not the solver. It may inspect private evaluator artifacts and gold comparisons in order to diagnose why a rollout succeeded or failed. However, it must write two outputs: a private report for analysis and a sanitized public feedback draft for training. This split is important because the tactic updater must not receive hidden gold details; it should learn general process lessons such as tool-schema mismatch, collection wiring, job-state handling, or artifact packaging failures.
tactic updater prompt You are the BioWorkflow TacticUpdaterAgent. Your job is to propose a linked-tactics patch bundle from public training signals only. A tactics checkpoint is a skill library: multiple focused tactic files connected by an index and cross-links. It must not collapse a whole stage into one omnibus reflection file. Use this patch shape: - Treat the tactics checkpoint as a maintained linked skill library, not an append-only reflection log. - Decide the library edit yourself from public evidence and current tactics: add, update, delete, rename, merge, deprecate, reorganize, or leave unchanged. - Do not target a fixed number of files. - Keep INDEX.md and topic indexes consistent when retrieval cues, links, file paths, or load order change. - Prefer topic directories: api/; workflow_authoring/; execution/; repair/; verification/; task_families/; ... You may read: - current tactics: {current_tactics} - this public group summary embedded below - public trajectory summaries under {proposal_dir/public_trajectories} - public task-level LLM review summaries under {proposal_dir/public_task_reviews} You must not use private evaluator files, gold workflows, gold tests, original benchmark repository paths, search engines, or task-specific hidden data. Write proposed tactic files under: {proposal_dir/files} Use repository-relative paths such as repair/usegalaxy_collection_wiring.md, workflow_authoring/gxformat2_terminal_outputs.md, verification/reference_artifact_contract.md, task_families/rnaseq_velocity.md, or INDEX.md. Only Markdown files are allowed. Also write {proposal_dir/proposal_manifest.json}, with changes containing path, action, new_path, rationale, and public evidence. Each active tactic file must include activation, procedure, termination, failure modes, verifier expectations, links to related tactics, and evidence. Do not write case-specific rescue hints. Convert observed failures into general, reusable procedures. Extract a semantic group advantage for BioWorkflow tactics. Training unit: {task_id} Compare rollouts by process reward, not only final score. Identify which workflow-construction decisions, API usage patterns, repair actions, and lifecycle choices caused relative success or failure. Propose only linked tactic deltas with activation, procedure, termination, verifier evidence, and links to existing tactics. Contexts: {rollout_summaries}, {group_summary}, {trajectory_context}, {task_review_context}.
Figure 8: Source-faithful outline of the tactic updater prompt.
Figure 8 shows the tactic updater prompt. The updater treats the tactic checkpoint as a maintained linked library rather than an append-only reflection log. It may add, update, delete, rename, merge, or deprecate Markdown tactics, but every active tactic must include activation conditions, procedures, termination checks, failure modes, verifier expectations, related links, and public evidence. This is where the method differs from prompt-only evolution: the update target is a structured process memory, not one global instruction.
Checkpoint Complexity
Files Tokens Main lesson
seed
n/a
8
batch1
Small 4; medium 2
13
batch2
Medium 6
18
batch3
Medium 2; long 2; xlong 2
23
batch4
Medium 2; long 1; xlong 3
28
6,669 Initial generic tactics for BioBlend access, gxformat2 authoring, lifecycle discipline, and verification. 12,412 Early live failures become cross-cutting graph, collection, terminal-repair, timeout, and chromatin contracts. 19,070 Adds terminal semantic checks and medium-task family contracts for RNA-seq, pseudobulk, decontamination, and variant/report workflows. 27,102 Generalizes from long/xlong tasks into mapped scalar validation, chemistry, DE, molecular dynamics, MAG, assembly QC, and ARTIC/variant updates. 33,700 Adds domain contracts for the remaining difficult families: Hi-C, HyPhy, isoform switching, Scanpy clustering, purge-dups, and ATAC-specific chromatin details.
Table 10: Tactics Evolution. Files counts Markdown files, Tokens is the approximate tactic-library token count, and Complexity follows the curriculum progression, with Tiny normalized to Small.
Table 10 summarizes the resulting library growth. The seed checkpoint contains a small set of general API, workflow-authoring, lifecycle, and verification tactics. After curriculum training, the process-reward setting expands into repair tactics and task-family contracts, while outcome-only training grows more slowly and remains concentrated on generic completion and biology triage. This table is therefore the quantitative counterpart to the prompt pipeline above: process feedback changes what kind of memory is written.
D
Case Study: XLong Hi-C Workflow
This appendix expands the xlong Hi-C case discussed in Section 4. The goal is not to add another leaderboard result, but to inspect how the learned tactics affect a live Galaxy trajectory. The case is useful because it requires long-horizon software interaction: the agent must reason about assembly curation, Hi-C alignment, contact-map generation, Galaxy tool schemas, workflow import and invocation, failure repair, and final artifact collection. D.1
Case Selection and Evidence
We analyze the held-out Hi-C contact-map task for assembly manual curation. The task is xlong, belongs to the same test35 split used in the main evaluation, and exposes the main failure modes of workflow agents: missing tool wrappers, datatype and collection wiring, invocation failures, optional diagnostic branches, and output-family accounting. The representative run uses the batch-4 tactic checkpoint. Its execution trace contains policy checks, tactic retrieval, notebook cells, live Galaxy API calls, workflow draft creation, graph upload, invocation, repair attempts, and final evidence packaging. The visibility boundary remains the same as in training. The solver sees only the task bundle, public documentation, live Galaxy responses, and learned tactics. It does not see hidden gold workflows, exact private tests, or benchmark answer paths. This makes the case a process analysis of tactic use rather than evidence of gold-workflow access. D.2
Tactics Aligned to Execution Turns
Figure 9 aligns selected tactic elements with execution trace milestones. The left side contains tactic-level guidance such as reading visibility policy, deriving output-family obligations, using live Galaxy schema discovery, checking gxformat2 before import, and preserving repair provenance. The right side shows the corresponding trajectory events. The important pattern is that the agent does not simply reason longer. It follows a more direct operational route: establish a role contract, inspect schemas before wiring tools, upload a draft graph, use Galaxy failure state as typed feedback, and apply bounded repairs.
Activated tactics
Agent execution trace
Lifecycle hygiene; policy discipline
Records allowed docs and restricted sources before any Galaxy call; avoids gold workflow access and writes the doc-mining report.
Tactic selection; Hi-C and assembly contracts
Loads Hi-C, assembly QC, semantic-graph, live-schema, and localcheck tactics before planning.
BioBlend bootstrap; notebook state
Creates an idempotent notebook, output directories, run summaries, and a public role contract.
Live schema and artifact evidence
Queries live UseGalaxy schemas; when narrow search misses tools, switches to a full live tool catalog and filters locally.
Role contract before graph writing
Maps task prose to obligations: haplotypes, gap/telomere tracks, Hi-C statistics, Pretext maps, and coverage outputs.
gxformat2 local check loop
Writes gxformat2, converts to native workflow, lints, and patches output declarations from live schemas before import.
Collection wiring; invocation hygiene
Stages server-side URLs, creates Hi-C and PacBio collections, imports the workflow, and invokes it in one history.
Terminal failure repair gate
Stops after terminal failure; preserves failed-job evidence from the legacy BWA-MEM wrapper instead of blind retrying.
Wrapper-specific bounded repair
Repairs BWA-MEM to minimap2, then BWA-MEM2, then removes optional PretextSnapshot after schema-specific failure.
Semantic smoke audit; final packaging
Final repair completes 22 Galaxy jobs and 17 workflow outputs; downloads artifacts, writes assertion trace, and checks for leakage.
Figure 9: Tactics-use timeline for the representative xlong Hi-C task. The left lane shows activated process-memory tactics; the right lane shows aligned execution steps and concrete Galaxy/workflow evidence.
The first major transition is from biological prose to a workflow role contract. The agent identifies curation assembly construction, assembly statistics, gap and telomere tracks, Hi-C raw and deduplicated alignments, Pretext contact maps, and coverage outputs before writing the executable graph. This is the intended use of tactics: they provide reusable verifier expectations and software-operation procedures, not stored answers for a specific benchmark case. D.3
Repair Behavior
The trace also illustrates why process rewards are more useful than final scores alone. A failed Galaxy invocation is not merely a negative outcome. It contains typed evidence: which job failed, which wrapper emitted the error, which input or parameter was implicated, and which downstream branch should be repaired. In this case, the agent uses Galaxy state to stop polling, inspect the failed job, check live schemas, patch only the implicated branch, rerun local workflow checks, and re-invoke. Several baseline agents consume many more tokens without reaching the same repair depth because they do not convert platform feedback into bounded workflow edits. D.4
Constructed Galaxy Workflow
The final workflow screenshot in Figure 10 is included as a concrete example of the workflow graph that the agent constructs and executes on the usegalaxy backend. The graph is not a perfect reproduction of the public expert workflow; it is a compact executable reconstruction produced under the solver visibility boundary. It stages haplotype FASTA inputs, Hi-C paired-read collections, and long-read inputs, then combines assembly preparation, statistics, alignment, contact-map generation, and coverage-output branches. This case should therefore be interpreted at two levels. At the mechanism level, learned tactics make the trajectory more auditable and repairable: the agent reads relevant procedures, uses live schema evidence, uploads an executable graph, diagnoses errors, and keeps final outputs separate from superseded failed attempts. At the benchmark level, xlong workflow recovery remains difficult. The remaining errors show that agents still need stronger branch-level topology recovery and optional-output reasoning, especially when expert workflows contain diagnostic or reporting branches that are not necessary for terminal execution but matter for exact biological matching.
Figure 10: Representative xlong Galaxy workflow constructed by the post-training PRTE Agent. The workflow is the final Hi-C contact-map workflow for assembly manual curation, captured from the usegalaxy.eu website.