🤖 machine learning

LLM as Detector: An In-context Learning Approach for Tabular Anomaly Detection

This paper proposes LLM-Detector, a novel framework that leverages in-context learning to convert normal tabular data into structured prompts for code-generated scoring engines, enabling effective anomaly detection across diverse datasets without the need for fine-tuning or neural network training.

Original authors: Tu Anh Hoang Nguyen, Dang Nguyen, Thuc Duy Le, Trung Le, Sunil Gupta

Published 2026-08-21

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Tu Anh Hoang Nguyen, Dang Nguyen, Thuc Duy Le, Trung Le, Sunil Gupta

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the vast, quiet hum of modern data centers, a specific kind of trouble often hides in plain sight. It is not a dramatic explosion or a glaring error, but a subtle wrongness within a spreadsheet of numbers and categories. This is the world of tabular data, the digital ledger that records everything from bank transactions and medical records to server logs and insurance claims. For decades, computers have been tasked with finding the single fraudulent transaction among millions of legitimate ones, or the one sick patient among thousands of healthy ones. The challenge is that these "anomalies" rarely look like obvious mistakes. They often look perfectly normal on the surface, yet they violate the hidden rules that govern how different pieces of information should relate to one another. A person's age, income, and tax bracket usually follow a predictable pattern; when they don't, it signals a problem, even if every individual number seems plausible on its own.

For years, the standard way to catch these hidden errors has been to build complex mathematical models that learn what "normal" looks like, then flag anything that deviates too far from that pattern. More recently, scientists have tried using large language models—the same powerful artificial intelligence systems that can write essays or answer questions—to spot these errors. The idea was that if you could teach a computer to read a row of data like a sentence, it might understand the story behind the numbers better than a calculator could. However, these early attempts faced a significant hurdle: they were either too slow to be useful in real time, or they required the AI to be retrained on new data, which is expensive and computationally heavy. They struggled to handle the messy mix of numbers and text categories that real-world data often contains, often losing the meaning of the data in the process.

A team of researchers from universities in Australia has proposed a different way to solve this puzzle, one that treats the artificial intelligence not as a student to be trained, but as a skilled architect to be given a blueprint. Instead of forcing the AI to learn from scratch or memorize examples, they asked it to write a custom program based on a summary of what normal data looks like. The researchers call this new approach LLM-Detector. Their method relies on a concept called in-context learning, which allows a large language model to perform a complex task simply by being given a clear description of the rules and a few examples, without needing to change its internal brain or undergo a long training process.

The process begins by taking a large collection of normal, healthy data—such as thousands of legitimate bank records—and distilling it down into three key types of information. First, the system calculates the statistical profile of each column, noting the average values, the typical ranges, and how common different categories are. Second, it maps out the causal relationships, figuring out which pieces of information depend on others; for instance, it learns that a high income usually correlates with a specific tax bracket. Third, it selects a small, representative group of actual data points that act as anchors, showing the typical shape and spread of the data. These three elements are then packaged into a single, detailed prompt and sent to the large language model.

The model reads this prompt and, acting as a code generator, writes a complete, executable computer program designed specifically for that dataset. This program is not a guess; it is a set of instructions that knows exactly how to check for statistical oddities, how to spot broken relationships between variables, and how to measure how far a new data point sits from the center of the normal crowd. Once this program is written, it is saved and run against new, unseen data. When a new record arrives, the program instantly calculates an anomaly score, a number that indicates how suspicious the record is. If the score is high, it means the record violates the rules the AI deduced from the normal data.

The researchers tested this method on twenty-four different datasets, ranging from small medical records to massive cybersecurity logs. They compared their approach against fifteen other state-of-the-art methods, including traditional statistical tools, deep learning models, and the previous attempts at using language models for this task. The results showed that their method consistently outperformed the others, particularly in datasets that mixed numbers and text categories. On average, their approach achieved a detection accuracy score of 0.7407, which was higher than the next best method. Crucially, this performance came without the heavy computational cost of training a new model. Because the AI only writes the code once and then steps aside, the system is incredibly fast, taking only a fraction of a second to process data compared to the minutes or hours required by other methods.

The study also explored how different parts of the system contributed to its success. They found that giving the AI just the statistical numbers was helpful, but adding the map of relationships between variables made it significantly better at catching subtle errors. Including the representative examples of normal data further refined the system's ability to understand the overall shape of the data. The researchers also tested the method with different underlying AI models and found that while stronger models performed slightly better, the core design of writing a custom program worked well across the board. This suggests that the power of the method comes from the structure of the approach—translating data into a set of logical rules—rather than relying on a single specific type of artificial intelligence.

By turning the problem of anomaly detection into a task of code generation, the researchers have created a system that is both powerful and practical. It does not require the massive computing power usually associated with advanced artificial intelligence, nor does it need to be retrained every time the data changes. It simply reads the story of what is normal, writes a rulebook for spotting the exceptions, and then applies that rulebook to the real world. This approach offers a promising path forward for industries that need to monitor vast amounts of data for risks, from preventing financial fraud to securing computer networks, proving that sometimes the most effective way to find a needle in a haystack is to teach the computer how to build a better magnet.

Technical Summary: LLM as Detector for Tabular Anomaly Detection

Problem Definition

