ARCUS: Resilient and Contextually Unified Architecture for Adaptive Threat Detection and Containment in Multicloud Environments

1. Introduction

The digital transformation driven by multicloud architectures, containers, orchestration via Kubernetes, and infrastructure as code (IaC) has substantially redefined the cybersecurity paradigm. Contemporary organizations distribute workloads across Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP), and on-premise environments, integrating public APIs, DevSecOps pipelines, third-party services, and generative AI platforms. This heterogeneity expands the attack surface and introduces nonlinear dependencies among distributed components, making observability and event correlation more difficult.

Recent incidents highlight this systemic complexity. The Log4Shell vulnerability (CVE-2021-44228) demonstrated how widely used libraries can become global vectors for remote code execution. Supply chain compromises, such as the SolarWinds case, exemplify technique T1195 (Supply Chain Compromise) from the MITRE ATT&CK matrix (MITRE, 2024). Verizon reports indicate that the majority of breaches involve human factors or the use of compromised valid credentials, frequently associated with technique T1078 (Valid Accounts) (VERIZON, 2024). In 2025, threats specific to large language models (LLMs) are added, including prompt injection, context exfiltration, and plugin abuse, broadening the scope of risks (OWASP, 2024).

Traditional SIEM, IDS, and IPS solutions, such as Snort (ROESCH, 1999), and modern XDR and CNAPP platforms, although effective in specific scenarios, are often based on signatures, heuristic rules, or predefined correlations. Such mechanisms exhibit structural limitations: high false positive rates, difficulty in cross-domain correlation, and lack of formal guarantees regarding automated containment actions. Purely anomaly-based approaches face the “open world” problem, in which legitimate system variability undermines model robustness (SOMMER; PAXSON, 2010).

We therefore formulate the following research questions:

RQ1: How can multicloud interactions be formally modeled so as to capture temporal and contextual dependencies relevant to the detection of advanced threats, including attacks targeting AI workloads?

RQ2: Is it possible to integrate graph-based deep learning with formal correctness guarantees in automated response orchestration while preserving critical availability invariants?

RQ3: What quantitative gains in accuracy, robustness, and latency can be achieved by a unified and adaptive architecture, compared with solutions based solely on signatures or sequential models?

Our contributions are:

C1: Formalization of a probabilistic temporal graph for unified representation of multicloud events, including runtime telemetry via eBPF and logs from managed services.

C2: Proposal of a detection mechanism based on Graph Attention Networks (VELICKOVIC et al., 2018) with contextual Bayesian inference and dynamic embeddings.

C3: Formulation of containment as a mixed-integer linear programming (MILP) problem with verifiable constraints derived from formal policies, including complexity analysis and partial correctness guarantees.

2. Background and Related Work

2.1 Formal Foundations

We define a multicloud environment as a set of administrative domains $D = {d_1, \dots, d_k}$. Each domain contains entities $E_i$ (users, processes, containers, Kubernetes pods, serverless functions, AI models, and service identities). An event is modeled as the tuple:

$$ e = (s, t, \tau, \alpha) $$

where $s, t \in V$ represent source and destination entities, $\tau \in \mathbb{R}^+$ is the timestamp, and $\alpha \in \mathbb{R}^p$ is a vector of observable attributes (for example, API type, Kubernetes namespace, image hash, prompt embedding).

The system is represented by a probabilistic temporal graph:

$$ G = (V, E, T, \mathbb{P}) $$

in which $T: E \rightarrow \mathbb{R}^+$ associates time with edges and $\mathbb{P}$ defines a distribution over behavioral patterns conditioned on context. Detection is formalized as an inference problem:

$$ f(G_t) = \arg\max_{y \in {0,1}} P(y \mid G_t), $$

where $G_t$ is the subgraph induced by events up to time $t$.

2.2 Related Work

Graph convolutional neural networks (KIPF; WELLING, 2017) and attention mechanisms (VELICKOVIC et al., 2018) have been applied to intrusion detection and lateral traffic analysis. Temporal and dynamic extensions have expanded such models to evolving graphs, maintaining typical complexity $O(|E|d)$ per layer, where $d$ is the embedding dimension.

Architectures based on global attention, such as Transformers (VASWANI et al., 2017), exhibit temporal complexity $O(n^2)$ on long sequences, which motivates the use of graph-structured representations to reduce computational cost in high-cardinality event environments.

