From Sensors to Insight: Rapid, Edge-to-Core Application Development for Sensor-Driven Applications

From Sensors to Insight: Rapid, Edge-to-Core Application Development for Sensor-Driven Applications Komal Thareja* , Anirban Mandal* , Ewa Deelman‡ *

arXiv:2605.02859v1 [cs.DC] 4 May 2026

‡

Renaissance Computing Institute, University of North Carolina at Chapel Hill, NC, USA Information Sciences Institute, University of Southern California, Marina del Rey, CA, USA

Abstract—Scientists increasingly rely on sensor-based data, yet transforming raw streams into insights across the edge-to-cloud continuum remains difficult. Provisioning heterogeneous infrastructure and managing execution on emerging platforms like Data Processing Units typically requires cross-domain expertise, creating significant barriers to rapid prototyping. This paper introduces an experience-driven methodology for the rapid development of sensor-driven applications. By combining pattern-based workflow engineering with AI-assisted development—implemented via Pegasus on the FABRIC testbed—we utilize an existing Orcasound hydrophone workflow as a reusable template. We introduce a pattern-based engineering methodology to generate and refine workflows for air quality, earthquake, and soil moisture monitoring. Furthermore, we show how these abstract structures are extended to edge resources through modular configuration and placement. Our evaluation focuses on user productivity and practical lessons rather than peak performance. Through these case studies, we illustrate how AIassisted, pattern-based development lowers the entry barrier for non-experts and enables iterative exploration of sensor-driven applications across distributed infrastructures. Index Terms—Sensor-based applications, Edge-to-core computing, Scientific workflows, Programmable infrastructure, AIassisted development, User productivity

I. I NTRODUCTION Sensor-driven applications are a cornerstone of cutting-edge research in environmental monitoring, smart infrastructure, marine biology, and cyber-physical systems. These applications increasingly demand end-to-end processing pipelines that transform raw sensor data into actionable insight through a combination of edge processing, distributed analytics, and cloud-scale computation. Although sensing hardware, networking, and analytics frameworks have advanced rapidly, the development of integrated edge-to-core applications remains complex, error-prone, and time-consuming. A key challenge lies in bridging the gap between sensing systems and scalable computation—what we term the “blank page bottleneck.” Traditionally, moving from a scientific question (e.g., “How does local air quality impact respiratory health trends?”) to a production scientific workflow capable of generating data to answer this questions, requires deep infrastructure expertise. Instead of exploring their data, scientists often find themselves bogged down with execution mechanics like workflow formats, container orchestration, and infrastructure provisioning. For many practitioners, particularly domain scientists and IoT application developers, this

breadth of required knowledge presents a significant barrier to rapid prototyping and deployment. Workflow management systems such as Pegasus [1] and programmable infrastructures like FABRIC [2] offer powerful abstractions for managing complex distributed applications, including emerging hardware accelerators such as Data Processing Units (DPUs) [3]. However, effectively leveraging these tools requires the understanding of configuration models, deployment options, and infrastructure interfaces—specifically for sensor-driven or edge-centric applications [4]. We address this challenge through pattern-based engineering with AI assistance. Rather than starting from scratch, users provide an AI assistant (e.g. Claude [5]) with an existing Pegasus workflow pattern and describe their new use case. The AI adapts the pattern—retaining dependency logic while swapping domain-specific components—producing a working first draft. This shifts development from code-first to intentfirst: scientists describe their data sources, analysis steps, and expected outputs in plain English, and AI generates production-ready workflow code [6]. Grounding AI in existing patterns prevents hallucinations and ensures that the generated code follows established best practices. We operationalize this approach through a 5-step development loop that compresses days of workflow creation to minutes: (1) Describe Science—define data, analysis steps, and outputs in plain English; (2) Ground with Context—provide the AI assistant with a proven Pegasus example; (3) Generate Skeleton—AI produces working Python code with task definitions, I/O declarations, and dependency graphs; (4) Refine— human-in-the-loop iteration to adjust resource requirements and parallelization; (5) Scale—deploy to the edge, clusters or clouds without redesign. We demonstrate this methodology through four representative scientific workflows spanning diverse sensor domains and execution patterns: air quality forecasting using OpenAQ [7] data with LSTM models, earthquake analysis with USGS [8] seismic data and branching analytical pipelines, Orcasound hydrophone [9] processing for Orca whale detection with edge-to-cloud computation including DPU offload, and soil moisture prediction [10] for precision agriculture. These workflows are deployed on FABRIC infrastructure using FABlib [?] for provisioning, HTCondor [4] for job scheduling, and Pegasus for workflow orchestration.

