Industrial automation increasingly relies on multi-agent AI, yet evaluation remains difficult due to task complexity and data confidentiality. We present AssetOpsBench-Live, a demo of a competition-ready platform for real-time, privacy-preserving evaluation of multi-agent AI in industrial contexts. The platform integrates AssetOpsBench, which measures six dimensions of multi-agent performance and performs automated failure-mode discovery, with Codabench, which supports reproducible, code-oriented competitions. End users first validate agents locally, then submit containerized code for execution on hidden industrial scenarios. Instead of raw trajectories, the system provides quantitative scores and clustered failure modes (e.g., reasoning--action mismatch, step repetition), enabling participants to identify failures, apply targeted improvements, and iteratively resubmit. By combining competition-based engagement with actionable diagnostics, AssetOpsBench-Live delivers reproducible, real-time insights reflecting real-world industrial constraints.

Effective anomaly detection frameworks are a central pillar of the Industry 4.0 paradigm. In this paper, we introduce an Optimal Transport (OT)-based framework for anomaly detection, designed to detect deviations from normal behaviour in time-series sensor data. The OT-based method requires minimal user input and adapts to real-time data without the need for labelled training data. Our method effectively addresses existing limitations related to data labelling, generalisability, and scalability, demonstrating resilience against short-term fluctuations, noise, and data gaps — common challenges in industrial environments. Additionally, our method provides counterfactual explanations improving the auditability of the approach when deployed in industrial settingsThe proposed method learns the mapping between normal and observed operating conditions through a sliding reference window that adapts to the dynamicity of the data. We evaluate our approach on three industrial datasets, from shipping, industrial HVAC systems, and publicly available benchmark data. The method was highly effective in identifying anomalies and reducing false positives, outperforming traditional methods, while maintaining computational efficiency and ease of configuration.

WSO (Web-Services Orchestration) addresses a broad set of failure scenarios that become relevant when web-service implementations encapsulate multiple web-service calls to other systems. Network timeouts introduce uncertainty about the success or failure of a given API call: in certain scenarios, simply retrying the operation may make the situation worse. In order to guarantee pseudo-atomicity of a web-service call sequence, the failure of one API call implies that other, successfully completed, API calls may have to compensated for before retrying the original set of web-service calls. Even if no failure occurs, orchestration of a web-service to deal with edge-cases (such as expiration of credentials) can be difficult to implement correctly. In this paper we describe an approach to solving such scenarios which we have implemented in our WSO project. To facilitate use of WSO, the programming model is designed to wrap existing code rather than requiring rewriting code. We show the benefits of WSO in the context of a motivating scenario and also present a before/after comparison.

To meet the demand for rapid Web-service development, developers seek to efficiently consume existing data from multiple sources into a form that can be used by the new service. In this paper, we discuss our SAKURA prototype in which we created two services to facilitate such data consumption. The first, a “resource-aggregation” service, gives developers a “composed object” abstraction across multiple Web-services. The second, a “business object” caching service, improves the performance of accessing existing Web-services from the new application. We describe these two services and illustrate their benefits in the context of an extended scenario.

Large enterprises have built very large "on-premise" data-sets that are critical to many business functions. With the availability of cloud-based storage, many of these enterprises are considering whether and how to make some of this data available on the cloud. One motivation is to offload the processing of new mobile application workloads from the on-premise system to the cloud. Another motivation is to improve the performance of these mobile applications. However, because of the importance of this data, and because of regulatory constraints, many enterprises are unwilling to simply move their data from an on-premise environment to the cloud. Instead, they prefer to keep the "master" version of the data on-premise, while projecting a subset of the data to the cloud. Several challenges face these enterprises. First, how can large data-sets be efficiently made available on the cloud with minimal disruption to the ongoing on-premise business function? Second, how can this data be represented in a way that will be useful to cloud developers? Typically, cloud developers want data represented in a way that is easily consumable by REST APIs, but the on-premise representation may not be amenable to such usage. Our INTEGRATOR project addresses these challenges by providing an integrated cloud/on-premise data-service. Importantly, the INTEGRATOR architecture is broadly applicable across various back-end systems. In this paper we describe the INTEGRATOR architecture and a prototype implementation for a specific on-premise system. We examine alternative architectures - "table based" and "business object based" - and explain why we chose the business object approach.

We examine the lifecycle requirements of intermittently connected web-applications (ICWAs) and investigate whether such applications can be developed as an "always connected" web-application combined with middleware that address ICWA requirements. We show that this is difficult to do because ICWAs require application-specific logic that is not easily combined with a middleware API. We therefore propose the use of "middleware components" in the areas of data-provisioning and change-set propagation. Combined with application-specific logic, these components make it easier to develop an ICWA by reducing the amount of required developer code. We show how our prototype UNTETHER system implements these components and reduces the burden on the application developer.

