Abstract
Machine learning is increasingly used in cybersecurity, for example, for anomaly and intrusion detection in microservice and Internet of Things environments. Guidance on securing the machine learning operations (MLOps) lifecycle, termed MLSecOps or SecMLOps, recommends continuous monitoring, a versioned model registry, and lifecycle integration of training, evaluation, and serving. This layer is typically built per deployment, as model-specific code rather than a shared framework. We present AICybOps, a framework that systematizes these practices so the operational features and security properties a deployed model needs are provided by design. It wraps trained models behind a uniform lifecycle interface, exposes a monitor control application programming interface (API) for long-running prediction loops, re-loads models by registered name and version across hosts, and runs durable asynchronous training and evaluation, so a developer implements only the model and inherits the rest. These four design features constitute the framework’s current version; an inheritance-and-expansion criterion governs its contents and keeps it open to further security operations. Because the framework addresses a deployed model by registered version, tracks its runs automatically, and holds the registry behind the service boundary, it yields five security properties: lineage, reproducible replay, an audit trail, private provenance, and integrity of model identity.
1. Introduction
Machine-learning models used in cybersecurity [1], across tasks from traffic analysis to intrusion detection [2,3,4,5,6], each require an operational layer to run in production. That layer wraps the model for deployment, exposes it through a continuous monitor, registers and versions its artifacts, and supports long-running training and evaluation across a service boundary. This operational layer is built separately for each deployment rather than provided once as a shared framework. An empirical survey of machine-learning-enabled systems reports limited adoption of machine-learning operations (MLOps) principles: models are mainly deployed as separate services, many are not monitored at all, and teams routinely build their own monitoring tools [7]. An earlier study of software-engineering practice in machine learning corroborates this uneven adoption across teams [8].
Security across the MLOps lifecycle is addressed under two closely related terms: SecMLOps, the academic conceptualization [9,10], and MLSecOps, the term used in practitioner guidance [11]. Both integrate security into every MLOps stage, from data preparation through training, deployment, and runtime monitoring, and we use them interchangeably. This guidance converges on the same operational practices recommended for cybersecurity deployments as well [12]; the gap is that these are typically left to deployment-specific integration code.
The cost of this divergence is operational and concrete. When each model carries its own training, serving, and monitoring code, adding a new model means re-implementing the same infrastructure, a primary source of hidden technical debt that compounds across ML systems [13]. When lineage and version-pinning are best-effort, incident response cannot reliably identify which model at which version produced a given alarm, a provenance gap that becomes a security and compliance liability when the model is itself a security-critical asset [10,11].
We present AICybOps, a framework that systematizes the operationalization of machine-learning models: it gives every model it hosts a set of operational features by design, so the properties a deployed model needs are part of the development and deployment path rather than added afterward. It hosts heterogeneous models under one application programming interface (API) spanning their lifecycles; the framework is implemented as a library that a deployment runs as a service. Because these features live in the framework itself, the service and every hosted model inherit them, and the developer implements only the model, rather than re-implementing them for each deployment. In its current version, the framework provides four design features (Section 3). The first is a uniform model lifecycle interface defining a small set of methods spanning data preparation, training, evaluation, and prediction, and the second a uniform monitor control API (start, status, alarms, stop) for long-running prediction loops. The third is version-addressable re-load of models by name@version across hosts, and the fourth is durable asynchronous training and evaluation behind the same API, with sync/async parity over the lifecycle interface. The four features compose into one design, not four separate capabilities. The same framework yields five security properties (lineage, reproducible replay, an audit trail, private provenance, and integrity of model identity) without each model implementing them. The design is independent of language and runtime; we describe one implementation in Section 4.
To demonstrate the framework, we deploy it as a service and implement four heterogeneous models, hosted in that service, against its interface. These are its two use cases: the service shows the framework operating live, and the four models (a gradient-boosted classifier, a suite of classical classifiers, an autoencoder, and a deep attentive multimodal (DAM) anomaly-detection model) show it hosting heterogeneous models with no framework changes. Neither is part of the framework. Three of the models were externally developed and were integrated through thin adapters that leave their original code unchanged: although they were not written for the framework, each was integrated by implementing its lifecycle interface.
Methodology and roadmap. We derive the operational requirements from MLSecOps guidance and the deployment context, and position the work against related systems and within its security setting (Section 2). We then design the framework to satisfy those requirements (Section 3) and demonstrate it through a working implementation: the framework run as a service, and four heterogeneous models implemented against it (Section 4). We evaluate it against those requirements together with a structural indication of what integrating a model requires (Section 5). We conclude in Section 6.
Generative AI tools assisted manuscript preparation, including drafting and revision, literature discovery, code preparation, and figure preparation. Their use varied across tasks and stages and was evaluated case by case by the authors.
2. Deployment Context, Related Work, and Security Relevance
This section sets up the problem the design solves: the deployment context and the requirements it imposes, how the work relates to existing MLOps and to systems that serve trained models, and the security relevance and trust boundary.
2.1. Deployment Context and Requirements
Running a model in production takes more than the model. It has to be served continuously, replaced when a newer version is trained, trained and evaluated across that same service, and traceable when an alarm has to be explained. These are the operational demands the framework exists to handle, and they are why the framework provides the four design features it does (Section 3) rather than an arbitrary set. An interview study of practitioners describes production work in the same terms, as a matter of velocity, visibility, and versioning [14]. An operational assessment of machine learning in intrusion detection finds that the literature reports model metrics almost exclusively and offers little evidence from deployed prototypes or field use [15]. The five requirements that follow map onto those four features, some of them satisfied by features acting together (Section 5.1). To make them concrete, consider a deployment that runs several models at once. A security-monitoring stack might run, side by side, a multimodal anomaly-detection module over microservice telemetry, an anomaly-detection module over supervisory control and data acquisition (SCADA) and operational-technology traffic, and a supervised classifier over network flows. Each is a module with its own data source, polled by a long-running monitor.
This context imposes five requirements on the framework’s design:
- Continuous, in-service monitoring. The monitor is a long-running internal process, not an externally driven endpoint: it must be explicitly started, must expose its current state for health and observability, and must stop cleanly, letting the cycle in progress finish and leaving its last output observable.
- Switching versions without a service rebuild. When a new model version is registered (after retraining, a tuned threshold, or a new feature), the running module must be replaceable without code changes, during tuning, drills, or incident response.
- Training and evaluation across the service boundary. Long-running training and evaluation must be exposed across the service with both synchronous and asynchronous semantics, as first-class operations rather than out-of-band scripts.
- Lineage. Given an alarm, one must identify which model at which version produced it and re-instantiate that exact version on another host.
- Adding a model without rebuilding the framework. With several heterogeneous models in one deployment, the framework’s operational features (monitoring, versioning, jobs, and tracking) cannot be re-implemented for each; a model is added by implementing only the model and inheriting the rest.
2.2. Related Work and Positioning
The operational concerns AICybOps addresses have been studied from two directions: the MLOps discipline, and the infrastructure that serves trained models for inference. We position the framework against both and present it on its own terms.
MLOps work establishes the practices and documents the gap. Kreuzberger et al. give a definitional and architectural account of MLOps [16], and Paleyes et al. survey deployment challenges across the lifecycle [17], while empirical studies report that these practices are unevenly adopted, with models often unmonitored and monitoring code rebuilt for each deployment [7,8]. On the security side, the SecMLOps paradigm and practitioner MLSecOps guidance extend these practices with security obligations across the lifecycle [9,10,11], and recent work argues that robustness and resilience should attach to the MLOps base rather than stand as separate systems [18,19]. A parallel line examines the supply chain through which models reach production, reporting that artifacts published on model hubs carry security risks that the ecosystem’s current defenses do not address [20,21]. For ML-based intrusion detection specifically, a recent survey names a key open challenge: turning intrusion-detection models into deployable solutions with continuous detection [22], one that early MLOps frameworks for intrusion detection have begun to address [12]. Reviews of machine learning for cybersecurity more broadly map the methods and threats of this space [23]. AICybOps follows this line: in its current version, it provides these recommended operational practices as one framework, and the same lifecycle interface is open to further security-specific operations.
Serving trained models for low-latency inference is a neighboring problem. Clipper places heterogeneous, containerized models behind a uniform prediction interface [24]; TensorFlow-Serving provides high-performance production serving [25]; DLHub adds publication, versioning, and metadata for heterogeneous models [26]; and ServeFlow targets serving for network-traffic analysis in particular [27]. These systems optimize the request and response serving path; AICybOps works at the lifecycle layer above it, and the two are complementary: a deployment could serve a model through one of these systems while AICybOps manages its lifecycle.
General MLOps tools provide the individual pieces separately: a registry and experiment tracking (for example, MLflow [28], which AICybOps uses as its registry backend), pipeline orchestration, and model serving through systems such as Seldon Core, BentoML, or KServe [29,30,31]. Surveys of the tool landscape list many options [16,32]. Putting them together into a running deployment is integration work redone for each one, the situation described in Section 1. AICybOps differs on three points that matter for the deployment context. First, it covers the whole lifecycle (training, evaluation, prediction, and continuous monitoring) behind one interface, instead of serving alone and leaving the other stages to separate tools. Second, its monitor is an internal loop the operator starts and stops, not a server answering outside requests or a router splitting traffic between versions. Third, re-loading a model by name and version, automatic tracking, and a private registry together give the security properties, so lineage, provenance, and integrity of model identity come from the framework rather than being built by hand for each deployment.
A related line of work approaches the same operational concerns from governance rather than from tooling. Model-governance and enterprise-deployment practice is concerned with who may register a model, what record accompanies a deployed version, and what evidence exists when a decision has to be explained or audited [33,34,35]. These obligations are usually met by process and by platform features layered around a deployment. The properties of Section 3.6 meet several of them as a byproduct of the framework’s tracking path, which is where our work touches this line: the record exists because the framework produces it as models run, not because a separate governance step does.
The advantage of providing the operational features a deployed model needs as one framework rather than assembling them for each deployment is that every hosted model inherits them without its developer building them or understanding how they work. A model developer writes the model. They do not implement tracking or registration, work with the tracking system’s interface, decide how a version is created and addressed, or determine what record a deployed model leaves behind.
The security properties of Section 3.6 follow from that inheritance rather than from model-specific code, so they are available to a model whose developer gave no thought to lineage, provenance, or the integrity of model identity. That is what makes them properties of the framework rather than of a well-run deployment.
This is the benefit a framework ordinarily brings, applied to a setting that has been slow to obtain it. The practices surveyed above are unevenly adopted in part because each project implements monitoring, versioning, and tracking for itself; a framework replaces that repetition with one systematized path, so that adopting the practices is not an undertaking for each project. Assembling the same behavior from separate tools is possible, and is what deployments commonly do. What the framework changes is that the assembly is not the model developer’s to make: it is settled in the design, and settled the same way for every model, so two developers who never coordinated produce two models that are invoked the same way. A capability added to the framework under the criterion of Section 3.5 reaches every hosted model on the same terms, without any of them changing.
More broadly, the tools beneath the framework are replaceable parts, not the contribution: the framework defines how every hosted model is served, monitored, versioned, and tracked, and the same design holds if any one is swapped. It provides these properties once, by design, rather than leaving each deployment to wire them together. The implementation shows this directly: four different models run through the one interface, none adding its own code for serving, monitoring, jobs, or tracking. We draw this distinction descriptively, to locate the framework rather than to rank it. The systems named above work at a level different from the whole model lifecycle (serving a model, or the building blocks underneath) the framework covers, so a feature-by-feature comparison would set unlike things side by side, and we make none. Table 1 instead lists the operational features every hosted model receives and the systems from which each capability is separately available.
Table 1.
Operational features AICybOps provides to every hosted model, against the systems from which that capability is separately available. No system named provides more than a part of the left column. The framework provides all of it, to every hosted model, through one interface and without the model’s developer implementing any of it, and the security properties of Section 3.6 follow from that single path. The framework offers no better version of any single row, so it is not an alternative to the systems named: obtaining the same set from them means integrating several, once for each deployment rather than once for every model.
2.3. Security Relevance and Trust Boundary
Whatever its application, each model the framework hosts expands the attack surface, so the model and the infrastructure running it are themselves assets worth protecting. This is most pronounced when the application is cybersecurity, where the hosted model is itself a security-critical asset whose outputs inform or drive the response: a detection is only actionable if the response can trust it and trace it to what produced it. When an alarm fires, incident response and audit must be able to identify the exact model and version behind it and reproduce its behavior, or the detection cannot be acted on with confidence. Security taxonomies for ML systems enumerate the relevant exposures across data, training, the registry, and deployment. They include the MITRE ATLAS adversarial-threat taxonomy [38], the OWASP machine-learning risks [39], an asset-centered threat-modeling method for the machine-learning lifecycle [40], and surveys of attacks on the MLOps pipeline and ML-based software [41,42].
What the framework provides are the integrity and accountability prerequisites that active security operations build on. Version-addressable re-load (Section 3.3) makes the deployed model a known, reproducible artifact, so any output can be tied to the exact model and version that produced it, the property that incident response and forensic review depend on [43] and that security guidance increasingly calls for [11]. Holding the registry, tracking store, and artifact store behind the service boundary keeps model provenance from being addressable or substitutable from outside the service. These properties assume the service host and its private registry, tracking store, and artifact store are trusted: they guard against external addressing, substitution, and undetected change through the registry, not against an adversary who compromises the host itself. Defending the model against adversarial inputs or training-time attacks is one such active security operation: a capability of a distinct class, which the framework admits under the inheritance-and-expansion criterion (Section 3.5 and Section 5.3) and which builds on the properties it provides.
Because the registry defines what a name and version denote, its own integrity matters [20], and two cases are worth separating. Against an attacker outside the service, the framework adds no path of its own. No request sets a version number or re-points an existing version: versions are assigned by the registry as lifecycle stages complete, and a version once registered denotes the artifact it was created from. An attacker who has compromised the host falls outside the assumption stated above, and protecting the stores against one is host and infrastructure security: a distinct class of measure that belongs to the deployment, not a property of the framework. The measures are the ordinary ones. Least-privileged credentials for each store keep a compromised component from rewriting what it did not create. Append-only or backed-up storage makes an alteration recoverable. A copy of the tracking record kept off the host turns a silent change into a visible discrepancy. A deployment can go further still: signed, content-addressed model artifacts make tampering detectable by verification rather than by comparison [21,34].
3. Framework Design
The framework systematizes the operationalization of machine-learning models, so that the operational features a deployed model needs are built into the framework and inherited by every model it hosts, rather than rebuilt for each deployment. This aligns those models with the operational practices MLSecOps guidance recommends [11]. An inheritance-and-expansion criterion governs what belongs in the framework and keeps it open to further features, so its contents are not fixed.
In its current version, the framework contains four such features, exposed as one coherent API: a uniform model lifecycle interface (Section 3.1), a monitor lifecycle (Section 3.2), version-addressable re-load (Section 3.3), and durable asynchronous jobs (Section 3.4). They compose into a single design. Because the operational features live in the framework, the service and every hosted model inherit them, and a new model is added by implementing the lifecycle interface and nothing more. The same composition yields the security properties a security-critical hosted model requires, properties that follow from the framework rather than being assembled for each deployment. We show how the four compose in Section 3.5 and state the security properties that follow in Section 3.6. Each feature below is introduced by the problem it answers, what the framework provides, and the effect on a hosted model.
These descriptions are at the design level. Figure 1 shows how the four features compose around the uniform lifecycle interface.
Figure 1.
The AICybOps framework, as one design, runs as a service that exposes its features. The monitor lifecycle, durable asynchronous jobs, and version-addressable re-load operate on a single uniform model lifecycle interface; heterogeneous models implement that interface by subclassing the base class, and new capabilities can be added under the same criterion.
3.1. Uniform Model Lifecycle
Motivation. In the deployment context, several heterogeneous modules run concurrently. Each model exposes lifecycle stages: preparing data, training, validating, testing, evaluating against held-out data, predicting in production, and optimizing hyperparameters. When each model exposes these stages through its own entry points, two consequences follow for the layer hosting them. First, hosting several modules side by side, or replacing one with another, requires model-specific integration code rather than a uniform interface. Second, lifecycle stages cannot be invoked uniformly across modules: there is no single way to train or evaluate an arbitrary model. This integration code accumulates with every module integrated.
What the framework provides. A uniform model lifecycle interface in two parts: the methods a model implements for its own logic, and the operations the framework supplies on top of them. Table 2 sets out the division.
Table 2.
The uniform model lifecycle interface, grouped by what supplies each method: a model implements the first group for itself, the framework supplies the second, and the third holds framework defaults a model may override.
The two operations a model may override are supplied capabilities of the interface rather than extensions planned for later. The first is optimize, a default hyperparameter search that runs through the framework and records its trials on the same tracking path as any other run, so a search is as traceable as a training run. A model that wraps an externally developed training script overrides it to run that script’s own routine instead, which is how the externally developed models of Section 4.3 use it. The second is evaluate, held-out evaluation a model opts into by overriding it. Any caller (an HTTP handler, a batch pipeline, an interactive session) invokes the same method names regardless of which model is on the other end.
The interface names the stages but does not require a model to keep them apart. A model whose routine builds, fits, and scores in one pass (a suite of classical classifiers, say) implements that routine under train, and lets validate and test report from what the single pass produced. Data preparation and construction stay empty where the routine already performs them. A model that separates the stages implements each in turn. In both cases the service drives the model through the same interface, so the operational features of the framework reach it on the same terms. The interface records the shape a model already has rather than imposing one on it.
Effect. The uniform lifecycle is the interface the rest of the framework is written against. The control plane targets this interface; the registry records artifacts produced through it. Adding a new model means subclassing the base class and implementing the relevant abstract methods, not writing new control-plane code.
3.2. Monitor Lifecycle
Motivation. The deployment context invokes each module continuously through a long-running monitor. Three operational properties of that context define a control API: start and a clean stop, observable status, and switching versions without code changes. This is unlike request/response serving (the model called by external clients) and deployment-level traffic rollouts (the platform routing traffic between versions). The monitor loop is internal to the framework, not driven by external requests, and switching versions happens by re-loading a registered name@version rather than by traffic shaping.
What the framework provides. A uniform monitor control API (start, status, alarms, stop) for the long-running prediction loop that wraps a model. start instantiates the model at a specified registry version, accepts model construction parameters and a polling cadence, and launches the loop; each cycle then invokes the model’s prediction path at that pinned version. status reports the loop’s liveness, last-alarm timestamp, and the last error if any. alarms exposes the most recent alarm or score state. stop halts polling cleanly: the cycle in progress finishes, and the last output remains observable until the next start. The same four operations control any registered model.
Effect. The uniform monitor control API lets the lifecycle interface and version-addressable re-load compose: a single start call instantiates any registered model at any registered version, with no model-specific code in the control plane. The monitor control API and the lifecycle interface together let any registered model be brought up under one control plane; concurrent monitoring of multiple modules from one service instance is an implementation extension.
3.3. Version-Addressable Re-Load
Motivation. Given a model’s name and version, one must be able to re-load the same artifacts and obtain the same predictions on the same inputs, on any host that can reach the registry. This is the lineage requirement set out earlier, and it applies even when the model is a streaming model with internal state. A registry that records artifacts is necessary but not sufficient; the re-load path must be exposed as a primitive of the framework.
What the framework provides. Version-addressable re-load. Given a registry-managed identifier name@version, the framework loads and instantiates the model, including the auxiliary artifacts it carries (such as preprocessors, scalers, vocabularies, and learned thresholds), to a state functionally equivalent to the state at registration time, on any host that can reach the registry. “Functionally equivalent” is operationalized as: replaying a fixed input sequence produces the same output sequence. What re-load fixes is the model, not the numerical environment it runs in or any randomness a model’s own inference draws. Versioning is automatic. A model developer does not tag or register a version: when validation, testing, or evaluation completes on the framework’s tracking path, the framework logs the artifact and the run that produced it, and the registry creates the next version under the model’s name. The developer implements the lifecycle methods, and the version numbers follow from running them. Addressing a model as name@version therefore refers to a version the framework itself created, which is what allows a name and version to identify one trained artifact unambiguously.
Effect. Version-addressable re-load is the feature that lets the monitor lifecycle switch between versions without code changes: start takes a name@version, and the rest of the framework is unaffected. It is also the feature that makes the framework portable: a registered model can be re-instantiated in a different deployment without re-shipping model-specific code.
3.4. Durable Asynchronous Jobs
Motivation. Two of the lifecycle methods, train and evaluate, can be long-running. Started synchronously over HTTP, such a run is fragile in two independent ways: the client may disconnect before it finishes, and the service side, a worker or the API process, may restart. The operational requirement is to expose the same uniform lifecycle interface across a service boundary with both synchronous and asynchronous semantics, so that a submitted run executes independently of the client’s connection and queued work persists across a worker or API-process restart.
What the framework provides. Sync/async parity for the long-running lifecycle methods. A synchronous variant blocks for short or test runs, and an asynchronous variant is backed by a durable job store that records the job’s identifier, status, and final result (the submitted request, including its parameters, is retained on the queue). A worker process consumes the job store, executes the lifecycle method, and writes results back. Because the run executes in the worker rather than the request handler, the client submits the run, receives a job identifier, and reads the result back by that identifier, so it need not stay connected. Because the queue is durable, a restarted worker resumes consuming it, and a run interrupted in progress is marked failed rather than silently dropped.
Effect. Sync/async parity over the same lifecycle interface keeps the framework’s API thin: one definition of train, two transport semantics. Without a durable job store, train over HTTP is not viable for long-running runs; with one, training and evaluation become first-class operations of the service rather than out-of-band scripts.
3.5. The Four Features as One Framework
The four features are built to work together, not in isolation. The monitor and the durable jobs operate on the uniform lifecycle interface, and version-addressable re-load lets the monitor switch versions without code changes and lets a durable evaluation job load the exact version it names. Without this composition, each model added rebuilds the operational infrastructure itself (its own training entry point, serving code, monitoring loop, and ad-hoc lineage capture), and the operational practices the cited MLSecOps guidance recommends remain best-effort for each deployment.
Because these features live in the framework rather than in any model, each operational feature is implemented once and inherited by every hosted model. The same principle governs what the framework should contain, and is the inheritance-and-expansion criterion introduced above. A capability belongs in the framework when it reflects an established practice in operational machine learning, in securing machine-learning systems, or in security more generally, whether or not every hosted model will use it. The four features of this section meet this test, whereas anything specific to a single model’s own task stays in that model’s implementation. This criterion keeps the framework lean and auditable, and it is also what leaves room for further security operations to be added as the framework grows.
The four features are the starting point of the framework, not a closed set. New capabilities can be added under the same criterion, without rebuilding the framework.
3.6. Security Properties of the Framework
The four features are operational, but they also yield a set of security properties, and these are a central reason the framework matters for security and not only for operations. The properties do not depend on the task a hosted model performs; they follow from the framework itself. A cybersecurity deployment is where they matter most, because there the model is itself a security-critical asset: its outputs drive or inform the response, so its decisions must be attributable, independently verifiable, and protected from undetected change. The composition of version-addressable re-load, automatic tracking of each run, and a registry held behind the service boundary gives the deployed service the following properties without each model implementing them.
- Lineage. A prediction, evaluation, or monitoring cycle addresses the model by an explicitly registered version, and training and evaluation are recorded under that version. A model in service that registers its artifacts through the tracking path is therefore always a known, identified artifact with a recorded origin, the precondition for holding its decisions accountable.
- Reproducible replay. A name and version are enough to reconstruct the model on any host that can reach the registry, so a security analyst can re-examine a past decision or run the model on new data on a different machine, and a detection is independently checkable rather than taken on trust.
- Audit trail. Because tracking is automatic and tied to the registered version, the link from a deployed version back to the runs, parameters, and metrics that produced it is explicit. Each lifecycle stage is recorded as a separate run rather than as one opaque record, so an auditor can trace a version to its provenance and isolate the stage that produced any questioned metric, without relying on operator testimony.
- Private provenance. Because models are addressed through registry pointers rather than external locations, the registry, tracking store, and artifact store stay private to the service host and are reachable only through the service, so a model’s artifacts and provenance are not exposed or addressable from outside.
- Integrity of model identity. Because re-load is by registered name and version, the registry alone defines which trained model a name and version denote, which removes the ambiguity that could otherwise let a model be silently substituted.
Worked example. Consider an alarm under review. On any host with registry access, an analyst re-loads the exact name@version that raised it, and replays the recorded input window to re-examine the detection. The registry record leads back to the run, parameters, and metrics that produced that version, without rebuilding the model or relying on operator notes. Because the same pointer fixes what is in service, a mid-session retraining cannot silently change what is running. Figure 2 traces this path.
Figure 2.
How an alarm resolves to the model that produced it, and where each security property arises. The version pointer carried by the alarm resolves in the registry to the run that produced that version, with its parameters and metrics, and to the artifact from which the version is re-instantiated on any host that can reach the registry. The registry, tracking store, and artifact store sit within the service boundary.
The accountability and integrity properties above hold in the framework as it stands, within the trust boundary of Section 2.3: they follow from that composition and require no security-specific code. They are also the kind of evidence that AI risk-management and governance frameworks call for, for example, the NIST AI Risk Management Framework [44], supplied here as a byproduct of operation rather than as separate compliance work. The connection is worth making specific. The AI Risk Management Framework organizes practice into four functions (govern, map, measure, and manage), and the properties here supply evidence for three of them. Under govern, accountability and documentation: every deployed model has a recorded provenance, and the record is produced by the act of training rather than by a separate documentation step. Under map, transparency about what is deployed: a name and version identify one trained artifact, so what is running is knowable rather than reconstructed. Under manage, response and traceability: an output resolves to the model and version that produced it, and that version re-instantiates for examination. Active security operations, building on the properties above, are a further way the framework could expand under the same criterion.
4. Implementation
We describe the implementation of AICybOps. The framework is implemented as a library, written in Python; its source code, with the accompanying technical report, is openly available at https://github.com/rleal16/aicybops-framework (accessed on 4 October 2026). In the implementation, it is run as a live service that hosts a set of models; the service and the hosted models are each a use case demonstrating the framework rather than forming part of it. The service runs the framework; it shows how the framework operates as a service and how the four design features behave once running. The hosted models are four heterogeneous models that implement the lifecycle interface; they show how new models are brought onto the framework and demonstrate its versatility. Each is concrete code that uses the framework: the service calls each model through the BaseModel interface, and a model that implements that interface runs on the service without service-side changes. Neither the service nor the hosted models are part of the framework; we present both as use cases, an existence proof of the framework in operation.
4.1. Architecture
The library defines the uniform lifecycle interface as an abstract base class, BaseModel. A model is implemented by subclassing BaseModel, implementing its abstract methods, and applying a logging decorator to its training-side lifecycle methods (train, validate, test, and evaluate where supported) so that parameters, metrics, model signatures, and registered versions are recorded to MLflow. The framework places no constraints on a model’s data sources: each model defines and handles its own data collection, for both training and prediction. Beyond implementing the interface, a model needs no knowledge of the server or of how it is deployed.
The library also provides a server, a FastAPI application. It exposes endpoints for train and evaluate over the same lifecycle interface, with both synchronous (blocking, selected by a wait=true query parameter) and asynchronous (default, returning HTTP 202 with a job identifier) semantics, using a Redis-backed durable job store and a worker process. It also exposes a monitor control API (start, status, alarms, stop) that runs a long-running prediction loop on a model loaded by the registered version. The current implementation runs one active monitor loop per service instance (a second start returns HTTP 409 rather than replacing the first, so each instance’s status and alarms stay attributable to the single name@version it is running). Concurrency across modules comes from running several service instances, each with its own state. The durable job layer scales independently because the Redis-backed queue decouples submission from execution and additional workers can consume it without API changes, and a multi-loop control API within one instance is a natural later extension. Standard MLflow infrastructure (tracking server, artifact store, backend database) is used as the registry backend [28].
To deploy, we run the library’s server and register with it a set of models that implement the interface. An in-process registry maps each registered model type to its class, so one server hosts several heterogeneous models at once and dispatches each request to the right model through the BaseModel interface. The server supplies the operational capabilities and each model its own logic, so what distinguishes one deployment is which models it registers. This running deployment is the service, where the four design features and the security properties operate; a concrete example follows.
The architecture is shown in Figure 3.
Figure 3.
Implementation architecture. The library’s server, run as a service, exposes the lifecycle routes, the monitor control API, and job polling, with one active monitor loop per instance. BaseModel subclasses register in an in-process registry and are dispatched by model type; a Redis-backed durable job store and worker run training and evaluation; MLflow is the registry backend, its model registry, tracking store, and artifact store inside the service boundary. The numbers follow one request from the client to the registry. In /monitor/*, the asterisk denotes the four monitor endpoints: start, status, alarms, and stop.
4.2. How Each Design Feature Is Implemented
Uniform model lifecycle (Section 3.1). BaseModel separates the methods a model must implement from the operations the framework supplies on top of them. Table 2 sets out the division. In the implementation, the supplied evaluate defaults to raising NotImplementedError, so held-out evaluation is opt-in for the models that support it. A logging decorator wraps train, validate, test, and (in subclasses that override it) evaluate to record parameters (on train) and metrics to MLflow, attach a model signature on registration calls, and associate the run with a registered model name and version. A new model is added by subclassing BaseModel, overriding the abstract methods relevant to its training and inference, and applying the decorator. Models are registered with the in-process registry by name, after which the service can address them by model type in any API request.
Monitor lifecycle (Section 3.2). The monitor exposes the four control endpoints. start accepts a registered model name, an explicit version, model construction parameters, and a polling cadence. It instantiates the model via the in-process model-type registry and launches a thread that, on each polling tick, invokes the model’s prediction path (loading the registered version from the MLflow registry and calling predict). Each tick’s alarm or score output is written to a shared, thread-safe state, replacing the previous tick’s. status returns the current liveness, the timestamp of the last successful alarm, and the last error, if any; alarms returns the most recent alarm payload; stop halts polling cleanly. Switching versions is performed by invoking stop followed by start with a new name@version, with no code change. As a worked example, consider one of the hosted models, registered as anomaly_model. A retrained version anomaly_model@7 is registered after a tuning run. The on-call analyst issues POST/monitor/stop and then POST/monitor/start {name: anomaly_model, version: 7}, and the new version begins polling on the next tick with a fresh alarm window tied to the new version. No service restart, no code change, no model-specific script to switch versions.
Version-addressable re-load (Section 3.3). Registration is performed through the logging decorator. When validate, test, or evaluate completes, where evaluate is opt-in for the models that implement it, the decorator logs a model artifact under the configured name in MLflow, and the registry creates a new version under that name. (train invocations record parameters and metrics but do not themselves log a model artifact; registration is anchored to the held-out-set methods.) In practice, this means a call to the train-test-validate routine creates a new registry version on completion of test, and another on completion of validate. Re-load is performed by the monitor’s start and by an explicit predict endpoint that takes a name@version and reconstructs the model from registry artifacts via the library’s re-load path. The implementation currently uses MLflow’s models:/name/version URI scheme as the underlying re-load mechanism; the framework operationalizes re-load by registered name and version as an explicit feature rather than leaving it solely as a backend detail of the registry implementation. The MLflow integration in the current implementation uses MLflow’s PyTorch flavor (PyTorch 2.12.0+cpu in the documented operational run); supporting the other hosted models’ flavors (XGBoost, scikit-learn, Keras) is engineering work that does not change the design feature.
Durable asynchronous jobs (Section 3.4). The train and evaluate endpoints accept a wait=true query parameter for the synchronous variant, which blocks until completion and returns HTTP 200 with the result. They default to the asynchronous variant: the request is enqueued into a Redis-backed job store with a generated identifier, the endpoint returns HTTP 202 with the identifier, and a worker process consumes jobs from the queue and executes the lifecycle method. Job status and final results are written back to the job store and are queryable by identifier through /jobs/{id} and /eval-jobs/{id}. Queued jobs persist across worker restarts: a restarted worker resumes consumption from the Redis queue (a blocking BRPOP on a list key) rather than from in-memory state. A run that was in progress when the worker stopped is not lost silently: on restart, the worker marks any job still recorded as running as failed, giving it an explicit terminal state. The synchronous path uses the same job store internally; the difference between the two transport semantics is whether the HTTP handler blocks on the result.
4.3. Use Case: Heterogeneous Models Hosted Under the Framework
The service is the framework’s server deployed as two containers, the FastAPI application and the durable-job worker, alongside the infrastructure its features depend on. An MLflow tracking server, backed by a PostgreSQL metadata store and a MinIO artifact store, is the registry and tracking store behind version-addressable re-load and the security properties, and a Redis instance is the durable queue behind the asynchronous jobs. Instantiating it is configuration, not code: the four models are registered at startup, and the infrastructure endpoints are supplied through environment variables. Each model brings its own data, so what a deployment monitors is set by the models it registers, not by the service.
A model is added to the service by implementing the lifecycle interface. Listing 1 shows the methods it implements and the registration that makes it addressable by model type. The developer writes only this model logic; the HTTP routes, durable jobs, monitor loop, version-addressable re-load, and tracking are inherited from the framework.
| Listing 1. A model implemented against the lifecycle interface. The developer’s subclass of BaseModel supplies the model’s own logic in each method. The decorator on the training stages is the framework’s: applying it is what records each run and registers the trained model as a new version. |
![]() |
Registering the class under a model-type key is what makes it available to the service:
| model_registry.register("my_model", MyModel) |
To demonstrate the framework’s versatility, the four models, integrated this way, span learning paradigms and ML frameworks:
- A gradient-boosted classifier (XGBoost) for supervised intrusion classification.
- A suite of classical classifiers (decision tree, random forest, naive Bayes, support-vector machine, one-class SVM, and multilayer perceptron), implemented with scikit-learn, run independently and exposed as a single model type.
- An autoencoder for unsupervised reconstruction-error anomaly detection, implemented with TensorFlow/Keras.
- A deep attentive multimodal anomaly-detection model (DAM) for microservice telemetry, our PyTorch implementation of the published architecture of [45].
Spanning supervised, one-class, and unsupervised paradigms and four ML frameworks, they all run under the single BaseModel interface with no framework changes, an existence proof of the framework’s versatility. They instantiate part of the deployment context: DAM is the microservice anomaly-detection module, and the classifiers cover supervised network intrusion classification.
The three external models are integrated in the same way. Each was provided to us as a self-contained training-and-evaluation script, which a thin BaseModel subclass wraps behind a single entry point, leaving the provided code unchanged. Because each script loads its own data and runs end to end, the subclass implements the data-preparation methods as no-ops and routes train, validate, test, and predict to it, exposing its predictions and summary metrics (for example, accuracy and weighted F1) through the lifecycle interface. Each adapter is a thin wrapper that adds no learning logic of its own; the three differ only in the script they call.
DAM implements the lifecycle interface in full rather than wrapping a script. Its data-preparation methods load the multimodal telemetry into aligned time windows, build_model constructs the network, train fits it, predict scores the live stream, and evaluate runs held-out evaluation. The training-side methods carry the logging decorator, so every run logs its parameters and metrics and registers the trained network as a versioned artifact. In doing so it uses the framework’s full feature set: its training and evaluation run as durable jobs, it is addressed and re-loaded by registered version, and it is driven live by the monitor, all over the one lifecycle interface. The model itself is a PyTorch network that encodes three telemetry modalities (resource-load, traffic, and log sequences) with per-modality recurrent encoders, fuses them with multi-head attention, and forecasts each modality’s next values; the per-window prediction error, thresholded by a quantile, is the anomaly score.
Models that reach the framework by different routes converge on the same operational result. DAM was written against the lifecycle interface from the start; the other three were developed independently of this work, by collaborators working without reference to the framework, and were integrated afterwards without altering them. From the service’s side, that difference is not visible: all four are invoked through the same interface, and the framework supplies its operational features (serving, monitoring, durable jobs, versioning, and tracking) to each on the same terms.
Every lifecycle method is invoked the same way for all four. Training, validation, testing, and prediction each run through the same interface, whether a model computes them directly or routes them to the code it wraps; what a method returns is determined by the model, not by the route it took into the framework. This is Section 3.5 in practice: each operational feature is implemented once in the framework and inherited by every hosted model, whatever that model implements for itself.
4.4. Deployment and Reproducibility
The deployment runs as a set of containers defined by a Compose file in the public repository, on a single remote Linux machine. Two of the containers run the framework: the service, a FastAPI application exposing the routes of Section 4.1, and a worker that executes asynchronous training and evaluation jobs; both are built from a Python 3.11 base image. The remaining containers provide the backing stores: an MLflow tracking server with PostgreSQL as its metadata store and MinIO as its artifact store, which the service and the worker also read and write directly, and Redis as the job queue and job store. The Compose file names the store images and the repository lists the framework’s dependencies. Nothing in the design depends on this arrangement, or on particular versions of these components: the framework places no requirement on where the service runs, on which components back it, or on the versions in which they are deployed. Bringing the deployment up requires starting the Compose stack with the infrastructure endpoints and model settings supplied as environment variables, which the repository documents, and registering each model to be hosted under a model-type key as described in Section 4.2. The repository also records the request sequence used for Section 5.2.
5. Evaluation and Future Work
We evaluate the framework against the operational requirements it was built to meet, showing that it satisfies them in a working deployment.
5.1. Validation Approach
We take the design to succeed when four conditions hold together. First, each of the five operational requirements of Section 2.1 is met by a named design feature rather than by deployment-specific code. Second, each of those features runs in a live service. Third, a model is hosted by implementing the lifecycle interface alone, inheriting the operational features the framework provides rather than contributing any of them. Fourth, models that differ in learning paradigm and in machine-learning library are hosted through that same interface without changes to the framework.
The framework is validated by showing that each operational requirement is met by a named design feature and confirmed in a working deployment, not by a performance benchmark. Because the framework hosts models but contains none, and is independent of language and runtime, a benchmark would characterize a particular model or deployment rather than the design itself. We do this in two complementary ways: by mapping each requirement to the design feature that satisfies it, and by confirming each framework behavior in a running deployment of the service.
Table 3 gives this mapping, with each requirement met in the implementation. The framework is built and deployed as the service, which currently hosts four heterogeneous models.
Table 3.
Operational requirements and the design feature that satisfies each.
5.2. Operational Validation
Beyond mapping requirements to features, we validate each framework behavior in the deployed service: each behavior is provided by a named feature, and a technical report in the project repository (Data Availability) documents an operational run of the service. Each behavior is either observed in that run or follows by construction from a feature that is. The validation is behavioral, not a performance or accuracy benchmark. The monitor, job, and tracking behaviors are provided by the framework and hold for every hosted model without model-specific code; version-addressable re-load and the replay it enables hold for any model that registers its artifacts through the framework’s tracking path. Table 4 summarizes.
Table 4.
Operational validation: how each framework’s behavior is validated in the deployed service.
The run behind that table gives the figures directly. A single training request produced two registered versions of DAM, one on the test stage and one on validation, and a subsequent evaluation produced a third. Each version is reachable from its name-and-version pointer back to the run, parameters, and metrics that produced it, and no registration step of its own appears anywhere in the sequence.
Table 4 rests on three lines of evidence: behaviors observed directly in the operational run, behaviors that follow by construction from one of those, and a static observation of the implementation. The monitor-control, re-load, job-durability, and audit-trail entries are observed directly. The four monitor endpoints drive the prediction loop, and a second start returns HTTP 409, confirming the single active loop per instance. The multimodal model is loaded by name@version and reconstructed from the private registry to its registered state, auxiliary artifacts included. An asynchronous train request returns a job identifier and stays queryable through it after the submitting connection has ended, so the job outlives the request that started it. Each lifecycle stage that registers a version is recorded as a separate run, so a deployed version traces back to the runs, parameters, and metrics that produced it. Replay and worker restart follow by construction from two of these. Because a re-loaded version restores the same artifacts, replaying a fixed input window reproduces its registered outputs without a separate run to show it. Because the queue is durable, a restarted worker resumes consuming queued work rather than losing it. The model-integration entry is a static observation of the three external adapters, which wrap an existing script and add no framework code.
The deployment gives a structural indication of what the framework absorbs. Three of the four hosted models were developed outside this work, each provided as a self-contained training-and-evaluation script written against a different machine-learning library. Hosting each required only a thin wrapper that names the metrics the model reports and routes the lifecycle methods to the provided script; the scripts themselves were left unchanged. None of the three contributes code for serving, monitoring, job handling, or tracking, and none registers artifacts, records runs, or exposes routes on its own account: those are what the interface supplies. What the framework records for these models it records on the same terms as for the model implemented in full, because the record follows from the path their runs take rather than from anything the model does. What a developer would otherwise assemble for each model (a serving path, a monitor, job handling, a registry and tracking integration) is what the wrapper does not contain.
Version-addressable re-load is demonstrated end to end with DAM, which registers its artifacts through the framework’s tracking path and is re-loaded by name and version for both prediction and monitoring; the replay it enables follows from that re-load. Both properties follow from the tracking path rather than from the model. The other three hosted models wrap existing code that trains and retains its own model: they report their metrics through the tracking path without registering a model artifact. Carrying their artifacts too is implementation work on both sides, the model exposing its trained artifact and the framework recording that library’s format, and it leaves the design feature unchanged.
Three boundaries of the present evidence are worth stating plainly. The security properties of Section 3.6 hold by construction, from the record the framework produces as each hosted model’s stages run, and are confirmed behaviorally in the deployment. They are not established by measurement against an adversary, and the trust boundary of Section 2.3 sets what they cover. The evidence for model integration is likewise structural: it rests on what a model developer writes and what the framework supplies, not on measurement. The framework’s runtime cost is unmeasured: we make no claim about prediction latency or about the overhead of hosting several models at once, and a measurement of the present deployment would characterize that deployment’s components rather than the design. Establishing any of the three empirically would require a different kind of study: for the first, evaluation against an adversary model; for the second, a controlled comparison with developers from outside the project; for the third, a measurement study over a deployment configured for it. Such work is built around measurement rather than around design.
5.3. Future Work
The framework is designed to grow through the inheritance-and-expansion criterion, which admits new capabilities without changes to the framework’s core. The most immediate direction is a class of security-specific operations that build on the security properties: adversarial-robustness checks, explainability, drift evaluation, and model-card or audit-log emission. The present design founds these directly. Operations of this kind need two things: a defined point at which to act on a model, and a record to attach their output to. The lifecycle interface supplies the first: a capability added under the criterion attaches to the stage it belongs to and reaches every hosted model through it. The tracking path and registry supply the second: a robustness check, an explanation, a drift evaluation, or an emitted model card is recorded against the same name and version as the run it describes. Its result then carries the same lineage as the metrics beside it. The properties of Section 3.6 are what make that record trustworthy. This is how the framework’s cybersecurity contribution matures, from the present accountability and integrity properties to active security operations on the same interface. The runtime the framework provides (serving, continuous monitoring, and durable jobs) can be extended in the same spirit, enriching the operational features every hosted model inherits. Characterizing these extensions under the AICybOps abstraction is left to future work.
6. Conclusions
We have presented AICybOps, a framework that systematizes the operationalization of machine-learning models, building the operational features a deployed model needs into the framework by design so every hosted model inherits them rather than having them rebuilt for each deployment. Its design composes a small set of current features under one interface, governed by the inheritance-and-expansion criterion that keeps the framework open to further ones, including further security operations on the same interface, and aligns with the operational practices MLSecOps guidance recommends. The service hosts four heterogeneous models under one abstraction. The framework gives the deployed model five security properties: lineage, reproducible replay, an audit trail, private provenance, and integrity of model identity. These matter most where the model is itself a security-critical asset.
Author Contributions
Conceptualization, R.L.; methodology, R.L.; software, R.L.; investigation, R.L.; writing—original draft preparation, R.L.; visualization, R.L.; writing—review and editing, S.F.; supervision, S.F.; project administration, S.F.; funding acquisition, S.F. All authors have read and agreed to the published version of the manuscript.
Funding
This work was co-financed by the Recovery and Resilience Plan (PRR), through the European Union—NextGenerationEU, under the project Nexus—Green and Digital Transition for Transport, Logistics and Mobility (Ref. C645112083-00000059).
Institutional Review Board Statement
Not applicable. This study did not involve humans or animals.
Informed Consent Statement
Not applicable.
Data Availability Statement
The source code of the framework and the service deployment built on it, described in this paper, is available at https://github.com/rleal16/aicybops-framework (accessed on 4 October 2026), together with a technical report documenting the deployment and the operational run referenced in Section 5.2. The framework incorporates no proprietary or sensitive data: it contains no models and no data of its own, and no claim in this paper depends on a particular dataset, so a deployment supplies whatever data its hosted models require. The repository referenced above ships the data the hosted models use, and all of it is machine-generated: recorded runs of instrumented services under normal and attack conditions, system-call traces, and telemetry produced by the project’s own tooling. None of it is personal or proprietary.
Acknowledgments
During the preparation of this manuscript, the authors used Codex (OpenAI), Claude (Anthropic), and Cursor (Anysphere) as assistants for drafting and revising text, literature discovery, code preparation, and figure preparation. Their use varied across tasks and stages and was evaluated case by case by the authors. All conceptual content (the framework’s design, the implementation, and the directions for future work) originated with the authors. The authors have reviewed and edited the output, verified all factual claims and citations against the framework’s source, and take full responsibility for the content of the publication.
Conflicts of Interest
The authors declare no conflicts of interest.
References
- Apruzzese, G.; Laskov, P.; Montes de Oca, E.; Mallouli, W.; Búrdalo Rapa, L.; Grammatopoulos, A.V.; Di Franco, F. The Role of Machine Learning in Cybersecurity. Digit. Threat. Res. Pract. 2023, 4, 1–38. [Google Scholar] [CrossRef] [Scilit]
- Lotfollahi, M.; Jafari Siavoshani, M.; Shirali Hossein Zade, R.; Saberian, M. Deep Packet: A Novel Approach for Encrypted Traffic Classification Using Deep Learning. Soft Comput. 2020, 24, 1999–2012. [Google Scholar] [CrossRef] [Scilit]
- Mirsky, Y.; Doitshman, T.; Elovici, Y.; Shabtai, A. Kitsune: An Ensemble of Autoencoders for Online Network Intrusion Detection. In Proceedings of the Network and Distributed System Security Symposium (NDSS), San Diego, CA, USA, 18–21 February 2018. [Google Scholar] [CrossRef] [Scilit]
- Araujo, I.; Antunes, N.; Vieira, M. Evaluation of Machine Learning for Intrusion Detection in Microservice Applications. In Proceedings of the 12th Latin-American Symposium on Dependable and Secure Computing (LADC), La Paz, Bolivia, 16–18 October 2023; pp. 126–135. [Google Scholar] [CrossRef] [Scilit]
- Plazas Olaya, M.K.; Vergara Tejada, J.A.; Aedo Cobo, J.E. Securing Microservices-Based IoT Networks: Real-Time Anomaly Detection Using Machine Learning. J. Comput. Netw. Commun. 2024, 2024, 9281529. [Google Scholar] [CrossRef] [Scilit]
- Holubenko, V.; Gaspar, D.; Leal, R.; Silva, P. Autonomous Intrusion Detection for IoT: A Decentralized and Privacy Preserving Approach. Int. J. Inf. Secur. 2025, 24, 7. [Google Scholar] [CrossRef] [Scilit]
- Zimelewicz, E.; Kalinowski, M.; Mendez, D.; Giray, G.; Santos Alves, A.P.; Lavesson, N.; Azevedo, K.; Villamizar, H.; Escovedo, T.; Lopes, H.; et al. ML-Enabled Systems Model Deployment and Monitoring: Status Quo and Problems. In Software Quality as a Foundation for Security (SWQD 2024); Lecture Notes in Business Information Processing; Springer: Cham, Switzerland, 2024; Volume 505, pp. 112–131. [Google Scholar] [CrossRef] [Scilit]
- Serban, A.; van der Blom, K.; Hoos, H.; Visser, J. Adoption and Effects of Software Engineering Best Practices in Machine Learning. In Proceedings of the 14th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM), Bari, Italy, 5–9 October 2020; pp. 1–12. [Google Scholar] [CrossRef] [Scilit]
- Zhang, X.; Jaskolka, J. Conceptualizing the Secure Machine Learning Operations (SecMLOps) Paradigm. In Proceedings of the 22nd IEEE International Conference on Software Quality, Reliability and Security (QRS), Guangzhou, China, 5–9 December 2022; pp. 127–138. [Google Scholar] [CrossRef] [Scilit]
- Zhang, X.; Zhao, P.; Jaskolka, J.; Li, H.; Lu, R. SecMLOps: A Comprehensive Framework for Integrating Security throughout the Machine Learning Operations Lifecycle. Empir. Softw. Eng. 2026, 31, 74. [Google Scholar] [CrossRef] [Scilit]
- Open Source Security Foundation (OpenSSF). Visualizing Secure MLOps (MLSecOps): A Practical Guide for Building Robust AI/ML Pipeline Security. OpenSSF Whitepaper. 2025. Available online: https://openssf.org/wp-content/uploads/2025/08/OpenSSF_MLSecOps_Whitepaper.pdf (accessed on 18 June 2026).
- Spadari, V.; Cerasuolo, F.; Bovenzi, G.; Pescapè, A. An MLOps Framework for Explainable Network Intrusion Detection with MLflow. In Proceedings of the 29th IEEE Symposium on Computers and Communications (ISCC), Paris, France, 26–29 June 2024; pp. 1–6. [Google Scholar] [CrossRef] [Scilit]
- Sculley, D.; Holt, G.; Golovin, D.; Davydov, E.; Phillips, T.; Ebner, D.; Chaudhary, V.; Young, M.; Crespo, J.-F.; Dennison, D. Hidden Technical Debt in Machine Learning Systems. In Advances in Neural Information Processing Systems 28 (NeurIPS 2015); Curran Associates: Red Hook, NY, USA, 2015; pp. 2503–2511. [Google Scholar]
- Shankar, S.; Garcia, R.; Hellerstein, J.M.; Parameswaran, A.G. “We Have No Idea How Models will Behave in Production until Production”: How Engineers Operationalize Machine Learning. Proc. ACM Hum.-Comput. Interact. 2024, 8, 1–34. [Google Scholar] [CrossRef] [Scilit]
- Husák, M.; Manoj, D.; Kumar, P. Machine Learning in Intrusion Detection: An Operational Perspective. In Proceedings of the 20th International Conference on Network and Service Management (CNSM), Prague, Czech Republic, 28–31 October 2024; pp. 1–7. [Google Scholar] [CrossRef] [Scilit]
- Kreuzberger, D.; Kühl, N.; Hirschl, S. Machine Learning Operations (MLOps): Overview, Definition, and Architecture. IEEE Access 2023, 11, 31866–31879. [Google Scholar] [CrossRef] [Scilit]
- Paleyes, A.; Urma, R.-G.; Lawrence, N.D. Challenges in Deploying Machine Learning: A Survey of Case Studies. ACM Comput. Surv. 2022, 55, 1–29. [Google Scholar] [CrossRef] [Scilit]
- Bayram, F.; Ahmed, B.S. Towards Trustworthy Machine Learning in Production: An Overview of the Robustness in MLOps Approach. ACM Comput. Surv. 2025, 57, 1–35. [Google Scholar] [CrossRef] [Scilit]
- Moskalenko, V.; Kharchenko, V. Resilience-Aware MLOps for AI-Based Medical Diagnostic System. Front. Public Health 2024, 12, 1342937. [Google Scholar] [CrossRef] [Scilit]
- Jiang, W.; Synovic, N.; Sethi, R.; Indarapu, A.; Hyatt, M.; Schorlemmer, T.R.; Thiruvathukal, G.K.; Davis, J.C. An Empirical Study of Artifacts and Security Risks in the Pre-trained Model Supply Chain. In Proceedings of the 2022 ACM Workshop on Software Supply Chain Offensive Research and Ecosystem Defenses (SCORED ’22), Los Angeles, CA, USA, 7 November 2022; pp. 105–114. [Google Scholar] [CrossRef] [Scilit]
- Meiklejohn, S.; Blauzvern, H.; Maruseac, M.; Schrock, S.; Simon, L.; Shumailov, I. Position: Machine Learning Models Have a Supply Chain Problem. In Proceedings of the 42nd International Conference on Machine Learning (ICML 2025), Position Paper Track, Vancouver, BC, Canada, 13–19 July 2025. [Google Scholar] [CrossRef] [Scilit]
- Pinto Neto, E.C.; Iqbal, S.; Buffett, S.; Sultana, M.; Taylor, A. Deep Learning for Intrusion Detection in Emerging Technologies: A Comprehensive Survey and New Perspectives. Artif. Intell. Rev. 2025, 58, 340. [Google Scholar] [CrossRef] [Scilit]
- Ahsan, M.; Nygard, K.E.; Gomes, R.; Chowdhury, M.M.; Rifat, N.; Connolly, J.F. Cybersecurity Threats and Their Mitigation Approaches Using Machine Learning—A Review. J. Cybersecur. Priv. 2022, 2, 527–555. [Google Scholar] [CrossRef] [Scilit]
- Crankshaw, D.; Wang, X.; Zhou, G.; Franklin, M.J.; Gonzalez, J.E.; Stoica, I. Clipper: A Low-Latency Online Prediction Serving System. In Proceedings of the 14th USENIX Symposium on Networked Systems Design and Implementation (NSDI), Boston, MA, USA, 27–29 March 2017; pp. 613–627. [Google Scholar]
- Olston, C.; Fiedel, N.; Gorovoy, K.; Harmsen, J.; Lao, L.; Li, F.; Rajashekhar, V.; Ramesh, S.; Soyke, J. TensorFlow-Serving: Flexible, High-Performance ML Serving. arXiv 2017, arXiv:1712.06139. [Google Scholar]
- Li, Z.; Chard, R.; Ward, L.; Chard, K.; Skluzacek, T.J.; Babuji, Y.; Woodard, A.; Tuecke, S.; Blaiszik, B.; Franklin, M.J.; et al. DLHub: Simplifying Publication, Discovery, and Use of Machine Learning Models in Science. J. Parallel Distrib. Comput. 2021, 147, 64–76. [Google Scholar] [CrossRef] [Scilit]
- Liu, S.; Shaowang, T.; Wan, G.; Chae, J.; Marques, J.; Krishnan, S.; Feamster, N. ServeFlow: A Fast-Slow Model Architecture for Network Traffic Analysis. arXiv 2024, arXiv:2402.03694. [Google Scholar]
- Zaharia, M.; Chen, A.; Davidson, A.; Ghodsi, A.; Hong, S.A.; Konwinski, A.; Murching, S.; Nykodym, T.; Ogilvie, P.; Parkhe, M.; et al. Accelerating the Machine Learning Lifecycle with MLflow. IEEE Data Eng. Bull. 2018, 41, 39–45. [Google Scholar]
- Seldon Technologies. Seldon Core. Available online: https://github.com/SeldonIO/seldon-core (accessed on 10 September 2026).
- BentoML. BentoML: Unified Inference Platform. Available online: https://www.bentoml.com/ (accessed on 10 September 2026).
- The KServe Authors. KServe. Available online: https://kserve.github.io/website/ (accessed on 10 September 2026).
- Berberi, L.; Kozlov, V.; Nguyen, G.; Sáinz-Pardo Díaz, J.; Calatrava, A.; Moltó, G.; Tran, V.; López García, Á. Machine Learning Operations Landscape: Platforms and Tools. Artif. Intell. Rev. 2025, 58, 167. [Google Scholar] [CrossRef] [Scilit]
- Chandrasekaran, V.; Jia, H.; Thudi, A.; Travers, A.; Yaghini, M.; Papernot, N. SoK: Machine Learning Governance. arXiv 2021, arXiv:2109.10870. [Google Scholar] [CrossRef] [Scilit]
- Butt, T.A.; Iqbal, M.; Arshad, N. From Policy to Pipeline: A Governance Framework for AI Development and Operations Pipelines. IEEE Access 2026, 14, 1373–1397. [Google Scholar] [CrossRef] [Scilit]
- Bedoya, A.D.; Economou-Zavlanos, N.J.; Goldstein, B.A.; Young, A.; Jelovsek, J.E.; O’Brien, C.; Parrish, A.B.; Elengold, S.; Lytle, K.; Balu, S.; et al. A Framework for the Oversight and Local Deployment of Safe and High-Quality Prediction Models. J. Am. Med. Inform. Assoc. 2022, 29, 1631–1636. [Google Scholar] [CrossRef] [Scilit]
- Apache Software Foundation. Apache Airflow. Available online: https://airflow.apache.org/ (accessed on 10 September 2026).
- Kubeflow Project. Kubeflow Pipelines. Available online: https://www.kubeflow.org/docs/components/pipelines/ (accessed on 10 September 2026).
- MITRE Corporation. ATLAS: Adversarial Threat Landscape for Artificial-Intelligence Systems. Available online: https://atlas.mitre.org/ (accessed on 18 June 2026).
- OWASP Foundation. OWASP Machine Learning Security Top Ten, 2023 version; OWASP Foundation: Wilmington, DE, USA, 2023. Available online: https://owasp.github.io/www-project-machine-learning-security-top-10/ (accessed on 4 October 2026).
- Mauri, L.; Damiani, E. Modeling Threats to AI-ML Systems Using STRIDE. Sensors 2022, 22, 6662. [Google Scholar] [CrossRef] [Scilit]
- Patel, R.; Tripathi, H.; Stone, J.; Golilarz, N.A.; Mittal, S.; Rahimi, S.; Chaudhary, V. Towards Secure MLOps: Surveying Attacks, Mitigation Strategies, and Research Challenges. ACM Trans. AI Secur. Priv. 2026; in press. [CrossRef]
- Chen, H.; Babar, M.A. Security for Machine Learning-Based Software Systems: A Survey of Threats, Practices, and Challenges. ACM Comput. Surv. 2024, 56, 1–38. [Google Scholar] [CrossRef] [Scilit]
- Siva Kumar, R.S.; Nyström, M.; Lambert, J.; Marshall, A.; Goertzel, M.; Comissoneru, A.; Swann, M.; Xia, S. Adversarial Machine Learning—Industry Perspectives. In Proceedings of the IEEE Security and Privacy Workshops (SPW), San Francisco, CA, USA, 21 May 2020; pp. 69–75. [Google Scholar] [CrossRef] [Scilit]
- National Institute of Standards and Technology. Artificial Intelligence Risk Management Framework (AI RMF 1.0); NIST AI 100-1; NIST: Gaithersburg, MD, USA, 2023. [CrossRef] [Scilit]
- Chen, Y.; Yan, M.; Yang, D.; Zhang, X.; Wang, Z. Deep Attentive Anomaly Detection for Microservice Systems with Multimodal Time-Series Data. In Proceedings of the IEEE International Conference on Web Services (ICWS), Barcelona, Spain, 10–16 July 2022; pp. 373–378. [Google Scholar] [CrossRef] [Scilit]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license.