This paper makes the following contributions: We present a pattern-based engineering methodology for rapid edge-to-core application development, demonstrating how AI assistance combined with existing workflow tools (Pegasus/HTCondor) and infrastructure platforms (FABRIC/FABlib) accelerates development of sensor-driven scientific applications. • We describe a 5-step development loop that shifts workflow construction from code-first to intent-first, enabling scientists to describe analyses in plain English while AI generates production-ready Pegasus workflows. • We provide practical insights from four case studies spanning air quality, seismology, marine bioacoustics, and agriculture—deployed across edge-to-core configurations including BlueField-3 DPUs—demonstrating flexibility in execution placement and reduced development effort. • We articulate why Pegasus and AI are synergistic: the explicit, readable, composable, and execution-agnostic nature of Pegasus workflows makes them ideal targets for LLM-assisted generation and adaptation.

•

The remainder of this paper is organized as follows. Section II presents background and related work on scientific workflows, programmable research infrastructure, edge-tocore computing, and AI-assisted development. Section III describes our pattern-based, AI-assisted methodology for constructing sensor-driven workflows on programmable infrastructure. Section IV presents a sequence of case studies demonstrating progressive workflow reuse, incremental development, and extension to edge resources. Section V provides a user-centric evaluation focusing on iteration effort, debugging experience, and time-to-first-execution. Section VI presents our conclusions and directions for future work. II. BACKGROUND AND R ELATED W ORK We briefly review relevant background and position our work with respect to prior research in scientific workflow management, programmable research infrastructure, edge-tocore computing, and AI-assisted software development. Scientific Workflow Management Systems. Scientific workflow management systems address the complexity of coordinating multi-stage computations across distributed resources. Systems such as Pegasus [1], Makeflow [11], Kepler [12], NextFlow [13], and Airflow [14] allow users to express applications as workflows with explicit task dependencies, enabling automated data movement, job scheduling, and fault handling. Pegasus is particularly well suited for distributed scientific applications due to its separation of abstract workflow descriptions from execution environments. Users define workflows as directed acyclic graphs (DAGs) independent of infrastructure, while Pegasus handles planning, data staging, retries, and provenance tracking at execution time. Pegasus commonly integrates with HTCondor [4], which provides a flexible execution substrate capable of managing heterogeneous resources through declarative scheduling constraints.

Prior work has demonstrated the scalability, portability, and reliability benefits of workflow systems in high-performance and distributed computing environments [15]–[17]. However, constructing and configuring workflows remains a significant barrier for new users, especially when workflows span multiple execution sites or involve heterogeneous resources such as edge devices or accelerators. Programmable Research Infrastructure. Programmable research infrastructures provide researchers with fine-grained control over compute, storage, and networking resources. Platforms such as FABRIC [2], Chameleon [18] , and CloudLab [19], enable users to deploy custom topologies, experiment with advanced networking features, and evaluate distributed systems under realistic conditions. FABRIC extends these capabilities by offering a geographically distributed testbed with support for heterogeneous hardware, including GPUs, FPGAs, SmartNICs, and DPUs. Access is provided through programmable APIs and notebooks, allowing infrastructure to be provisioned and reconfigured as code. While such platforms enable powerful experimentation, effectively leveraging them for scientific applications often requires expertise in infrastructure configuration, networking, and system integration. Our work operates within this context, using programmable infrastructure not as an end in itself, but as a substrate on which sensor-driven workflows can be deployed and evaluated. Edge-to-Core Computing. Edge computing distributes computation closer to data sources to reduce latency, conserve bandwidth, and improve responsiveness [20]. In sensor-driven and IoT applications, edge processing is often combined with cloud-based analytics, forming an edge-to-core continuum. Prior research has explored task placement, data offload strategies, and resource-aware scheduling across this continuum. Recent hardware trends, including programmable SmartNICs [21] and DPUs [3], further blur the boundary between networking and computation by enabling data processing at the network edge. These platforms have been used to accelerate I/O-intensive tasks and offload preprocessing from host CPUs. However, integrating such resources into end-to-end sensor application workflows typically requires custom orchestration logic or specialized frameworks. In contrast, our approach demonstrates how existing workflow systems can incorporate edge devices and DPUs using standard scheduling and placement mechanisms, avoiding bespoke edge orchestration layers. AI-Assisted Software and Workflow Development. Large language models have recently been applied to software development tasks such as code generation, debugging, and API exploration. Tools including GitHub Copilot, ChatGPT, Claude, and Gemini have been shown to improve user productivity, particularly for boilerplate generation and error diagnosis [6]. Several recent efforts explore the use of AI for infrastructure-as-code generation and workflow specification. However, many such approaches treat AI-generated scripts

