🤖 AI

Chameleon: An Adaptive AI-Driven Honeypot Architecture Using Threat-Calibrated Particle Swarm Optimization and Semantic Deception Rapidly-Exploring Random Trees

Chameleon is a cost-effective, adaptive AI-driven honeypot platform that overcomes the static nature of traditional deception systems by integrating a BiLSTM threat classifier, a local Qwen3.5-0.8B language model, and novel TC-PSO and S-RRT meta-heuristic engines to dynamically evolve semantic responses in real-time, achieving superior detection accuracy and convergence while reducing operational costs by approximately 490-fold compared to commercial alternatives.

Original authors: Rohit Swami, Tushar Singh, Akash Warde, Sri Muthu

Published 2026-08-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Rohit Swami, Tushar Singh, Akash Warde, Sri Muthu

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 digital world, security teams face a constant, overwhelming flood of alerts. Every day, organizations process thousands of potential threats, yet human analysts can only investigate a small fraction of them. Traditional defenses, like firewalls, act as rigid gates that only recognize known bad actors; they struggle when attackers use new tricks or hide within normal traffic. To solve this, experts have long used "honeypots"—decoy systems designed to look like real, vulnerable computers. These traps lure attackers in, allowing defenders to study their methods without risking actual data. However, most existing honeypots are static. Once set up, their behavior never changes. A skilled attacker can quickly test a few commands, realize the responses are too perfect or too rigid, and identify the system as a trap, leaving before any useful information is gathered.

Researchers Rohit Swami, Tushar Singh, Akash Warde, and Sri Muthu have developed a new kind of honeypot called Chameleon to fix this flaw. Unlike its static predecessors, Chameleon is an adaptive system that changes its behavior in real time based on what the attacker is doing. It combines a fast threat detector with a language model that can hold a conversation, all guided by two specialized optimization engines. The goal is to keep the attacker engaged long enough to learn their tactics, while doing so at a tiny fraction of the cost of expensive commercial alternatives. The team tested their system in simulations, finding that it could distinguish between harmless traffic and genuine attacks with near-perfect accuracy, and that its adaptive strategies significantly outperformed standard methods used in the field.

The core innovation of Chameleon lies in how it reacts to danger. When a connection is made, the system first analyzes the incoming commands to determine if they are benign or malicious. It uses a neural network, a type of computer program modeled after the human brain, to scan the text of the commands. This classifier is incredibly fast, making a decision in about two milliseconds, and it correctly identifies seven different types of threats, such as attempts to steal data or take control of a server, with an accuracy of 99.61 percent. If the traffic is harmless, the system responds with a simple, quick answer. But if the system detects a serious threat, it escalates the interaction to a more sophisticated layer.

This second layer involves a language model, a compact version of an artificial intelligence designed to understand and generate human-like text. Instead of giving a canned response, this model engages the attacker in a realistic conversation, mimicking a real operating system. It remembers the history of the conversation to maintain consistency, ensuring that the deception feels authentic. To keep the attacker from leaving, the system also employs two mathematical strategies to decide how long to hold the connection and how to evolve the fake file system it presents. One strategy adjusts the delay before responding, making the system feel sluggish or unresponsive in a way that frustrates the attacker and keeps them trying. The other strategy grows a complex, fake directory structure that mimics a real server, but it does so intelligently, focusing its energy on the parts of the system the attacker is actually interested in.

The researchers found that these adaptive strategies made a massive difference. When they compared their new methods against standard, non-adaptive versions, the results were striking. The adaptive system improved the quality of its engagement by nearly 50 percent in one test and by more than 250 percent in another. In the most critical scenarios, where the attacker was using the most dangerous techniques, the adaptive system was more than three times better at maintaining a convincing deception than the standard approach. Furthermore, the system was designed to be memory-efficient, using about 25 percent less computer memory than the unoptimized versions, which allows it to run on modest hardware.