In the normative context, NIST SP 800-61r2 (NIST, 2012) and the NIST Cybersecurity Framework 2.0 (NIST, 2024) establish guidelines for incident response, while ISO/IEC 27001:2022 (ISO, 2022) defines requirements for information security management systems. However, such frameworks do not specify formal mechanisms for automated response optimization. In cloud-native environments, CNAPP platforms integrate CSPM, CWPP, and CIEM, but generally lack mathematical formalization of containment guarantees.

3. Threat Model and Problem Formalization

We adopt an adversarial model inspired by Dolev-Yao (DOLEV; YAO, 1983), extended to multicloud environments with federated identity and exposed APIs. The adversary can:

1. Intercept, modify, or redirect communications between services.
2. Compromise valid credentials or OAuth tokens.
3. Execute arbitrary code on vulnerable instances or misconfigured containers.
4. Perform lateral movement, privilege escalation, and persistence.
5. Exploit integrations with AI models, including prompt injection and exfiltration of sensitive context.

Let $A = {a_1, \dots, a_m}$ be the set of techniques mapped to MITRE ATT&CK (MITRE, 2024). We define the global cost function:

$$ \min_{\pi} \mathbb{E}\left[L_{det}(G) + \lambda L_{resp}(\pi)\right], $$

where $L_{det}$ is the detection loss (for example, cross-entropy) and $L_{resp}$ represents operational cost and availability impact associated with policy $\pi$.

Desired properties include:

Partial correctness: no response action violates critical availability or integrity policies formalized as invariants $I$ such that $\forall \pi, ; I(\pi) = \text{true}$.

Probabilistic completeness:

$$ P(f(G)=1 \mid \text{attack}) \geq \theta, $$

for a previously defined threshold $\theta$.

Bounded latency:

$$ \Delta t_{det} < 10,\text{s}. $$

The exact solution of the MILP is NP-hard. We employ branch-and-bound and valid cuts, with exponential worst-case complexity, but acceptable practical performance for $|A| < 50$ and a number of candidate actions limited by pre-filtered policies.

4. Proposed Methodology

4.1 Incremental Graph Construction

Event ingestion is performed incrementally, with amortized complexity $O(|S|)$ for inserting a set $S$ of events, assuming $O(1)$ access to vertices via hashing. Events are normalized according to a common schema and enriched with context (cloud tags, identity, namespace, associated AI model).

4.2 GNN Model with Attention

Embedding updates follow:

$$ h_v^{(l+1)} = \sigma \left( \sum_{u \in \mathcal{N}(v)} \alpha_{vu}^{(l)} W^{(l)} h_u^{(l)} \right), $$

where the attention coefficients are:

$$ \alpha_{vu}^{(l)} = \frac{\exp(e_{vu})}{\sum_{k \in \mathcal{N}(v)} \exp(e_{vk})}. $$

The complexity per layer is $O(|E|d)$. We incorporate temporal embeddings and positional encoding to capture order dependencies while maintaining computational feasibility for streams of millions of events per second.

4.3 Orchestration via MILP

We formulate containment as:

$$ \min \sum_i c_i x_i $$

subject to:

$$ Ax \leq b, \quad x_i \in {0,1}. $$

The constraints $Ax \leq b$ encode formal policies, such as separation of duties, high-availability requirements, and dependencies between services. We show that, if the constraint set is consistent, the optimal solution satisfies security invariants previously specified in linear temporal logic (LTL), whose verification is performed offline.

5. Implementation

Ingestion uses Apache Kafka (APACHE, 2024), with observed throughput of approximately $2{,}3 \times 10^6$ events per second in a distributed cluster. Low-level telemetry on Linux hosts is collected via eBPF, reducing overhead and expanding visibility into system calls. Graph storage uses Neo4j in distributed configuration (NEO4J, 2024).

Model training was performed on NVIDIA A100 GPUs, using the Adam optimizer (KINGMA; BA, 2015). The average inference latency per batch was below $120$ ms, meeting the requirement $\Delta t_{det} < 10$ s even under high load. Scalability was validated up to approximately $1{,}2 \times 10^9$ accumulated events, with horizontal partitioning.

6. Experimental Evaluation

We used the UNSW-NB15 (UNSW, 2015) and CIC-IDS2017 (CIC, 2017) datasets, supplemented by synthetic multicloud scenarios with Kubernetes logs and cloud APIs. Metrics include AUC-ROC, F1-score, true positive rate (TPR), and false positive rate (FPR).

