Agentic and LLM-Based Multimodal Anomaly Detection: Architectures, Challenges, and Prospects

1. Introduction

Anomaly detection is increasingly becoming crucial for ensuring the reliability, security, and optimal performance of complex systems across a wide range of domains. From industrial manufacturing [1,2] and financial services [3] to healthcare [4], cybersecurity [5,6,7,8,9], and autonomous systems [10], the early identification of abnormal patterns plays a vital role in preventing costly failures, supporting timely decision-making, and mitigating risks. At its core, anomaly detection involves identifying data patterns that deviate from expected or normal behavior [11,12]. These anomalies often signify critical events or faults: for instance, unusual network traffic may suggest a cyberattack, aberrant sensor readings could indicate impending equipment failure, and outlier financial transactions might reveal fraudulent activity. Because anomalies typically represent rare but significant occurrences, anomaly detection has been extensively studied in the past few years [13,14,15].

Figure 1. Agentic anomaly detection.

Figure 1. Agentic anomaly detection.

Conventional anomaly detectors have typically modeled a single data modality and a fixed normal profile (e.g., via statistical thresholds, one-class SVMs, nearest-neighbor, or density models). However, the explosion of data complexity and volume has challenged these methods. Deep learning has become a dominant paradigm in recent years. Pang et al. [16] highlight that deep anomaly detection (using autoencoders, GANs, normalizing flows, etc.) has emerged as a critical direction with unique problem complexities [17]. These methods can learn rich representations of normal data, but most still assume a single input modality or sensor [18,19]. As a result, purely single-modal approaches may miss anomalies that only manifest when multiple data sources are considered together. To address this, multimodal anomaly detection has gained prominence. Modern systems often have heterogeneous sensors (e.g., image, audio, thermal, etc.), and fusing their information can improve robustness [20,21]. Lin et al. [22] presents unsupervised industrial anomaly detection that integrates RGB images with 3D scans and yields much better performance than either alone. Similarly, Li et al. [23] introduce MulSen-AD, a multi-sensor anomaly dataset that unifies RGB cameras, laser scans, and infrared thermography. Other domains see analogous trends: in robotics, for example, anomaly detectors now combine proprioceptive signals (forces, motions) with visual-language models to capture both mechanical and environmental failures [24]. In surveillance, fusing video and audio cues has been explored to capture anomalies that are invisible in vision alone. In general, modern anomaly detection increasingly relies on multi-modal inputs to capture complex anomalies that single sensors might miss [23].

Another recent development is agentic AI, autonomous, goal-driven AI agents that can reason, plan, and use tools with minimal human intervention [25]. Agentic AI is designed to pursue complex goals with characteristics such as adaptability and decision-making under uncertainty [26]. Unlike conventional or purely generative AI, agentic systems are built to operate in uncontrolled environments, setting their own subgoals and using external tools or information as needed [27]. Many modern large language model (LLM) applications (e.g., AutoGPT, ReAct agents, and tool-augmented chatbots) fall under this paradigm. Agentic anomaly detection offers the ability of such systems to incorporate reasoning, context, and tool use into the detection process. For instance, LLM-based agents can utilize contextual knowledge, parse unstructured data (such as system logs or maintenance notes), and iteratively refine anomaly criteria. Recently, several agentic and multimodal anomaly detection methods have been proposed. Russell-Gilbert et al. [28] demonstrate framing time-series anomaly detection as a language task, using a pre-trained LLM to interpret sensor readings in context without retraining. Liu et al. [17] present a method that combines generative diffusion models with LLMs for human-interpretable anomaly explanations and contextual reasoning. In practice, agentic anomaly systems autonomously query multiple data sources (e.g., visual feeds, databases, knowledge graphs) and apply chain-of-thought reasoning to decide if an anomaly is significant.

Several recent works on anomaly detection provide extensive surveys on conventional and deep learning-based methods. Chandola et al. [11] established foundational taxonomies across multiple application domains. Chalapathy et al. [29] and Pang et al. [16] specifically addressed deep learning techniques, categorizing key neural architectures and methodological advances. Domain-specific reviews such as Cook et al. [30] target IoT-based systems, while Erhan et al. [31] focus on sensor-centric anomaly detection. Moreover, Choi et al. [32] and Garg et al. [33] provided practical guidelines, benchmarking methodologies, and comparative evaluations. However, despite this progress, no existing survey comprehensively focuses on the intersection of agentic and multimodal anomaly detection.

In this paper, we fill this gap by providing a comprehensive and up-to-date synthesis of recent advancements in anomaly detection that leverage both agentic AI systems (autonomous, reasoning-capable agents) and multimodal data integration frameworks. We present a unified taxonomy, compare key methods, identify prevailing trends, and outline open research challenges in this rapidly evolving field. Specifically, the contributions of this work are:

• We provide a structured survey of anomaly detection approaches that incorporate both agentic AI and multimodal data fusion.
• We introduce a novel taxonomy to classify existing methods based on agent architecture (single-agent vs. multi-agent), reasoning capability, tool integration, and modality scope.
• We review recent benchmark datasets and evaluation methods for multimodal anomaly detection.
• We present key challenges and summarize mitigation strategies and future directions in agentic and multimodal anomaly detection.

The remainder of the paper is organized as follows: Section 3 and Section 4 review multimodal anomaly detection methods and fusion techniques. Section 2 discusses agentic anomaly detection and classifies agent architectures and capabilities. Section 5 summarizes multimodal anomaly detection datasets and benchmarks. Section 6 highlights key challenges, mitigation strategies, and open research problems. Finally, Section 7 concludes the paper and outlines future research directions.

2. Agentic Anomaly Detection

Agentic anomaly detection (AAD) extends conventional anomaly detection paradigms by integrating autonomy, reasoning, and tool use into detection pipelines. These systems, often built upon large language models (LLMs) or reinforcement learning (RL) agents, enable dynamic decomposition of complex tasks, contextual interpretation of multimodal signals, and adaptive orchestration of detection tools and models. In conventional anomaly detection, a scoring function $s\left(x\right)$ is defined for input x and flags an anomaly if $s\left(x\right)$ exceeds a threshold $\tau$ (or equivalently if the estimated probability of x being generated by a normal data distribution falls below some value $\alpha$). Unlike static detectors, agentic systems possess the ability to interact with external knowledge sources, communicate between agents, and iteratively refine their predictions based on observations and reasoning outcomes. Agentic systems transform the one-shot detection function into an interactive process that can incorporate external knowledge and multi-step reasoning to improve accuracy and explainability. We categorize agentic AD methods along three principal paradigms: agent architecture, agent capability, and modality scope. Table 1 summarizes representative agentic AD frameworks and their attributes.