Fig. 1: Pattern-based, AI-assisted development loop for sensordriven edge-to-core applications.

with a scientific intent—data sources, analysis steps, and expected outputs—expressed in natural language rather than lowlevel execution mechanics; (2) Pattern reuse over greenfield design: New applications are derived by adapting existing, validated workflow patterns rather than starting from an empty specification, mitigating the “blank page bottleneck.”; (3) Separation of concerns: Workflow logic, execution placement, and infrastructure provisioning are explicitly separated. Abstract workflows remain execution-agnostic, while placement decisions are expressed in configuration and scheduling layers; (4) Human-in-the-loop AI assistance: AI tools assist with generation, adaptation, and debugging but do not replace workflow engines or scheduling systems; users retain control and validate changes through execution. A. The Five-Step Development Loop

as standalone artifacts, limiting portability, provenance tracking, and fault tolerance. Moreover, systematic studies of AIassisted development for scientific workflows—especially in edge-to-core sensing contexts—remain limited. Our work differs in two key ways. First, AI assistance is explicitly grounded in existing, validated workflow patterns rather than unconstrained generation. Second, AI is used to assist workflow construction and refinement within mature workflow systems, preserving their benefits while reducing the learning curve for new users. Positioning. In summary, prior work has established the value of workflows, programmable infrastructure, edge computing, and AI-assisted development independently. However, there is limited empirical guidance on how these components can be combined to support rapid, iterative development of sensordriven applications across the edge-to-core continuum, particularly from the perspective of user productivity. This paper addresses this gap by presenting an experiencedriven methodology that integrates AI-assisted development with pattern-based workflow engineering on programmable infrastructure. Rather than proposing new workflow abstractions or scheduling algorithms, we focus on practical lessons learned from building and extending real applications, providing actionable insights for researchers and practitioners working at the intersection of sensing, workflows, and distributed systems. III. M ETHODOLOGY This section describes our methodology for rapidly developing sensor-driven, edge-to-core scientific applications by combining pattern-based workflow engineering with AI-assisted development, implemented using Pegasus, HTCondor, and programmable infrastructure on FABRIC. The methodology is derived from practical experience building and deploying realworld sensor workflows and is designed to reduce user effort while preserving the rigor, portability, and reproducibility of workflow-based execution. Figure 1 summarizes the five-step, AI-assisted development loop used to construct, refine, and deploy sensor workflows across edge-to-core resources. Our methodology is guided by four design principles: (1) Intent-first development: Application development begins

Our approach follows an iterative five-step loop that compresses workflow development from days to hours: Step 1: Describe the science. Scientists describe the application intent in plain language, including sensor data sources (e.g., APIs or object storage), processing stages (preprocessing, feature extraction, inference), and outputs (forecasts, alerts, visualizations). Infrastructure specifics are intentionally omitted. Step 2: Ground with an existing workflow pattern. Instead of generating from scratch, users provide a reference Pegasus workflow that captures a similar structure (e.g., ingest → process → predict → visualize; branching analyses; or edge-to-cloud splits). The AI assistant is instructed to preserve the dependency structure while adapting task semantics, data access, and executables. Step 3: Generate a production-ready workflow skeleton. Given the grounded pattern, the AI assistant produces executable Pegasus Python code [22] containing: (i) task definitions, (ii) explicit input/output declarations (Replica and Transformation catalogs), (iii) dependency relationships (DAG topology), and (iv) parameterized loops over sensors, regions, or time windows. Step 4: Human-guided refinement. Scientists iteratively refine resource sizing (cores/memory), containerization, and parallelization granularity. AI assistance is used to interpret Pegasus planning failures, HTCondor logs, and configuration issues, but final edits are reviewed and validated by the user. Step 5: Scale and re-target execution. After local validation, the same abstract workflow is scaled or re-targeted to different execution environments without redesign. Execution placement is controlled through Pegasus catalogs and properties, enabling the same workflow to run across laptops, clusters, and heterogeneous edge-to-core deployments. B. Workflow Construction and Execution Model All applications are represented as Pegasus DAGs with explicit data dependencies. This representation is particularly compatible with AI-assisted development because it is explicit, readable, composable, and execution-agnostic. Pegasus plans