Application-caching occurs when applications assume control for data caching rather then relying on middleware to manage their data. This paradigm is a good fit for"main-memory caching" in which data storage and retrieval issues are relatively straight-forward. However, the caching requirements of certain workloads exceed even modern main-memory capacity. Although disk-offload offers the potential to overcome this capacity constraint, it poses a problem for the application-caching paradigm since application data may now be resident in either main-memory or on disk. In this paper, we therefore examine how disk-offload middleware can best support the application-caching paradigm for data-centric web-services. We present two disk-offload caching architectures, evaluate their performance, and draw conclusions as to their relative effectiveness.

Developers of situational applications - applications created by a small group of users/developers to satisfy the specific needs of the group - require two things from their software stack. First, they require support for their rapidly changing designs; second, they require semantics that are close to their own domain of expertise. For example, developers of situational applications prefer to use scripting languages because the "duck typing" style of programming language allows them to ignore issues related to class inheritance or interface implementation. In comparison to strongly-typed languages, developers can begin programming more quickly, and can modify their program more rapidly in response to changing requirements. In this paper we explore whether middleware services can similarly provide developers of situational applications with these desired software characteristics. Specifically, we present EDS, an Extensible Data-Service designed to support applications whose design changes rapidly and with semantics that are closer to the domain expertise of situational application developers. We present the features of EDS, contrast it to other data services and APIs, and discuss the EDS implementation.

One benefit of Software-as-a-Service (SaaS) is the ability to rapidly deploy iterative improvements without requiring users to upgrade the application on their machine. However, the need to rapidly "develop and test" different versions of an application implies that developers need branch isolation to protect the system from local changes to both data and meta-data in the same way that they traditionally use branch-isolation to protect the system from source-code changes. Providing branch-isolation for source-code changes has well-known solutions, but these solutions do not extend well to providing isolation for changes to data and meta-data. EVERETT provides developers the ability to safely - and concurrently - change database values with new business logic or evolve data schema in various ways while sharing the same database.

Many web-applications can be characterized as relational. In this paper we introduce and evaluate WebRB, a visualdomain-specific language for building such applications. WebRB addresses the limitations of the conventional imperative-embedding approach typically used to build relational web-applications. We describe the WebRB language, present extended examples of its use, and discuss the WebRB visual editor, libraries, and runtime. We then evaluate WebRB by comparing it to alternative approaches, and demonstrate its effectiveness in building relational web-applications.

Many Web-applications can be characterized as "relational". In this paper we show that developers can greatly benefit from relational blocks, a visual, domain-specific, dataflow language that is designed to facilitate the construction of such web-applications. We define the relational blocks visual language, discuss our WebRB implementation, and show how WebRB is used to construct non-trivial web-pages.

Abstract We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput in clustered environments. Throughput is improved because data serving is offloaded from the database server to the cache‐enabled application server. EJB caching is successful because it exploits the low‐latency connections between the database server and application servers that exist in a clustered environment. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache‐enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non‐caching architectures. Copyright © 2005 John Wiley & Sons, Ltd.

We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput. Throughput is improved because data serving is offloaded from the database server to the cache-enabled application server. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache-enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non-caching architectures.

The Model/View/Controller design pattern is very useful for architecting interactive software systems. This design pattern is partition-independent, because it is expressed in terms of an interactive application running in a single address space. Applying the Model/View/Controller design pattern to web-applications is therefore complicated by the fact that current technologies encourage developers to partition the application as early as in the design phase. Subsequent changes to that partitioning require considerable changes to the application's implementation-despite the fact that the application logic has not changed. This paper introduces the concept of Flexible Web-Application Partitioning, a programming model and implementation infrastructure, that allows developers to apply the Model/View/Controller design pattern in a partition-independent manner Applications are developed and tested in a single address-space; they can then be deployed to various client/server architectures without changing the application's source code. In addition, partitioning decisions can be changed without modifying the application.

An implementation of the two-dimensional (2-D) discrete Fourier transform (DFT) on the Armstrong Multiprocessor System is presented. Armstrong is a loosely coupled parallel processing system made up of a large number of identical processing nodes and is currently operational. The system utilizes a reconfigurable point-to-point network for communication, thus allowing researchers to experiment with different communication topologies for a given application. The 2-D DFT implementation is discussed, and its performance is analyzed under variations in DFT size, network topology, and processing-node count.>