2.1. Architectures

Agentic anomaly detection frameworks can be broadly categorized into two architectural paradigms: single-agent systems and multi-agent systems. A single-agent system relies on one central intelligent agent (typically an LLM or a single RL policy) responsible for the end-to-end anomaly detection task. In contrast, a multi-agent system decomposes the detection pipeline into specialized components, each operated by a dedicated agent with clearly defined roles and responsibilities. Below, we discuss these architectures and their internal operation.

2.1.1. Single-Agent Systems

Single-agent AD frameworks operate with a single decision-making entity and often take on one of two roles: (i) a tool-augmented orchestrator or (ii) a reasoner. In the first setup, an LLM-based agent serves as a central controller that interfaces with external analytics tools, databases, or knowledge graphs to enrich its decision-making. The agent functions as an orchestrator that queries tools and synthesizes their results before making a final anomaly judgement. For example, Timms et al. [38] introduce a GPT-4-based maritime anomaly detection system that augments LLM capabilities with access to sensor logs, environmental databases, and a domain-specific knowledge graph. In the second role, the agent utilizes the inferential and few-shot reasoning abilities of LLMs to derive human-interpretable rules or patterns from normal data and then uses those rules to detect anomalies in new data. Yang et al. [39] propose AnomalyRuler, a two-stage zero-shot AD framework for video streams using GPT-4V. The agent first induces behavioral rules from a few-shot set of normal videos and then applies these rules to detect and explain anomalies in unseen data. Similarly, Zhang et al. [40] introduce LogSAD, which combines GPT-4V, CLIP, and SAM to form a rule-based vision-language system. By generating compositional rules aligned with industrial visual anomalies, LogSAD detects structural defects beyond the reach of conventional pixel-level models without model fine-tuning.

2.1.2. Multi-Agent Systems

Multi-agent systems adopt a distributed approach where multiple specialized agents cooperate to accomplish the anomaly detection task. The agents may operate in sequence or in parallel and can even oversee each other’s performance. We distinguish two common patterns: collaborative pipelines, in which agents collectively execute different stages of a detection workflow, and oversight architectures, in which certain agents monitor or verify the actions of others to ensure reliability and coherence.

• Collaborative Pipelines: In a collaborative multi-agent pipeline, each agent is assigned a specific subtask (data preprocessing, feature extraction, anomaly scoring, explanation, etc.), and the output of one agent feeds into the input of the next. If we label the agents $A_1,A_2,\dots ,A_N$ as they appear in the pipeline, the overall detection function can be viewed as a composite of their operations:

  $$y=A_N\left(A_{N-1}(\dots A_2\left(A_1\left(x\right)\right)\dots )\right),$$

  (1)

  where x is the initial input and y the final anomaly decision or score. Each $A_i$ focuses on a delimited aspect of the task, and their coordination can be managed via an LLM-based planner. For example, Gu et al. [34] propose ARGOS, a multi-agent time-series AD framework that autonomously generates, validates, and refines detection rules using collaborative agents. Similarly, Yang et al.[35] introduce AD-AGENT, which employs a team of LLM agents to interactively build a complete anomaly detection pipeline from a high-level user instruction. Not all pipelines are strictly sequential; some agents might work in parallel on different data streams or features. For instance, Qin et al. [44] propose MAS-LSTM, where multiple LSTM-based detector agents each monitor a different subset of IIoT sensor streams, and anomalies are decided by voting or averaging their scores.
• Oversight Agents: As agentic systems become more complex, ensuring reliability and consistency is essential. Oversight architectures introduce dedicated agents that monitor and verify the outputs of task-oriented agents, effectively performing anomaly detection on the multi-agent system itself. These agents catch logical inconsistencies, hallucinations, or coordination failures that could compromise anomaly decisions. Formally, let $\left\{o_i\right\}$ be a collection of observations or outputs from various agents during an investigation; the oversight agent computes a consistency score or logical coherence measure $C(o_1,o_2,\dots ,o_k)$ over these. If C falls below a threshold (indicating incoherence or inconsistency), the oversight agent flags a meta-anomaly and can intervene (e.g., by resetting certain agents or requesting additional information). This adds a layer of fault tolerance and accountability to the agentic AD pipeline. For example, He et al. [36] propose SentinelAgent, which deploys an LLM oversight agent to supervise a team of collaborating agents. Similarly, in the Audit-LLM framework for security logs [37], a critic agent reviews the decisions made by a Detector agent and either approves them or asks for refinement, ensuring that high-stakes anomaly alerts

2.2. Agent Capability

The rapid development of autonomous agents has led to frameworks with varying depths of reasoning and autonomy. Plaat et al. [27] categorize agents by their ability to reason, act, and interact, emphasizing how agents decompose tasks, use external tools, and collaborate towards goals. Building on this idea, we classify agentic anomaly detection systems by their functional capabilities, resulting in four major categories: detection-only agents, reasoning agents, tool-using agents, and planner agents. Table 2 summarizes these categories, including key examples, strengths, and limitations.

2.2.1. Detection-Only Agents

These agents operate similarly to traditional anomaly detectors, except an LLM (or other foundation model) is used to directly produce anomaly labels or scores from the raw input, without performing explicit multi-step reasoning or tool use. In other words, the agent’s policy is essentially a single-step mapping $f:x\mapsto y$. For instance, one can prompt a large language model to output whether an input is anomalous or not in a zero-shot approach:

$$y=LLM\left(Prompt\right(x\left)\right),$$

(2)

where the prompt might be a template converting x (which could be a time series, log message, etc.) into a descriptive question for the LLM and y is the model prediction. Detection-only agents forego complex reasoning in favor of direct inference, making them straightforward to deploy and fast at runtime. Yang et al. [49] introduces AD-LLM, the first benchmark to evaluate the capabilities of LLMs for zero-shot anomaly detection, data augmentation, and model selection. Cao et al. [50] introduce TAD-Bench, a benchmark that uses state-of-the-art language model embeddings (from BERT, GPT, etc.) combined with classic anomaly detection algorithms (like isolation forests and autoencoders) for text anomalies. In the time-series domain, Alnegheimish et al. [48] propose SigLLM, a framework that serializes time-series data into textual descriptions and then uses an LLM (through prompting) to identify anomalies. Another line of work directly evaluates the zero-shot detection prowess of GPT-4 and similar models on various data. Dong et al. [47] tested GPT-4 on time-series anomaly detection by providing the model with sequences of values as input and asking it to highlight anomalies. Similarly, Derakhshan et al. [51] demonstrates that GPT-4o can effectively detect rework anomalies in business process event logs, achieving high accuracy across different anomaly distributions using zero-shot, one-shot, and few-shot prompting strategies. In general, detection-only agents benefit from the rich prior knowledge of foundation models and their ability to generalize from just a description of the task. They remain useful where low-latency or low-complexity anomaly flagging is required, especially for high-throughput tasks such as real-time sensor screening or log filtering. However, they are prone to the well-known pitfalls of LLMs, such as hallucination and limited transparency.