the abstract workflow onto available resources, while HTCondor performs job dispatch and placement. For edge-to-cloud workflows, HTCondor requirements (ClassAds) steer tasks to appropriate nodes (e.g., DPU-enabled edge workers vs. CPU-only cloud workers) [23]. The ClassAds are written automatically by Pegasus. Containerized codes further decouple workflow logic from runtime environments, improving reproducibility and portability across heterogeneous sites. C. Infrastructure Provisioning for Edge-to-Core Deployments Infrastructure is provisioned programmatically using FABlib. A typical deployment includes: (i) a submit node hosting Pegasus and the HTCondor central manager, (ii) edge workers near data sources (optionally equipped with DPUs), and (iii) cloud/cluster workers for compute-intensive stages. Connectivity is established using FABRIC networking services, enabling reproducible and reconfigurable experimental environments. In workflows incorporating DPUs, I/O-intensive preprocessing (e.g., audio format conversion, feature extraction) is placed on DPU-attached ARM cores, while ML inference and aggregation execute on general-purpose compute nodes. D. Role of AI Assistance AI assistance is applied exclusively at development time to accelerate workflow adaptation, API exploration, boilerplate generation, and debugging—not workflow execution or scheduling. It serves as a productivity layer that lowers the barrier to using Pegasus/HTCondor and FABRIC while preserving provenance, fault tolerance, and portability. All prompts are documented in the repository’s README.md for reproducibility. IV. C ASE S TUDIES : PATTERN R EUSE AND AI-A SSISTED W ORKFLOW E VOLUTION We present our case studies as a progressive development narrative rather than isolated application examples. Consistent with our goals, the purpose of these case studies is not to evaluate peak application performance, but to examine how effectively our methodology supports rapid workflow construction, incremental refinement, and extension across domains and execution environments. We emphasize user productivity (time-to-first-workflow, iteration effort, and portability of the workflow pattern) and highlight where AI assistance reduced friction during development. Across all case studies, Pegasus workflows were developed and executed on a Pegasus/HTCondor environment deployed on the FABRIC testbed. We additionally extended selected workflow stages to edge resources, including FABRIC DPUs and Raspberry Pis, to demonstrate how edge devices can participate in end-to-end workflows without redesigning the workflow logic. A. Baseline Workflow Pattern: Orcasound as Starting Point The Orcasound hydrophone processing workflow served as the foundational pattern for subsequent workflow development. Importantly, this workflow was already available and

operational prior to this effort, and we used it as the reference implementation to ground AI-assisted workflow generation. Orcasound represents a canonical sensor-driven analytics structure common across multiple domains [9]: ingest → preprocess → transform → infer → aggregate. Concretely, this sensor-driven workflow ingests audio segments, converts them into analysis-ready formats, performs ML inference to detect Orca vocalizations, and aggregates predictions across sensors and time windows. We treat Orcasound not only as an application but as a reusable workflow pattern representative of many sensor-driven applications: its explicit dependency graph, containerized transformations, and separation of workflow logic from execution placement make it well suited for adaptation across other domains. B. Pattern Reuse Across Domains with AI Assistance Using Orcasound [24] as a reference pattern, we generated three new sensor workflows—air quality analysis [25], earthquake analysis [26], and soil moisture prediction [10]—by preserving the high-level dependency structure while adapting domain-specific tasks, data sources, and parameters. Rather than manually designing new workflows from scratch, we followed an incremental prompting strategy: (i) provide the AI assistant like Claude (Opus 4.5 Model) with the Orcasound Pegasus workflow as a concrete template, (ii) describe the new scientific goal and data source in natural language, and (iii) instruct the assistant to retain the workflow structure while swapping domain components (ingestion logic, preprocessing steps, model/inference stages, and outputs). This grounded approach enabled rapid creation of runnable Pegasus workflow skeletons and reduced trial-and-error in configuration and dependency specification. C. Air Quality Workflow: Incremental Development Trajectory The air quality workflow illustrates how AI-assisted development supports stepwise workflow evolution from a simple, working pipeline to a richer ML-based workflow, without destabilizing earlier stages. Figure 2a shows the resulting workflow structure after incremental extensions, highlighting how new stages were added without restructuring the existing dependency graph. 1) Initial baseline pipeline (ingest–analyze–detect anomaly): The starting point for this workflow was an existing Orcasound acoustic monitoring template [9], which had previously been expressed as a Pegasus workflow capturing a simple ingest–process–detect pattern. Rather than designing the air quality workflow from scratch, we provided this template to the AI assistant as a structural reference and expressed a new scientific intent: monitoring particulate matter levels in air quality data instead of detecting anomalous acoustic signals. The assistant mapped this intent onto the existing workflow skeleton by identifying analogous stages—data ingestion, signal analysis, and anomaly detection—and adapting them to the new domain.

(a) Air quality workflow: ingestion, feature engineering, modeling, delivery.

(b) Representative air quality forecast and anomaly detection output.