Perhaps the most surprising finding is the cost. While commercial deception platforms can cost between one hundred thousand and one hundred fifty thousand dollars per year, Chameleon can be run on a basic cloud server for approximately seventeen dollars a month. This represents a reduction in cost of nearly 490 times. The system achieves this by running entirely on standard computer processors without needing expensive graphics cards, and by using open-source software components that the researchers made freely available. The entire system, including the code and the data used to test it, is released under a license that allows anyone to study, modify, and use it.

The study confirms that adaptive deception is not only possible but highly effective when the system can learn from the attacker in real time. By coupling a fast threat detector with a conversational AI and intelligent optimization, the researchers created a trap that is difficult to recognize and expensive for an attacker to bypass. The results were verified through rigorous testing, with the system passing a suite of ninety-one automated tests and showing statistically significant improvements over existing methods. While the current results are based on simulations and controlled experiments, the authors suggest that the approach offers a powerful, affordable new tool for cybersecurity, potentially changing how organizations protect their networks by turning the cost of deception from a luxury into a standard, accessible practice.

Technical Summary: Chameleon – An Adaptive AI-Driven Honeypot Architecture

Problem Statement
Traditional honeypot installations suffer from a critical vulnerability: an invariant behavioral profile. Skilled adversaries can identify these deception environments within a few diagnostic commands (e.g., uname -a) by matching deterministic response patterns against known honeypot fingerprints. While commercial deception products exist, they are prohibitively expensive (USD 100,000–150,000 annually) and lack real-time, model-driven feedback loops to adapt their responses dynamically. Existing open-source solutions like Cowrie and T-Pot share the same structural deficiency: their behavioral output is fixed at deployment and cannot evolve in response to an active session. This creates a gap where defenders cannot effectively redistribute the asymmetry of attacker engagement without incurring massive costs or relying on static, easily detectable sensors.

Methodology and Architecture
The paper introduces Chameleon, an open-source, adaptive honeypot platform designed to close this capability gap through a feedback-coupled, five-layer architecture. The system operates on CPU-only hardware and integrates three core components:

Threat Classification Pipeline:
- Preprocessing: Incoming payloads undergo a four-stage normalization pipeline (Unicode NFKC collapsing, structural character mapping, control-character suppression, and token-level normalization) to prevent encoding-based evasion.
- BiLSTM Classifier: A bidirectional long short-term memory (BiLSTM) neural network classifies traffic into seven categories (SQL injection, XSS, server-side includes, path traversal, RCE, brute force, and benign). Trained on 50,000 examples, it achieves 99.61% accuracy with approximately 2ms CPU latency.
- Decision Logic: Payloads with a class probability $\theta \geq 0.85$ are escalated to the deception engine; benign traffic receives lightweight static responses to maintain low latency.
Semantic Deception Engine:
- LLM Integration: Escalated sessions are handled by a locally deployed Qwen3.5-0.8B language model (fine-tuned via Low-Rank Adaptation). It generates context-aware terminal responses with 90% accuracy at 4.5ms average latency.
- Session Continuity: A rolling history of up to 20 command-response turns per source IP is maintained to ensure coherent interactions.
- Reliability: The system employs a circuit breaker, a TTL response cache (reducing model calls by 30–60%), and an OGCPS credential-pattern scanner for exfiltration detection.
Meta-Heuristic Optimization Layers:
- Threat-Calibrated Particle Swarm Optimization (TC-PSO): This module dynamically adjusts connection-holding delays. Unlike standard PSO with fixed inertia, TC-PSO modulates the inertia weight $w(t)$ based on the BiLSTM anomaly score $A(t)$ . As threat severity increases, inertia decreases to force rapid convergence toward maximum engagement delays. It also amplifies the objective function reward for high-severity sessions.
- Semantic Deception Rapidly-Exploring Random Trees (S-RRT): This module evolves the deception filesystem schema. It utilizes a Payload Severity Index ( $\Psi$ ) computed by the LLM to exponentially scale pheromone updates ( $\Delta\tau' = \Delta\tau \cdot e^{\Psi-1}$ ). High-severity attacks deposit significantly more pheromone, guiding the tree toward effective deception schemas. Crucially, a depth-decay multiplier enforces a finite memory footprint, preventing the unconstrained node proliferation seen in standard RRTs.

Key Contributions
The paper advances five primary contributions:

TC-PSO: The first application of a BiLSTM-derived anomaly signal to govern particle inertia and objective amplification specifically for honeypot tarpit-delay optimization.
S-RRT: A novel variant of the RRT family where pheromone reinforcement is exponentially scaled by an LLM-computed severity index, combined with a provable depth-decay memory constraint.
Feedback-Coupled Cascade: A two-stage pipeline pairing the BiLSTM classifier with a compact Qwen3.5-0.8B model, achieving ~99.5% combined accuracy at ~4.5ms latency on CPU-only hardware.
Production Instrumentation: A full stack including Merkle-chained forensic logs anchored to Ethereum Sepolia, honeytoken canary files triggering STIX 2.1 bundle generation, and a Paramiko-based SSH sensor with full pseudo-terminal emulation.
Reproducibility: Full release of MIT-licensed source code, benchmark datasets, and a deterministic 91-test suite for independent replication.

Results
Experiments were conducted on Apple M-Series ARM64 hardware (16GB RAM) across five independent runs (seeds 42–46) without GPU acceleration.

TC-PSO Performance: Outperformed standard PSO by 48.1% in mean final fitness (2.60 to 3.85) and achieved a 32.7% gain in convergence speed. All differences were statistically significant ( $p < 0.01$ ).
S-RRT Performance: Exceeded standard RRT by 258.9% in best-run fitness (450.2 to 1,615.8). At critical severity ( $\Psi = 3.0$ ), the fitness gain was 329.2% (264.64 to 1,135.75). S-RRT also achieved a 24.9% reduction in memory consumption compared to unconstrained baselines.
Classification & Latency: The BiLSTM classifier achieved 99.61% accuracy with a false-positive rate of 0.39%. The Qwen3.5-0.8B model achieved 90% contextual generation accuracy. The weighted average pipeline latency was approximately 4.5ms.
Cost Efficiency: Operating costs are estimated at USD 17 per month for a single-core cloud instance, representing a roughly 490-fold reduction compared to commercial alternatives (approx. USD 8,333/month).

Significance and Claims
The paper claims that Chameleon demonstrates that behaviorally adaptive deception infrastructure is achievable at a fraction of the cost of proprietary commercial solutions. It asserts that domain-specific meta-heuristic formulations are critical; standard optimization algorithms (PSO, RRT) applied without modification yield substantially inferior results compared to the threat-calibrated versions (TC-PSO, S-RRT).

The significance of the work lies in its statistical robustness (all improvements hold at $p < 0.01$ ) and its end-to-end integration of threat classification, meta-heuristic optimization, and language-model-driven response generation on open-source, CPU-only infrastructure. By releasing the system under an MIT license, the authors aim to lower the barrier to adaptive deception research and contribute to a more empirically grounded literature on meta-heuristic design for cybersecurity.

Limitations
The authors acknowledge four limitations:

The Qwen3.5-0.8B model was fine-tuned for only 600 iterations; higher accuracy (94–96%) is extrapolated for 2,000 iterations but not executed due to resource constraints.
All experiments were conducted in simulation; real-world validation requires live deployment with ethical approval.
The optimization algorithms are currently single-objective; future work could extend them to multi-objective frameworks (e.g., NSGA-II).
The Payload Severity Index uses discrete values; continuous calibration is proposed for future precision improvements.

Technical Summary: Chameleon – An Adaptive AI-Driven Honeypot Architecture

More like this