2.2.2. Reasoning Agents

Reasoning agents incorporate intermediate inference or rule induction into the anomaly detection process, enabling more interpretable and generalizable decisions. Instead of mapping input x directly to an output y, these agents construct a reasoning chain $c_{1:T}$, which guides their final decision:

$$c_{1:T}=\pi \left(x\right),y=f(x,c_{1:T}),$$

(3)

where $c_{1:T}$ represents a sequence of intermediate steps (e.g., logical inferences, verbalized rules, or structured descriptions), $\pi$ is a reasoning policy, and f is a decision function that uses both the input and reasoning trace. These steps act as latent variables, often human-readable, providing explainability. For instance, Yang et al. [39] propose AnomalyRuler, a zero-shot video anomaly detection framework using GPT-4V. The agent first observes normal video clips to induce temporal and behavioral rules, then applies these rules to new data to detect anomalies via chain-of-thought reasoning. Zhang et al. [40] combines GPT-4V and CLIP/SAM to perform logical and structural reasoning over industrial images without any training. Reasoning agents are particularly valuable in domains where explainability or concept-level anomaly interpretation is critical (e.g., surveillance, medical imaging). However, they heavily rely on well-constructed prompts and representative normal examples. Long reasoning chains may also introduce error propagation.

2.2.3. Tool-Using Agents

Tool-using agents augment their own capabilities by calling external tools (knowledge graphs, search engines, anomaly scoring modules, or third-party APIs) during the anomaly detection process. These agents treat tool outputs as additional observations that inform their final decision. We can describe a tool-using agent’s operation in two phases: (1) deciding which tool to use and what query to send, and (2) integrating the tool’s result into anomaly inference. If $q_i$ is a query formulated by the agent and $T_1,T_2,\dots ,T_k$ denotes external tool functions, the final decision could be represented as

$$y=A\left(x;T_1\left(q_1\right),T_2\left(q_2\right),\dots ,T_k\left(q_k\right)\right),$$

(4)

where x is the input data (or its derived features), A is the tool-using agent, and y is the output anomaly decision or score. The LLM agent A thus combines raw input with tool outputs $T_i\left(q_i\right)$ to produce a context-informed anomaly assessment. For example, Timms et al. [38] propose a GPT-4-based maritime anomaly detector that ingests real-time vessel sensor logs with queries from external maritime knowledge graphs and weather APIs. He et al. [36] propose SentinelAgent, a framework that uses a graph-based oversight model where agents query external APIs and maintain long-term tool state. He et al. [41] introduce VLM4TS, which reformulates time series into vision-language representations and then uses GPT-4V and retrieval tools to reason about anomalies. Gu et al. [34] propose ARGOS, which integrates LLM-generated rules with classical rule-based methods for time-series anomaly detection in cloud infrastructure. Tool-using agents blend the power of LLMs with domain-grounded computation. They are suitable for hybrid setups such as industrial pipelines with structured anomaly detection.

2.2.4. Planner Agents

Planner agents orchestrate multi-step workflows for anomaly detection, combining reasoning, action selection, and coordination across tools or sub-agents. These agents are capable of decomposing high-level goals into executable plans, managing task dependencies, and adapting dynamically to intermediate outcomes. Formally, a planner seeks an optimal action sequence ${\Pi }^{*}$ from a space of possible action sequences $\mathcal{S}$ that maximizes some utility (e.g., detection accuracy or information gain):

$${\Pi }^{*}\left(x\right)=arg\underset{\Pi \in \mathcal{S}}{max}U\left(\Pi ;x\right),$$

(5)

where $\Pi =[a_1,a_2,\dots ,a_n]$ is a sequence of actions, such as invoking tools, querying sub-agents, or acquiring new data. In practice, planners often use heuristic or learned strategies rather than solving this optimization exactly, but the formulation emphasizes the agent’s need to anticipate consequences and coordinate across steps. A representative example is Audit-LLM [37], a framework for insider threat detection in audit logs. An LLM-based planner (Coordinator) oversees three roles: a Decomposer breaks high-level questions into queries, an Executor runs them on the log data, and a Critic validates the results. The planner governs when to trigger deeper analysis or terminate the investigation, enabling adaptive depth. In the financial domain, Park et al. [3] design a multi-agent planner that coordinates tasks like searching external sources (e.g., news or market data), running anomaly checks, and synthesizing findings into a final report. ARGOS [34] also includes a planning component that iteratively refines anomaly detection rules by designing and validating experiments. This allows the system to not only detect but also improve its detection logic over time. Planner agents are best suited for real-world, multi-stage, and high-stakes AD scenarios where the detection task requires exploration, hypothesis testing, or intervention. However, their complexity presents challenges: debugging multi-step plans is difficult, coordination errors may arise, and latency increases with plan depth. Moreover, ensuring safe and reliable behavior in these agents remains an open problem.

2.3. Modality Integration

Modern anomaly detection (AD) systems are increasingly required to handle diverse data sources from heterogeneous sensor streams or data sources. Agentic AD methods can therefore be distinguished by their modality scope. A unimodal agent specializes in a single data modality, whereas a multimodal agent is designed to fuse and reason over multiple modalities.

2.3.1. Unimodal Agentic Detectors

Unimodal agents specialize in one modality, such as vision, time series, or logs. These agents are particularly effective in domains where anomalies are confined to a single data type. For example, Dong et al. [47] treat GPT-4 as a time-series agent by prompting it with numeric sequences to identify abnormal patterns. Zhu et al. [43] introduce ALFA, a vision-language model that performs zero-shot image anomaly detection by generating visual descriptions from image inputs and identifying deviations, effectively acting as a vision-centric unimodal agent. Audit-LLM [37], focused on event logs and metadata, operates entirely within the textual domain, making it a log/text unimodal agent. Unimodal agents provide simpler architectures, lower data alignment complexity, and efficient computation due to reduced input dimensionality. However, they are less effective when anomalies emerge from cross-modal interactions.

2.3.2. Multimodal Agentic Detectors