Fig. 2: Air quality workflow structure and representative analytical output. In this phase, the input data were sourced solely from Ope- how AI assistance can significantly reduce the effort required nAQ. The AI assistant generated a Pegasus workflow that (i) to diagnose and resolve multi-layered workflow errors. fetched particulate matter measurements for a specified region The same human-in-the-loop, AI-assisted methodology natand time window, (ii) performed basic aggregation/cleaning, urally extends to scaling workflows across larger task counts and (iii) detected anomalous readings using lightweight statis- and execution infrastructures. As workflows grow in size, tical rules (e.g., thresholds or rolling statistics). This baseline complexity, and geographic distribution, failures increasingly provided a fast time-to-first-execution milestone and created a arise from resource heterogeneity, data movement, schedulstable foundation for later extensions. ing policies, and site-specific execution environments rather 2) Extending to ML-based forecasting: After validating the than from application logic alone. In this setting, the AI baseline pipeline, we prompted the AI assistant to extend the assistant can be used to iteratively reason about performance workflow with ML-based forecasting. The assistant introduced bottlenecks, resource constraints, and execution failures by additional stages for feature preparation, model training (or correlating workflow structure with Pegasus planning output, model update), and prediction while preserving upstream HTCondor scheduling behavior, and site-level execution logs. ingestion and preprocessing logic. Crucially, this extension Incremental scaling—first increasing task parallelism, then required no redesign of the existing pipeline structure; it introducing additional execution sites or containers—allows primarily involved inserting new tasks and dependencies and stable workflow versions to be preserved while new scalingupdating transformation definitions and resource requirements. related issues are isolated and resolved. This approach enables Figure 2b illustrates a representative forecast artifact produced workflows to evolve from small, single-site executions to large-scale, multi-site deployments without requiring disrupby the workflow after the ML-based extension. 3) Adding new data sources from SAGE: We further ex- tive redesign, reinforcing the role of AI assistance as a tool tended the workflow by adding ingestion steps for environmen- for managing complexity in distributed scientific workflows. tal measurements from the NSF SAGE sensor network [27]. This required adapting data access logic and metadata handling at ingestion time while keeping the downstream analysis structure consistent. The resulting workflow demonstrates how pattern-based workflow engineering supports evolution from a single-source pipeline (OpenAQ) to a multi-source workflow (OpenAQ and SAGE) with minimal disruption. 4) Debugging and Iterative Refinement: Early executions of the generated workflows exposed realistic configuration and runtime errors common in distributed, containerized environments. For example, the air quality workflow initially failed during data ingestion due to missing OpenAQ API credentials inside the execution container, causing HTCondor jobs to enter a Held state with missing output files. Using the AI assistant, we traced the failure across Pegasus, HTCondor, and container logs, identified that environment variables were not being propagated into the container, and corrected the workflow configuration accordingly. Through this human-inthe-loop debugging process, the air quality workflow reached stable execution after seven execution attempts, illustrating

D. Earthquake and Soil Moisture Workflows The earthquake and soil moisture workflows were generated by reusing the already validated air quality workflow as their immediate reference pattern, rather than reverting back to the original Orcasound workflow. This reflects a realistic workflow development process in which previously built and debugged pipelines become templates for subsequent applications. For the earthquake workflow, the air quality pipeline was adapted by replacing the ingestion stage with USGS seismic event feeds and introducing conditional branching to trigger additional analysis for high-magnitude events. Figure 3 shows the earthquake workflow and a representative analytical output generated through AI-assisted, pattern-based workflow reuse. For the soil moisture workflow, the same pipeline structure was reused, with modifications to ingest in-situ soil sensor measurements and external weather data, followed by feature joining and regression-based prediction. Figure 4 shows the soil moisture workflow and a representative prediction artifact produced by the workflow.

(a) Earthquake workflow: ingestion, analysis, aggregation.

(b) Representative aftershock analysis output.

Fig. 3: Earthquake workflow structure and representative analytical output.

(a) Soil moisture workflow: ingestion, feature joining, prediction.

(b) Representative soil moisture prediction output.

Fig. 4: Soil moisture workflow structure and representative analytical output. In both cases, the underlying workflow structure, execution analytics executed on cloud resources. This demonstrates that model, and deployment configuration remained largely un- heterogeneous edge devices can become first-class participants changed. AI assistance was used to translate domain-specific in end-to-end Pegasus workflows using standard scheduling intent into Pegasus task definitions and to ensure that new and execution mechanisms, again with no abstract workflow ingestion and analysis stages were correctly integrated into changes. the existing dependency graph. F. Summary of Observations E. Integrating Edge Resources: DPUs and Raspberry Pi After validating cloud-based executions, we tailored the target workflows to incorporate edge resources. This step is central to our edge-to-core narrative: rather than designing separate edge orchestration logic, we integrated edge resources into the same Pegasus-managed workflow execution model. 1) DPU-based edge offloading on FABRIC. For soil moisture workflow [10], I/O-intensive preprocessing stages were offloaded to DPUs taking advantage of these novel edge resources. Execution placement was controlled by Pegasus site mappings, allowing tasks to be routed to DPU-enabled nodes without modifying the abstract workflow. This enabled experimentation with alternative placements in the edge to cloud continuum while preserving workflow structure and content. 2) Raspberry Pis as edge participants To incorporate a representative IoT edge device, we configured a Raspberry Pi to participate in the workflow data processing by connecting it to the Pegasus execution environment on FABRIC for soil moisture workflow [10]. The Raspberry Pi performed data ingestion and lightweight preprocessing, while downstream