Metric	ARCUS	Baseline GCN	Signature-based IDS
AUC-ROC	$0{,}982 \pm 0{,}004$	$0{,}951$	$0{,}887$
F1-score	$0{,}964 \pm 0{,}006$	$0{,}921$	$0{,}854$
TPR	$97{,}8%$	$93{,}2%$	$88{,}5%$
FPR	$1{,}9%$	$3{,}8%$	$6{,}4%$

A two-tailed Student’s t-test indicated $p < 0{,}01$ in comparison with the baselines, suggesting a statistically significant difference. We observed a consistent reduction in false positives, a critical factor for large-scale SOC environments.

7. Discussion

Probabilistic temporal graph modeling makes it possible to capture approximate causality and structural dependencies among identities, workloads, and AI services. Integration with MILP provides a partial correctness guarantee under explicit constraints, mitigating the risks of overly aggressive automated responses.

Limitations include the initial computational cost of training (approximately $18$ hours) and dependence on the quality and completeness of logs. Environments with fragmented telemetry may compromise probabilistic inference. Even so, the architecture demonstrates practical viability in large-scale scenarios.

8. Conclusion and Future Work

ARCUS demonstrates that the integration of formal modeling, GNNs, and verifiable optimization yields measurable gains in accuracy, robustness, and latency in contemporary multicloud environments. The explicit formalization of invariants and constraints distinguishes the approach from purely heuristic solutions.

As future work, we propose investigating secure federated learning across multiple organizations, incorporating post-quantum cryptographic mechanisms to protect cross-domain telemetry, and automated policy verification via LTL and incremental model checking.

References

APACHE SOFTWARE FOUNDATION. Apache Kafka Documentation. 2024. Available at: https://kafka.apache.org/documentation/.

CIC. CIC-IDS2017 Dataset. 2017. Available at: https://www.unb.ca/cic/datasets/ids-2017.html.

DOLEV, D.; YAO, A. C. On the security of public key protocols. IEEE Transactions on Information Theory, v. 29, n. 2, p. 198–208, 1983. Available at: https://ieeexplore.ieee.org/document/1056650.

ISO. ISO/IEC 27001:2022 Information security management systems — Requirements. 2022. Available at: https://www.iso.org/standard/27001.

KINGMA, D.; BA, J. Adam: A Method for Stochastic Optimization. ICLR, 2015. Available at: https://arxiv.org/abs/1412.6980.

KIPF, T.; WELLING, M. Semi-Supervised Classification with Graph Convolutional Networks. ICLR, 2017. Available at: https://arxiv.org/abs/1609.02907.

MITRE. ATT&CK Framework. 2024. Available at: https://attack.mitre.org/.

NEO4J. Neo4j Documentation. 2024. Available at: https://neo4j.com/docs/.

NIST. Computer Security Incident Handling Guide (SP 800-61r2). 2012. Available at: https://csrc.nist.gov/publications/detail/sp/800-61/rev-2/final.

NIST. Cybersecurity Framework 2.0. 2024. Available at: https://www.nist.gov/cyberframework.

OWASP. OWASP Top 10 for Large Language Model Applications. 2024. Available at: https://owasp.org/www-project-top-10-for-large-language-model-applications/.

ROESCH, M. Snort: Lightweight intrusion detection for networks. In: USENIX LISA. 1999. Available at: https://www.usenix.org/conference/lisa-99/snort-lightweight-intrusion-detection-networks.

SOMMER, R.; PAXSON, V. Outside the Closed World: On Using Machine Learning for Network Intrusion Detection. IEEE Symposium on Security and Privacy, 2010. Available at: https://ieeexplore.ieee.org/document/5504793.

UNSW. UNSW-NB15 Dataset. 2015. Available at: https://research.unsw.edu.au/projects/unsw-nb15-dataset.

VASWANI, A. et al. Attention Is All You Need. NeurIPS, 2017. Available at: https://arxiv.org/abs/1706.03762.

VELICKOVIC, P. et al. Graph Attention Networks. ICLR, 2018. Available at: https://arxiv.org/abs/1710.10903.

VERIZON. Data Breach Investigations Report 2024. 2024. Available at: https://www.verizon.com/business/resources/reports/dbir/.