Multimodal agents process and reason over multiple data modalities, such as vision, time series, text, or structured metadata, to detect anomalies that are only apparent through their interaction. These agents must solve two core challenges: (i) fusing features from heterogeneous modalities and (ii) performing cross-modal reasoning to detect inconsistencies or correlations. These agents must align features across modalities and perform joint reasoning. A common solution is to extract features from each modality and combine them in a shared representation:

$$z^{\left(i\right)}={\varphi }_i\left(x^{\left(i\right)}\right),z=[z^{\left(1\right)},z^{\left(2\right)},\dots ,z^{\left(M\right)}],$$

(6)

where ${\varphi }_i$ is a modality-specific encoder and $[·]$ denotes fusion (e.g., concatenation or attention). An anomaly score $s\left(z\right)$ or decision function is then applied, often via an LLM or neural classifier. For example, SentinelAgent [36] fuses textual inter-agent messages with structured environment state to detect coordination failures. LogSAD [40] jointly analyzes industrial images and machine logs to detect visual–textual inconsistencies. VLM4TS [41] reformulates time series as image–text pairs and analyzes them using GPT-4V, effectively treating time-series anomalies as vision-language problems. Similarly, the maritime anomaly detection system by Timms et al. [38] combines numeric sensor data with knowledge graph context to reason about situational normality. Multimodal agents are particularly useful in ambiguous or noisy settings, where cross-modal evidence reduces uncertainty. Mathematically, such agents implicitly learn the joint distribution $P(x^{\left(1\right)},x^{\left(2\right)},\dots ,x^{\left(M\right)})$, enabling them to detect anomalies in the co-occurrence structure. These agents also enhance explainability by pointing to complementary evidence. However, they come with added complexity: synchronization across modalities, higher model capacity, and potential complexity if one modality introduces noise.

3. Multimodal Anomaly Detection

Multimodal anomaly detection (MAD) methods detect anomalous patterns by jointly analyzing data from heterogeneous or multiple modalities, such as images, video, audio, text/logs, and sensor streams [22,52]. Traditional anomaly detection methods often operate within a single modality, but recent advances in deep learning and foundation models have enabled the fusion of heterogeneous sources, leveraging cross-modal context to improve robustness, interpretability, and generalization [53,54]. The emergence of large multimodal models (LMMs), vision-language models (VLMs), and LLMs with reasoning capabilities has further accelerated this shift, enabling more powerful and generalizable anomaly detection pipelines. Recently, multimodal AD methods are utilized in industrial inspection, video surveillance, autonomous systems, and more. In industrial quality control, multimodal AD often fuses visual (RGB camera) and 3D information (depth or point clouds) to detect manufacturing defects. Depth data can reveal surface anomalies or misalignments invisible in color images, significantly improving detection under varying lighting or textures [55]. In multimodal video AD systems, video frames and synchronized audio are combined so that visual cues capture physical actions, while audio can signal alarms [56]. In robotics and autonomous systems, heterogeneous modalities are fused to detect anomalies in robot behavior or environment interactions [24]. We categorize recent advances in MAD into three primary paradigms: foundation models, cross-modal fusion models, and multimodal augmentation and synthesis. Table 3 outlines representative recent methods, their modalities, and key innovations:

3.1. Foundation Models

Foundation models such as CLIP, GPT-4V, and MiniGPT-4 are increasingly applied to MAD as unified encoders and interpretable reasoning agents. These models embed multimodal inputs into shared semantic spaces, enabling zero-shot or few-shot anomaly detection with natural language explanations [62]. Ren et al. [39] provide a taxonomy of foundation-model anomaly detectors as encoders, detectors, or interpreters, highlighting their strengths in anomaly representation, direct detection, or explanation generation. In practice, foundation models enable detecting anomalies across modalities with minimal supervision. However, pre-trained foundation models may lack domain-specific sensitivity or precision. Recent works demonstrate that specialized prompting and multimodal instruction tuning significantly improve both detection accuracy and the interpretability of reasoning outputs relative to generic foundation models. For instance, Anomaly-OV [63] integrates GPT-4o with a Look-Twice Feature Matching mechanism to achieve strong zero-shot performance and reliable anomaly descriptions on manufacturing benchmarks (e.g., using Anomaly-Instruct-125k and datasets like VisA-D&R), significantly outperforming generic LLMs. Similarly, LogSAD uses a match-of-thought architecture with GPT-4V, CLIP, and SAM to detect both structural and logical defects in industrial images without any training while also generating compositional rules and calibrated anomaly scores [40].

3.2. Cross-Modal Fusion Models

Cross-modal fusion models effectively combine heterogeneous modalities, such as vision, audio, time series, and text, during model training or inference to improve anomaly detection performance. Peng et al. [64] introduce AVadCLIP, which fuses audio and visual inputs via CLIP embeddings, adaptive audio-visual prompts, and uncertainty-driven distillation to enhance detection under noise and occlusion. Ghadiya et al. [56] propose a Cross-Modal Fusion Adapter (CFA) with hyperbolic graph attention to dynamically balance audio-visual streams, yielding state-of-the-art weakly supervised video AD performance. Barusco et al. [65] adapt vision-based localization methods to spectrograms, enabling fine-grained temporal-frequency anomaly detection in audio with improved interpretability. Lee et al. [66] present CLIPFUSION, which combines CLIP’s global discriminative features with conditional diffusion-based reconstruction to jointly improve segmentation and classification on MVTec-AD and VisA datasets. Meanwhile, Wang et al. [67] introduce STADNet, a dual-stream 3D-convolutional model with spatio-temporal attention that fuses RGB and motion for improved surveillance anomaly detection on benchmarks like UCSD Ped2. Finally, Qu et al. [68] propose MFGAN, which integrates temperature, vibration, and acoustic sensor data via attention-based autoencoders to enhance anomaly detection in industrial manufacturing, achieving higher F1 scores than unimodal baselines. These cross-modal fusion methods consistently demonstrate that leveraging complementary modalities significantly enhances anomaly detection performance in both controlled and real-world environments.

3.3. Multimodal Augmentation

Multimodal generative frameworks augment anomaly detection pipelines by simulating rare or hard-to-label anomalies using domain knowledge and conditional generation. For instance, Key Knowledge Augmentation (KKA) [69] uses an LLM to synthesize plausible hard vs. easy anomalies based on domain knowledge, enriching training data and improving classifier boundaries. In audio, FS-TWFR-GMM [70] leverages metadata (e.g., machine types) with diffusion-based generation to simulate anomalies in zero- or few-shot scenarios. Such approaches blur the line between generative modeling and anomaly detection, with LLMs or multimodal models serving both as data generators and reasoning engines. The agentic and multimodal paradigm also extends to more specialized domains. In robotic processes, context-sensitive visual anomaly detection is enabled by combining procedural text with visual inputs through hierarchical VLM prompting [71]. In medical imaging, masked diffusion models trained on healthy scans can detect subtle pathologies without labels [72], while vision-language models promise even richer context-aware anomaly detection in future healthcare applications.