Across the case studies, we observed consistent trends aligned with our methodology goals: (i) pattern grounding accelerated time-to-first-workflow, (ii) incremental refinement (baseline → integrating ML steps → adding new data sources) was easier than greenfield development, (iii) AI assistance was most effective when adapting known patterns rather than generating workflows from scratch, and (iv) edge integration required minimal changes, primarily in execution placement and configuration rather than workflow restructuring. These findings motivate a user-centric evaluation focused on build/iteration effort, reproducibility, and portability rather than evaluating individual applications for peak workflow performance, which can be done by Pegasus. This progressive reuse pattern (orcasound → air quality → earthquake and soil moisture) mirrors realistic development practices and highlights how AI-assisted workflow generation compounds productivity gains across successive applications. V. E VALUATION : U SER -C ENTRIC P RODUCTIVITY Our evaluation focuses on user productivity and iteration effort rather than application performance. Specifically, we assess how AI-assisted, pattern-based workflow development

impacts (i) time-to-first-runnable-workflow, (ii) effort required to incrementally extend workflows, and (iii) effort required to debug and stabilize generated workflows in realistic execution environments. Importantly, this evaluation reflects the experience of a novice Pegasus user. Prior to this work, the primary exposure to Pegasus consisted of a single tutorial demonstrating how to run a basic workflow on NSF Access [28], [29]. There was no prior experience designing multistage workflows, configuring HTCondor pools, or integrating heterogeneous edge resources. This context is critical for interpreting the results presented below. A. Evaluation Methodology We evaluate user effort using the following measures: • Prompt iterations: the number of natural-language interactions required to generate or extend a workflow. • Execution attempts: the number of workflow executions required to reach stable, end-to-end completion. • Wall-clock development time: the elapsed time from initial workflow conception to stable execution. These measures capture both cognitive effort (understanding APIs, workflow structure, and execution semantics) and practical effort (debugging configuration and runtime issues), which are central to the usability of workflow systems for sensordriven applications. Prompt counts are reported only for the air quality workflow as a representative example; subsequent workflows exhibited similar or reduced prompting effort due to progressive reuse of validated workflow patterns. B. AI Tooling and Development Environment Most workflow code generation and adaptation was performed using Claude [5] (specifically Claude Opus 4.5), which was particularly effective for producing Pegasus workflow skeletons and adapting existing workflow patterns. However, due to token and usage limits encountered during extended development sessions, we also leveraged additional AI tools in practice. Specifically, ChatGPT (Codex) [30](GPT5.2) and Gemini [31](Gemini 3.0 Flash) were used opportunistically, most often during execution-time debugging when interpreting Pegasus planner output, HTCondor logs, and container runtime errors. We also experimented with the open-source Qwen3-Coder-30B [32] model and observed promising results for code generation tasks, suggesting that locally-hosted models may provide a viable alternative for teams with privacy or cost constraints. This multi-tool usage reflects a realistic development workflow in which users switch between AI assistants based on availability and task suitability, rather than relying on a single model. All workflows were deployed, executed, and validated on the FABRIC testbed. Infrastructure provisioning and configuration were performed using FABRIC notebooks and examples [33], which were also provided as contextual grounding to the AI assistant when generating code for: (i) deploying a Pegasus cluster, (ii) attaching and configuring FABRIC Data Processing Units (DPUs), and (iii) connecting external edge