The paper addresses Tabular Anomaly Detection (TAD) in unsupervised settings, where models must identify abnormal records using only normal training data ( $D_{normal}$ ). The authors highlight that TAD is particularly challenging because anomalies often manifest as violations of cross-feature dependencies or causal mechanisms rather than simple marginal numerical deviations.

Existing methods face several limitations:

Reconstruction-based approaches (e.g., Autoencoders, DeepSVDD) often focus on reconstruction fidelity and fail to enforce explicit consistency across features.
Density-based methods (e.g., Isolation Forest, KNN) treat anomalies as distant points, struggling with samples that are numerically plausible but structurally inconsistent.
Prior LLM-based approaches (specifically AnoLLM and LLM-DAS) either suffer from high computational costs due to per-sample inference/fine-tuning or fail to simultaneously handle mixed data types, computational efficiency, and causal modeling.

Methodology: LLM-Detector

The authors propose LLM-Detector, a framework that leverages the in-context learning capabilities of Large Language Models (LLMs) to synthesize an executable anomaly detection engine. Crucially, the LLM is not fine-tuned; instead, it acts as a deterministic code synthesizer conditioned on structured normal-state knowledge extracted from the training set.

The framework operates in two distinct phases:

1. Knowledge-to-Code (Prompt Construction & Code Generation)

Normal training data ( $D_{normal}$ ) is transformed into a compact "normal-state knowledge package" and injected into the LLM prompt. This package consists of three structured components:

Statistical Profiles ( $p_{stats}$ ): Marginal summaries for each feature. For numerical features, this includes mean, variance, and empirical bounds; for categorical features, it includes empirical category probabilities.
Causal Knowledge ( $p_{causal}$ ): A Directed Acyclic Graph (DAG) representing feature dependencies, estimated using the Peter-Clark (PC) algorithm. This captures conditional relations between parent and child variables.
Distilled Prototypes ( $p_{distill}$ ): A representative subset of normal samples obtained via K-Means clustering and nearest-neighbor mapping. These serve as geometric anchors for multivariate density checks.

The LLM receives a prompt containing these profiles, an objective to generate a Python scoring engine, and specific requirements (e.g., bounded output, deterministic execution). The LLM outputs a Python script that implements the scoring logic.

2. Code-to-Score (Test-Time Inference)

The generated Python script is executed on test samples ( $D_{test}$ ) to compute an anomaly score $S(x) \in [0, 100]$ . The score is an aggregation of three components:

Outlier Score ( $S_{outlier}$ ): Measures marginal deviation. Numerical features are penalized based on standardized deviation from the mean; categorical features are penalized based on low empirical probability.
Causal Violation Score ( $S_{causal}$ ): Detects structural inconsistencies. It checks if a child feature is abnormal while its causal parents remain normal, indicating a broken dependency mechanism.
Density Score ( $S_{density}$ ): Calculates the Mahalanobis distance of the test sample from the normal manifold using the distilled prototypes and covariance estimates.

The final score is bounded and calibrated, allowing for direct comparison across samples without requiring label information during the scoring process.

Key Contributions

Framework Innovation: Introduction of LLM-Detector, which treats in-context learning as a mechanism for synthesizing executable, domain-specific anomaly detection logic without model training or fine-tuning.
Structured Knowledge Factorization: Formalization of normal-state knowledge into statistical profiles, causal relations, and distilled prototypes. The paper demonstrates that injecting this structured knowledge enables the generation of causal-structure-guided scoring logic.
Empirical Validation: Extensive evaluation on 24 diverse tabular datasets (12 mixed-type, 12 continuous-only) against 15 state-of-the-art baselines, including classical statistical methods, deep learning models, and recent LLM-based approaches.

Experimental Results

Performance: LLM-Detector achieved the highest average AUC-ROC across all datasets.
- Mixed-type datasets: Achieved an average AUC-ROC of 0.7407, outperforming the second-best method (AnoLLM at 0.6972) by approximately 5%.
- Continuous-only datasets: Achieved top-tier performance (0.91), demonstrating generalization to fully continuous spaces.
Ablation Studies:
- Combining all three knowledge types (Statistics + Causal + Distilled) yielded the best results, confirming that anomalies are best detected by considering marginal, structural, and multivariate factors simultaneously.
- The method is robust across different LLM backbones (DeepSeek, GPT, Gemini), though Gemini-3.0 performed best due to superior long-context reasoning and code synthesis.
- Performance stabilized with 100 distilled samples, showing diminishing returns beyond this point.
Efficiency: The method is computationally efficient at test time. Unlike training-based methods (e.g., AnoGAN, AnoLLM) which require significant GPU time, LLM-Detector's inference reduces to executing a lightweight, pre-synthesized Python script.

Significance and Claims

The paper claims that LLM-Detector offers a practical solution for real-world tabular anomaly detection by:

Eliminating the need for LLM fine-tuning, thereby reducing computational costs and avoiding the need for large-scale model retraining, while still utilizing a normal training set for knowledge extraction.
Handling mixed data types (categorical and continuous) natively through textual context and semantic reasoning, avoiding the semantic distortion often caused by encoding categorical variables in traditional numerical backbones.
Enabling causal reasoning without explicit ground-truth labels, by leveraging data-driven causal discovery to detect mechanism violations.
Providing interpretability and determinism, as the output is an executable program based on explicit statistical and causal rules rather than a "black box" neural network prediction.

The authors conclude that their design bridges the gap between raw statistical data and executable, causal-aware detection rules, achieving strong and stable performance through principled in-context learning code generation.