4. Multimodal Fusion Methods

In multimodal anomaly detection, fusion methods determine how data, features, or decisions from each modality are combined to produce an anomaly score or classification. Fusion strategies can be categorized based on when the modalities are combined (fusion level) and how they are combined (fusion operation).

Figure 2. Multimodal Fusion Methods.

Figure 2. Multimodal Fusion Methods.

4.1. Fusion Stages

Fusion stages can be broadly categorized into early (data-level), intermediate (feature-level), and late (decision-level) fusion, depending on the stage at which modalities are combined within the processing pipeline. Recent multimodal anomaly detection systems often combine multiple fusion levels for improved robustness. For example, a system might perform intermediate fusion between closely related modalities while also applying a late fusion to incorporate a separate expert model decision. There are also hierarchical fusion architectures that integrate modalities at multiple stages (e.g., fusing some modalities early and fusing again at a higher feature level) to capture both low- and high-level cross-modal interactions. Additionally, multitask or multitier fusion frameworks are emerging approaches where different fusion stages are optimized for different objectives (for instance, earlier layers fuse modalities for a representation learning task, while later layers fuse decisions for a specific anomaly classification task) [73]. In general, early fusion maximizes direct cross-modal interaction, late fusion maximizes modularity, and intermediate fusion seeks a balance; hybrid approaches leverage the benefits of each. Table 4 summarizes common fusion methods along with their advantages and drawbacks.

4.1.1. Early Fusion (Data-Level)

Early fusion concatenates raw or low-level features from all modalities into a joint representation, allowing a single model to learn cross-modal correlations directly. For example, one might concatenate image pixels and depth values channel-wise to form a joint input or merge sensor readings into one feature vector before anomaly modeling. Costanzino et al. [55] propose mapping depth and RGB features via a lightweight cross-modal feature mapper during inference, detecting anomalies by inconsistencies between observed and mapped features. Beyond simple concatenation, some approaches fuse RGB frames with optical flow and depth in a unified tensor before passing through a single network [74]. In log-based monitoring, early fusion has also been applied by integrating multiple system log streams into one high-dimensional feature vector for end-to-end anomaly detection [75]. Early fusion captures direct correlations between modalities from the start but can be susceptible if modalities are not well-aligned or if one modality has much higher dimensionality (it may dominate the representation) [56]. In practice, early fusion is simple but may force the model to learn a very complex mapping from heterogeneous raw data to anomalies.

4.1.2. Intermediate Fusion (Feature-Level)

In feature-level fusion, each modality is first processed by a dedicated encoder to extract higher-level features, and fusion occurs at one or more intermediate layers of the network. For instance, a framework might include a CNN to encode images and an RNN to encode time-series sensor data; their latent feature representations $h^{\left(1\right)}$ and $h^{\left(2\right)}$ are then fused (e.g., concatenated or combined via attention) at a certain layer to produce a joint representation for anomaly detection. This approach allows each modality to contribute more distilled, modality-specific features to the fusion, often making the combined representation more informative [76,77]. The fusion point can be a single layer or multiple layers (multi-stage fusion). A common pattern is a dual-stream (or multi-stream) network that processes modalities separately up to a point and then merges their feature streams. Choosing the right layer (or layers) at which to fuse is critical: fusing too early might mix noisy, incompatible raw signals, whereas fusing too late might fail to capture important cross-modal interactions that could be learned at intermediate levels [59]. Learnable fusion operations such as attention or gating can be inserted at the fusion layer to adaptively weight the contributions of each modality. Intermediate fusion thus aims to balance modality specialization with cross-modal learning.

4.1.3. Late Fusion (Decision-Level)

Late fusion involves training separate models for each modality and combines their anomaly scores or decisions via methods such as weighted sums, majority voting, dynamic gating, or mixture-of-experts schemes [78]. This approach treats each modality expert independently up to the decision stage, offering straightforward implementation and modular explainability. It is particularly useful when modalities are largely independent or when safety-critical applications demand that any single modality alone can trigger an alert. However, because it relies on heuristics or separate reconciliation models, late fusion does not learn an integrated cross-modal representation and may struggle when modalities produce conflicting signals. Adaptive late fusion methods, such as mixture-of-experts, address this by learning confidence weights for each expert. For instance, Willibald et al. [24] propose a mixture-of-experts framework combining a Gaussian-mixture regression detector on proprioceptive signals with a CLIP-based visual-language model, dynamically selecting the most reliable expert at inference. Lin et al. [22] explore a dynamic weighting of video and audio anomaly scores based on environmental conditions.

4.2. Fusion Operations/architectures

Fusion operations or architectures determine how modalities are combined. Formally, let $h^{\left(1\right)}$ and $h^{\left(2\right)}$ be feature representations from two modalities (these could be raw inputs in an early-fusion setting or intermediate features in a mid-fusion setting). A fusion operation is a function F that combines these representations into a joint feature z:

$$z=F(h^{\left(1\right)},h^{\left(2\right)})$$

(7)

There are many choices for F, ranging from simple arithmetic combinations to complex learned modules. Below, we describe several common fusion operations and modules, along with mathematical formulations and examples from recent anomaly detection literature.

4.2.1. Concatenation

The simplest fusion operation is to concatenate the two feature vectors (denoted $[h^{\left(1\right)};h^{\left(2\right)}]$) into one larger vector, which can then be processed by subsequent layers (often a linear layer or MLP is applied to the concatenated vector to mix the features). For example, one can define

$$z=\varphi \left([h^{\left(1\right)};h^{\left(2\right)}]\right),$$

(8)

where $[h^{\left(1\right)};h^{\left(2\right)}]$ denotes the concatenation of $h^{\left(1\right)}$ and $h^{\left(2\right)}$ and $\varphi$ could be an identity function (direct concatenation) or a learnable transformation (a fully-connected layer). Several multimodal networks use simple concatenation followed by feed-forward layers at the fusion stage [59]. Concatenation preserves all information from both modalities, but it assumes the features are already aligned or comparable in scale, and the burden is on the subsequent layers to identify cross-modal relationships.

4.2.2. Element-wise Addition or Weighted Sum