devices, such as Raspberry Pi nodes, to the Pegasus-managed execution environment. C. Air Quality Workflow: Development Experience The air quality workflow serves as our primary evaluation example due to its incremental development trajectory and its role as a reference pattern for subsequent workflows. 1) Baseline workflow construction: Starting from the Orcasound workflow as a reference pattern, constructing the initial air quality baseline pipeline (ingest–analyze–detect anomaly) required approximately 3–4 prompts to the AI assistant. These prompts focused on adapting data ingestion logic for OpenAQ, defining basic aggregation tasks, and generating an executable Pegasus workflow skeleton. Although the generated workflow was syntactically correct, early executions surfaced realistic runtime and configuration issues typical of distributed, containerized environments. Resolving these issues required seven execution attempts, during which errors related to missing credentials, data staging, and container runtime assumptions were identified and corrected with AI-assisted debugging support. 2) Extending to ML-based forecasting: Once the baseline workflow reached stable execution, extending it with MLbased forecasting required an additional 3–4 prompts. These prompts resulted in new workflow stages for feature preparation, model training or update, and prediction, while preserving the existing ingestion and preprocessing logic. Because this extension reused an already validated workflow, the resulting pipeline stabilized more quickly, requiring only 2–3 execution attempts to reach successful end-to-end execution. This reduction in execution iterations illustrates the benefit of incremental refinement over greenfield development. 3) Adding SAGE data ingestion: Incorporating SAGE sensor data into the air quality workflow required 2–3 additional prompts to adapt ingestion logic and metadata handling. Testing and validation required 2–3 execution attempts, primarily to verify data access and schema alignment. Notably, this extension did not require restructuring the workflow, only modifications to ingestion tasks and configuration. D. End-to-End Development Time Across all workflows (air quality, earthquake analysis, and soil moisture prediction), the total development effort spanned approximately 4–5 days, corresponding to roughly 1–1.5 days per workflow. Assuming a standard research development cadence of approximately 6–8 focused hours per day, this corresponds to an estimated 24–40 total person-hours, or 8–12 hours per workflow. This time includes workflow generation, execution debugging, incremental extensions, and validation on distributed resources. Given the user’s novice status with Pegasus, this timeline suggests that AI-assisted, pattern-based development substantially lowers the barrier to entry for building non-trivial, multistage workflows. Without AI assistance, achieving comparable functionality would likely require significantly more time spent learning workflow abstractions, configuring execution environments, and diagnosing runtime failures.

E. Cross-Workflow Observations The development experience observed for the air quality workflow was representative of the subsequent earthquake and soil moisture workflows, which reused the already validated air quality pipeline as their immediate reference pattern. Across all workflows, we observed the following trends: • Rapid time-to-first-workflow: Runnable workflows were generated within a small number of prompts when grounded in an existing pattern. • Decreasing iteration cost: Later workflow extensions required fewer execution attempts due to inherited configuration and prior debugging. • Debugging dominates effort: Most iteration effort was spent resolving execution-time configuration issues rather than correcting workflow logic. • Compounding productivity gains: Progressive reuse (Orcasound → air quality → earthquake/soil moisture) reduced development effort for each successive workflow. VI. C ONCLUSIONS AND F UTURE W ORK This paper presented an experience-driven methodology for rapidly developing sensor-driven, edge-to-core applications by combining pattern-based workflow engineering with AIassisted development. Using Pegasus on the FABRIC testbed, we showed how validated workflow patterns can be incrementally adapted across domains and execution environments, enabling users to construct and stabilize non-trivial sensordriven workflows within a bounded timeframe. Across case studies in air quality analysis, earthquake processing, soil moisture prediction, and hydrophone-based audio analytics, we demonstrated that AI assistance is most effective when grounded in proven workflow patterns and applied to iterative refinement and debugging. Our evaluation highlights how progressive reuse compounds productivity gains and lowers barriers to developing complex distributed workflows. This work has limitations, including an evaluation focus on development effort rather than application performance and reliance on a single user’s experience. Additionally, configuring heterogeneous edge resources still requires domain expertise beyond current AI capabilities. These limitations motivate future work and exploration of tools like Kiso [34]. Future directions include extending the methodology to team-based and longer-lived workflows, incorporating execution feedback for automated adaptation, and integrating AI agents that proactively suggest Pegasus optimizations and placement strategies. We believe that that this approach offers a promising path toward more accessible and sustainable edgeto-core application development for the scientific community. R EFERENCES [1] E. Deelman et al., “Pegasus, a workflow management system for science automation,” Future Generation Computer Systems, vol. 46, pp. 17–35, 2015. [2] I. Baldin et al., “Fabric: A national-scale programmable experimental network infrastructure,” IEEE Internet Computing, vol. 23, no. 6, 2019. [3] NVIDIA, “BlueField-3: A high-performance DPU for data center infrastructure,” in Proceedings of the Hot Chips Symposium, 2022.