Another common fusion method is element-wise addition of the feature vectors. If $h^{\left(1\right)}$ and $h^{\left(2\right)}$ are of the same dimensionality, one can fuse by summing corresponding elements: $z=h^{\left(1\right)}+h^{\left(2\right)}$. More generally, a weighted sum allows the model to learn the contribution of each modality:

$$z=w_1\odot h^{\left(1\right)}+w_2\odot h^{\left(2\right)},$$

(9)

where $w_1$ and $w_2$ are scalar weights or weight vectors (learned or set by prior knowledge) and ⊙ denotes element-wise multiplication (scaling each feature). This operation effectively averages or emphasizes modalities in each feature dimension. Addition-based fusion is computationally cheap and treats the two feature sets symmetrically. For instance, some network architectures treat a secondary modality as an extra channel appended to the primary modality and use element-wise addition in intermediate layers to blend the information [55]. A variant of weighted sum fusion is to use a gating mechanism that dynamically adjusts weights based on the data. In a gating approach, a function (often a small neural network with a sigmoid activation) computes a gating factor $\alpha$ between 0 and 1 from the inputs:

$$\alpha =\sigma \left(W[h^{\left(1\right)};h^{\left(2\right)}]\right),$$

(10)

where W is a learnable weight matrix and $\sigma$ is the sigmoid function. Then the fused output is

$$z=\alpha \odot h^{\left(1\right)}+(1-\alpha )\odot h^{\left(2\right)}.$$

(11)

Here $\alpha$ (which could be a single scalar or a vector of gating values for different feature dimensions) acts as an adaptive trade-off: if $\alpha$ is close to 1, modality 1 dominates, and if $\alpha$ is close to 0, modality 2 dominates. This kind of gating is used in some attention-fusion modules; for example, the Cross-Modal Feature Attention (CFA) module in an audio-visual fusion model learns a dynamic weight to balance audio and video features for each time frame [56].

4.2.3. Multiplicative or Bilinear Fusion

Multiplicative fusion involves combining features by multiplication interactions rather than addition. The simplest form is element-wise multiplication:

$$z=h^{\left(1\right)}\odot h^{\left(2\right)},$$

(12)

which yields a fused feature where each dimension $z_i=h_i^{\left(1\right)}·h_i^{\left(2\right)}$. This operation can highlight feature dimensions that strongly agree across modalities (if both $h_i^{\left(1\right)}$ and $h_i^{\left(2\right)}$ are high) or dampen those that disagree in sign. Element-wise multiplication requires the two feature vectors to be the same size and implicitly assumes a one-to-one correspondence between their dimensions. A more general form is bilinear fusion, where each feature in one modality is multiplied by each feature in the other modality (an outer product), potentially with learnable weights. A bilinear fusion is defined as:

$$z_{jk}=h_j^{\left(1\right)}·h_k^{\left(2\right)},$$

(13)

which produces a matrix capturing all pairwise interactions between elements of $h^{\left(1\right)}$ and $h^{\left(2\right)}$. This outer product can then be vectorized or passed through pooling layers to form the final fused representation. In practice, it is common to introduce a parameterized bilinear form to control the dimensionality, such as:

$$z={\left(h^{\left(1\right)}\right)}^{\mathsf{T}}W{h}^{\left(2\right)},$$

(14)

where W is a learned matrix or tensor. This yields each component of z as a weighted combination of pairwise products of $h^{\left(1\right)}$ and $h^{\left(2\right)}$ elements. Bilinear fusion can capture complex interactions between modalities and has been employed in some vision–language models and multimodal classifiers [79,80]. However, it typically produces very high-dimensional representations (especially if we explicitly take an outer product) and can easily overfit without large amounts of data or proper regularization.

4.2.4. Attention-Based Fusion

Attention mechanisms adaptively fuse modalities by weighting relevant features from one modality using another. In a cross-attention setup, one modality’s features (the query set) are used to softly select or weight the features of another modality (the key and value set). Formally, given two sets of features $H^{\left(1\right)}=\left\{h_i^{\left(1\right)}\right\}$ and $H^{\left(2\right)}=\left\{h_j^{\left(2\right)}\right\}$, an attention-based fusion can compute for each feature $h_i^{\left(1\right)}$ a weighted combination of the $H^{\left(2\right)}$ features:

$$\mathrm{Attn}\left(h_i^{\left(1\right)},H^{\left(2\right)}\right)=\sum _j{\alpha }_{ij}{h}_j^{\left(2\right)},$$

(15)

where the attention weights ${\alpha }_{ij}$ are given by

$${\alpha }_{ij}={\mathrm{softmax}}_j\left(h_i^{\left(1\right)}{W}_Q{\left(h_j^{\left(2\right)}{W}_K\right)}^T\right)$$

(16)

in a typical formulation (with $W_Q,W_K$ projection matrices for queries and keys, respectively). The result is that each element of one modality can attend to (i.e., extract information from) the elements of another modality that have high content similarity or relevance. The fused representation could be, for instance, the original $H^{\left(1\right)}$ features augmented with these attention outputs, or vice versa. To reduce computational cost, attention bottlenecks introduce B learnable latent vectors $b_1,\dots ,b_B$ as intermediaries [76]. Each modality attends to these bottlenecks (at most $N\times B$ interactions), then reverse-attends back, enforcing a compact shared representation. This two-step bottleneck attention generalizes frameworks such as LB3M for RGB+3D fusion in industrial anomaly detection [55], yielding efficient and effective cross-modal integration. Cross-attention is ideal when modalities align semantically (e.g., synchronized video–audio or image–text). For time-series anomaly detection, MST-GAT uses intra- and inter-modal graph attention to learn sensor correlations and improve anomaly scoring [52]. In video surveillance, stacked cross-attention layers fuse RGB, optical flow, and audio, dynamically weighting cues for superior detection [74,81].

4.2.5. Feature Mapping

Rather than fusing features through arithmetic or attention, this approach uses one modality to reconstruct or predict the features of another. A mapping function M is trained to translate from one modality to another: $M:h^{\left(1\right)}\mapsto {\widehat{h}}^{\left(2\right)}$, where ${\widehat{h}}^{\left(2\right)}$ is the predicted counterpart of $h^{\left(2\right)}$. During inference, the reconstruction error $|{\widehat{h}}^{\left(2\right)}-h^{\left(2\right)}|$ serves as an anomaly score, i.e., large deviations indicate cross-modal inconsistency and potential anomalies. This method exploits the idea that, under normal conditions, modalities agree and can predict each other well. For example, Costanzino et al. map depth to RGB features and vice versa, detecting anomalies when prediction and observation diverge [55]. Beyond direct mapping, more advanced methods integrate contrastive learning and memory mechanisms. Wang et al. propose M3DM for RGB + 3D anomaly detection using patch-wise contrastive learning to align 3D point cloud and image features in a shared embedding space [58]. In general, these methods detect novelty by evaluating how well one modality can explain the other. A failure to do so suggests a modality-specific anomaly that would be missed in unimodal analysis.

4.2.6. Modality and Temporal Alignment

Effective fusion often requires aligning modalities spatially, semantically, and temporally before combining them. In spatially or feature-wise alignment, inputs $x_1,x_2$ are transformed via $f_1\left(x_1\right)$ and $f_2\left(x_2\right)$ into a common space (e.g., projecting depth maps or point clouds onto the image plane so each pixel’s depth and RGB correspond) [55]. Alternatively, contrastive or correlational objectives (e.g., contrastive loss) train feature extractors so that paired inputs yield embeddings $h^{\left(1\right)}$ and $h^{\left(2\right)}$ that coincide, while mismatches diverge. Temporally, modalities sampled at different rates or with offsets must be synchronized. A basic strategy resamples or buffers slower streams (e.g., holding the latest $h^{\left(2\right)}$ constant for multiple $h^{\left(1\right)}$ frames), creating aligned pairs $(h_t^{\left(1\right)},h_{\lfloor t/r\rfloor }^{\left(2\right)})$. More advanced methods employ temporal attention or sequence alignment when events lag across sensors, letting each feature at a time t attend over a window of the other modality timestamps.

4.2.7. Graph-Based Fusion

Graph-based fusion leverages Graph Neural Networks (GNNs) to integrate multimodal information by modeling modalities or components as nodes in a graph, with edges capturing relationships—whether physical, functional, or learned. A GNN then propagates and aggregates information across this graph to produce fused node or graph-level embeddings. In multimodal anomaly detection, each modality (sensor) can be treated as a node, with edges encoding inter-modality dependencies. Through message passing, each node updates its state by blending its own features with those of its neighbors:

$$h_u^{(l+1)}=\sigma \left(W{h}_u^{\left(l\right)}+\sum _{v\in \mathcal{N}\left(u\right)}\Theta h_v^{\left(l\right)}\right),$$

(17)

where $h_u^{\left(l\right)}$ is the representation at layer l, $\mathcal{N}\left(u\right)$ are neighbors, $W,\Theta$ are learnable weights, and $\sigma$ is an activation function. Ektefaie et al. apply this approach to sensor graphs, learning node embeddings that capture both individual and contextual information for anomaly detection [82]. Passos et al. extend this with CCA-GNN, which jointly optimizes GNN embeddings and Canonical Correlation Analysis to enforce cross-modal alignment, helping detect anomalies that disrupt typical inter-modality correlations [83]. Xia et al. propose VLDFNet, which builds a views-graph over 2D projections of 3D data and fuses image and point cloud features via a disentangled latent space [84]. The graph structure enables modeling both intra- and inter-modal relationships, enhancing robustness in anomaly detection. In general, graph-based fusion is well-suited for scenarios where relations between multiple modalities are key to understanding anomalies. It flexibly encodes multimodal interactions by treating modality as another dimension of connectivity in the graph.

4.3. Fusion Design Principles and Trade-offs

Designing effective multimodal fusion requires balancing integration and modularity: modalities should inform each other without allowing noise or irrelevant signals to degrade performance. Recent research suggests several key design principles:

• Fuse at Multiple Levels: Combining mid-level feature fusion with late-stage score fusion enhances robustness. Early fusion may overlook modality-specific noise, while multi-scale fusion captures both structural and semantic information [59].
• Selective Feature Fusion: Not all layers contribute equally to cross-modal alignment. Shallow or mid-level features often provide better spatial or temporal grounding across modalities than very early or late representations.
• Learnable and Adaptive Fusion: Models that use attention, gating, or mixture-of-experts mechanisms dynamically adjust modality contributions, outperforming static fusion strategies. This adaptiveness is especially valuable in heterogeneous or noisy environments [56].
• Efficiency: Fusing mid-level or compact embeddings is computationally efficient compared to raw input fusion. Techniques such as bottleneck layers and dimensionality reduction maintain informativeness while reducing overhead.
• Domain-Specific Design: Fusion should be tailored to the task and data characteristics. For instance, if one modality is unreliable or frequently missing, late fusion provides robustness. If anomalies depend on fine-grained correlations across streams (e.g., visual flashes coinciding with audio spikes), then mid-level feature fusion is essential. Domain knowledge can guide initial architecture choices, with further refinement via ablation or architecture search.

In general, multimodal fusion is not a one-size-fits-all problem. The optimal strategy depends on the nature of the modalities, the anomaly types, and the computational constraints of the deployment scenario.

5. Multimodal Datasets and Benchmarks

Multimodal anomaly detection relies on rich datasets that align multiple sensor modalities such as vision, audio, LiDAR, and text, yet truly multimodal benchmarks remain relatively scarce. Recent progress, however, has led to important datasets featuring synchronized multimodal recordings with detailed ground truth annotations. These datasets typically combine modalities like RGB and LiDAR for driving scenarios, audio and video streams, RGB images with depth information, and multisensor industrial data. Existing benchmarks often lack standardized evaluation metrics and underrepresent certain modality combinations, such as vision-text fusion in industrial anomaly detection or sensor-metadata fusion in manufacturing. The MMAD dataset [85] marks progress toward multimodal language model evaluations, although it primarily emphasizes vision. Table 5 presents multimodal datasets and benchmarks with details including modality, size, anomaly types, and label information.

6. Challenges, Mitigations and Future Works

Although agentic and multimodal anomaly detection systems provide robust anomaly detection, their deployment faces challenges including heterogeneous data fusion, data scarcity, and high inference costs [92]. LLM-based agentic pipelines compound these issues with added complexity surrounding agent coordination, trust, and security [36]. This section outlines key challenges, mitigations, and future research directions.

6.1. Data Scarcity

Anomalies are inherently rare, leading to severe data imbalance and scarcity of labeled examples for training. This scarcity impedes the learning of robust detectors and often biases models toward the abundant normal patterns. A promising solution to such a problem is synthetic anomaly generation using generative models. Early approaches employed GANs to perturb or reconstruct normal data, thereby creating pseudo-anomalies that enrich the training distribution [93]. More recently, diffusion models have shown the ability to produce high-fidelity synthetic anomalies [94,95]. Despite progress, ensuring that synthetic anomalies truly reflect real-world outliers remains a challenge. Future research should refine generative processes using more advanced conditional generation (e.g., text- or class-conditioned prompts to specify the anomaly type) and hybrid GAN–diffusion pipelines.