[4] D. Thain, T. Tannenbaum, and M. Livny, “Distributed computing in practice: The condor experience,” Concurrency and Computation: Practice and Experience, vol. 17, no. 2–4, pp. 323–356, 2005. [5] Anthropic, “Claude (anthropic),” https://www.anthropic.com/claude. [6] M. Chen et al., “Evaluating large language models trained on code,” arXiv preprint arXiv:2107.03374, 2021. [7] “OpenAQ: Open air quality data,” https://openaq.org. [8] “USGS earthquake hazards program,” https://earthquake.usgs.gov. [9] Orcasound Project, “Orcasound: An open-source project for real-time bioacoustic research and conservation,” in Proceedings of the Marine Mammal Science Conference, 2020. [10] “Soil moisture analysis and irrigation workflow using pegasus wms,” 2025. [Online]. Available: https://github.com/pegasus-isi/ soilmoisture-workflow [11] M. Albrecht, P. Donnelly, P. Bui, and D. Thain, “Makeflow: A portable abstraction for data intensive computing on clusters, clouds, and grids,” in Proceedings of the 1st ACM SIGMOD Workshop on Scalable Workflow Execution Engines and Technologies, 2012, pp. 1–13. [12] B. Ludäscher et al., “Scientific workflow management and the kepler system,” Concurrency and Computation: Practice and Experience, vol. 18, no. 10, pp. 1039–1065, 2006. [13] P. Di Tommaso, M. Chatzou, E. W. Floden, P. P. Barja, E. Palumbo, and C. Notredame, “Nextflow enables reproducible computational workflows,” Nature Biotechnology, vol. 35, no. 4, pp. 316–319, 2017. [14] Apache Software Foundation, “Apache airflow,” https://airflow.apache. org/. [15] E. Deelman et al., “The Evolution of the Pegasus Workflow Management Software,” Computing in Science & Engineering, vol. 21, no. 4, 2019. [16] K. Vahi, M. H. Wang, C. Chang, S. Dodelson, M. Rynge, and E. Deelman, “Workflows using pegasus: Enabling dark energy survey pipelines,” in Proceedings of the 28th Astronomical Data Analysis Software and Systems (ADASS’18), 2018, pp. 689–692. [17] T. M. A. Do et al., “Accelerating scientific workflows on hpc platforms with in situ processing,” in 2022 22nd IEEE International Symposium on Cluster, Cloud and Internet Computing (CCGrid), 2022, pp. 1–10. [18] D. Dupont et al., “Chameleon: A large-scale programmable experimental environment for computer systems research,” Future Generation Computer Systems, vol. 87, pp. 644–654, 2018. [19] D. Dupont, M. Hibler, R. Ricci, L. Stoller, and J. Webb, “Cloudlab: Flexible experimentation at scale,” in Proceedings of the USENIX Annual Technical Conference, 2019. [20] W. Shi, J. Cao, Q. Zhang, Y. Li, and L. Xu, “Edge computing: Vision and challenges,” IEEE Internet of Things Journal, vol. 3, no. 5, pp. 637–646, 2016. [21] D. Firestone et al., “Smartnics: Programmable acceleration for networkintensive applications,” in Proceedings of the ACM SIGCOMM Conference, 2018. [22] “Pegasus Workflow Management System API Reference,” https: //pegasus.isi.edu/documentation/reference-guide/api-reference.html, 2025. [23] R. Tanaka et al., “Automating edge-to-cloud workflows for science: Traversing the edge-to-cloud continuum with pegasus,” 05 2022, pp. 826–833. [24] “Orca sound deterction workflow using pegasus wms,” 2025. [Online]. Available: https://github.com/pegasus-isi/orcasound-workflow [25] “Air quality forecasting workflow using pegasus wms,” 2025. [Online]. Available: https://github.com/pegasus-isi/airquality-workflow [26] “Earthquake/seismic data workflow using pegasus wms,” 2025. [Online]. Available: https://github.com/pegasus-isi/earthquake-workflow [27] P. Beckman et al., “SAGE: A software-defined sensor network,” Computing in Science & Engineering, vol. 23, no. 3, pp. 95–101, 2021. [28] “Pegasus workflow management system via ACCESS,” 2024. [Online]. Available: https://support.access-ci.org/tools/pegasus [29] C. Roa et al., “End-to-end integration of scientific workflows on distributed cyberinfrastructures: Challenges and lessons learned with an earth science application,” in 16th IEEE/ACM International Conference on Utility and Cloud Computing, 2024. [30] OpenAI, “Openai codex,” https://openai.com/research/codex. [31] Google, “Gemini (google),” https://ai.google/gemini/, accessed 2026. [32] Q. Team, “Qwen3-coder: Advancing open-source code language models,” arXiv preprint arXiv:2409.12186, 2024, alibaba Cloud. [33] “Deploying pegasus on fabric testbed,” 2026. [Online]. Available: https://tinyurl.com/fabric-artifacts

[34] “Kiso: Edge to cloud workflows: Advancing workflow management in the computing continuum,” 2026. [Online]. Available: https: //kiso.scitech.group/