6.2. Multimodal Representation and Alignment

Multimodal anomaly detection requires integrating multiple data modalities into a unified representation, typically leveraging contrastive learning and attention mechanisms for aligning heterogeneous features [96]. Despite recent advances, modality imbalance and naive feature fusion remain major challenges, often suppressing modality-specific anomalies or limiting subtle cross-modal interactions [96]. Methods such as AVadCLIP and adaptive cross-modal fusion adapters dynamically balance and align modalities by adaptively weighting features based on context [56,64]. Future research must further develop adaptive fusion methods and robust alignment techniques capable of effectively handling missing or noisy modalities.

6.3. Agentic Reasoning and LLM Limitations

LLM-based agents enhance interpretability and reasoning but are prone to hallucination and domain mismatches [97]. Misinterpretations in specialized domains highlight the need for domain-adapted LLMs and structured knowledge integration. Future work should enhance LLM factuality and reasoning alignment and develop benchmarks for evaluating agent reasoning fidelity.

6.4. Real-Time Inference and Scalability

For several practical applications (e.g., security monitoring, autonomous driving), anomaly detection must operate under strict latency and throughput constraints. Complex agent frameworks can be computationally expensive, limiting their real-time use. Recent work has highlighted that detectors often involve very large networks, which are not suitable for cost-effective real-time applications [98]. A promising future direction is model compression and efficiency enhancement. Techniques such as knowledge distillation have demonstrated the ability to transfer anomaly detection capabilities from a heavy teacher model to a lightweight student, achieving similar accuracy with dramatically fewer parameters. Future work should explore dynamic model cascades, online model adaptation for data streams, and hardware-friendly implementations (e.g., via model quantization or edge computing) to ensure scalability.

6.5. Interpretability

Interpretability remains a major challenge in anomaly detection, particularly in high-stakes scenarios. Current approaches focus on generating natural-language rationalizations or employing explainable rule-based reasoning to enhance transparency [97]. Additionally, agent traceability, where each decision or action is logged and auditable, is increasingly emphasized to validate anomaly detection processes. Future work should explore developing intuitive interfaces for anomaly explanation, effective communication of uncertainty, and methods ensuring the reliability and trustworthiness of explanations provided to end-users [97].

6.6. Evaluation and Benchmarking

Evaluation and benchmarking in multimodal and agentic anomaly detection face significant limitations due to the lack of standardized benchmarks and consistent metrics, resulting in difficulties comparing methods across studies [97]. Recent efforts such as the MMAD [85] and AnoVox [99] datasets partially address these gaps but remain domain-specific. To progress, the field requires standardized anomaly taxonomies, evaluation protocols, and benchmarks that can handle complex multimodal and dynamic scenarios.

6.7. Theoretical Foundations

The theoretical underpinning of agentic and multimodal anomaly detection remains insufficient, often relying on empirical heuristics. While progress has been made using graph-based anomaly detection for modeling agent interactions [36], there is a pressing need for rigorous theoretical frameworks that can characterize detector behavior under diverse conditions, establish formal performance bounds, and analyze the complex dynamics of multi-agent systems.

Table 6. Key challenges in multimodal/agentic anomaly detection and prospective research directions.

Challenge	Current Mitigation	Future Directions
Data scarcity	Synthetic-anomaly generation via GANs / diffusion, data augmentation	Advanced conditional generation (text / prompts), hybrid GAN–diffusion approaches, few-shot simulation
Modality alignment	Cross-modal embeddings (CLIP, contrastive losses), feature-fusion layers	Unified multimodal representations (transformers), dynamic fusion strategies, multimodal foundation models
LLM domain mismatch	Prompt engineering, few-shot normal exemplars, rule-based prompting	Domain-adapted LLMs, hybrid neuro-symbolic systems, anomaly-aware fine-tuning
Real-time & scalability	Knowledge distillation (LLM to lightweight student), fast/slow pipelines	Model compression, efficient LLM architectures, adaptive inference scheduling
Benchmarking & evaluation	Emerging datasets (MMAD, AnoVox)	Comprehensive multimodal AD benchmarks & metrics, standardized anomaly taxonomies
Theoretical foundations	Ad-hoc frameworks (e.g., graph models for multi-agent systems)	Formal analysis of LLM-agent behavior, robustness theory, multi-agent anomaly theory

Table 6. Key challenges in multimodal/agentic anomaly detection and prospective research directions.

Challenge	Current Mitigation	Future Directions
Data scarcity	Synthetic-anomaly generation via GANs / diffusion, data augmentation	Advanced conditional generation (text / prompts), hybrid GAN–diffusion approaches, few-shot simulation
Modality alignment	Cross-modal embeddings (CLIP, contrastive losses), feature-fusion layers	Unified multimodal representations (transformers), dynamic fusion strategies, multimodal foundation models
LLM domain mismatch	Prompt engineering, few-shot normal exemplars, rule-based prompting	Domain-adapted LLMs, hybrid neuro-symbolic systems, anomaly-aware fine-tuning
Real-time & scalability	Knowledge distillation (LLM to lightweight student), fast/slow pipelines	Model compression, efficient LLM architectures, adaptive inference scheduling
Benchmarking & evaluation	Emerging datasets (MMAD, AnoVox)	Comprehensive multimodal AD benchmarks & metrics, standardized anomaly taxonomies
Theoretical foundations	Ad-hoc frameworks (e.g., graph models for multi-agent systems)	Formal analysis of LLM-agent behavior, robustness theory, multi-agent anomaly theory

7. Conclusions

Anomaly detection is evolving rapidly to meet the demands of increasingly complex, heterogeneous, and dynamic real-world environments. As intelligent systems become more autonomous and multimodal by design, the integration of agentic reasoning with cross-modal perception is not only natural but necessary. This review has presented a comprehensive overview of recent advances at the intersection of multimodal and agentic anomaly detection, two emerging paradigms that enable more robust, interpretable, and context-aware detection systems. We reviewed foundational work in anomaly detection and highlighted the shift from unimodal, static methods to multimodal fusion frameworks and reasoning-capable agents. We introduced a taxonomy that classifies agentic anomaly detection systems by architecture, capability, and modality scope, and we examined recent benchmarks, tools, and datasets that are driving this research frontier. We also identified core challenges and discussed current mitigation strategies and promising research directions. Future research should prioritize adaptive fusion strategies, theory-grounded agent design, and secure, explainable deployments. We hope this work serves as a foundation for researchers and practitioners seeking to develop next-generation anomaly detection systems that are both perceptually rich and autonomously intelligent.