Human-AI Collaborative Bot Detection in MMORPGs

TL;DR

This paper introduces an unsupervised, explainable framework for detecting auto-leveling bots in MMORPGs by combining contrastive learning, clustering, and LLM-based validation to enhance detection accuracy and transparency.

Contribution

It proposes a novel unsupervised detection method using contrastive learning and LLM validation, improving scalability and explainability in bot detection for MMORPGs.

Findings

Effective unsupervised detection of leveling bots

Enhanced explainability with growth curve visualization

Improved moderation efficiency through collaborative validation

Abstract

In Massively Multiplayer Online Role-Playing Games (MMORPGs), auto-leveling bots exploit automated programs to level up characters at scale, undermining gameplay balance and fairness. Detecting such bots is challenging, not only because they mimic human behavior, but also because punitive actions require explainable justification to avoid legal and user experience issues. In this paper, we present a novel framework for detecting auto-leveling bots by leveraging contrastive representation learning and clustering techniques in a fully unsupervised manner to identify groups of characters with similar level-up patterns. To ensure reliable decisions, we incorporate a Large Language Model (LLM) as an auxiliary reviewer to validate the clustered groups, effectively mimicking a secondary human judgment. We also introduce a growth curve-based visualization to assist both the LLM and human moderators in assessing leveling behavior. This collaborative approach improves the efficiency of bot detection workflows while maintaining explainability, thereby supporting scalable and accountable bot regulation in MMORPGs.

Tables

Table 1. Table 1. TS2Vec showed the best embedding quality based on Kendall’s Tau.

Model	DTW	Autoencoder	TS2Vec
Kendall’s Tau	0.5283	0.8219	0.8304

Table 2. Table 2. Setting q = 0.1 q=0.1 generally yields better performance. LLM refinement also significantly reduced access information homogeneity. All results are reported as daily averages.

IP	LLM	$\epsilon$	#Det.	Acc_info.	Max_avg.	Mean_avg.
G1	✗	q=0.1	92.14	2.66	32.21	12.35
		q=0.2	153.07	3.22	32.30	12.14
		2.0	274.14	4.72	31.85	12.68
		3.0	511.79	23.15	84.59	17.53
	✓	q=0.1	49.71	1.80	25.31	12.55
G2	✗	q=0.1	71.71	2.24	52.35	22.55
		q=0.2	121.07	2.54	58.14	23.74
		2.0	261.29	3.24	74.07	29.02
		3.0	379.64	10.96	113.66	28.73
	✓	q=0.1	47.07	1.80	40.83	19.47
G3	✗	q=0.1	129.86	1.81	43.25	8.60
		q=0.2	219.07	1.93	49.19	13.11
		2.0	615.50	2.25	24.03	5.65
		3.0	663.79	4.33	95.00	18.39
	✓	q=0.1	84.07	1.41	13.69	5.32

Equations

$$T_{\text{pert},lv}^{(p)}=T_{\text{del},lv}^{(p)}+{\mathcal{N}}_{lv},{\mathcal{N}}_{lv}\sim \{\begin{array}{ll}\text{Uniform}(-3\cdot lv,3\cdot lv),& \text{w.p. }\frac{lv}{10}\\ 0,& \text{otherwise}\end{array}$$

$$\displaystyle d\big{(}\mathcal{M}(T^{(p)}),\ \mathcal{M}(\text{pert}^{(p)}_{i})\big{)}<d\big{(}\mathcal{M}(T^{(p)}),\ \mathcal{M}(\text{pert}^{(p)}_{j})\big{)},$$

$$\text{for }1\le i<j\le 10$$

Full text

Game Bot Detection; LLM Applications; Contrastive Learning

††journalyear: 2025††copyright: acmlicensed††conference: ; Aug 27, 2025; NCSOFT††booktitle: arXiv††ccs: Computing methodologies Unsupervised learning††ccs: Computing methodologies Representation learning††ccs: Applied computing Computer games††ccs: Security and privacy Artificial intelligence-based security systems

1. Introduction

In MMORPGs (Massively Multiplayer Online Role-Playing Games), bots exhibit intelligent and systematic behavior by automating character progression along optimized routes. They efficiently farm experience and items by targeting high-yield areas and completing quests, eventually forming farming units—typically composed of three or more characters—to acquire valuable resources. These automated actions result in far greater efficiency than human players, disrupting fair play and destabilizing the in-game economy through item monopolization and real money trading (RMT) (Huhh, 2008; Lee et al., 2018; Kwon et al., 2016; Lee et al., 2011).

Effective bot detection is essential, but in practice, sanctioning often leads to legal disputes—especially when evidence is insufficient or legitimate players are wrongly penalized (Kim et al., 2025). Thus, detection systems must ensure both accuracy and explainability.

This paper focuses on detecting auto-leveling bots, a specific class of game bots, by leveraging time-series representation models and Large Language Models (LLMs). Our framework builds upon prior approaches such as (Kim et al., 2025; Tao et al., 2018; Xu et al., 2020). We construct sequential inputs from each character’s level-up logs and temporal features, and project them into a latent space through a time-series representation model. The embedded vectors are then clustered using DBSCAN (Ester et al., 1996), a density-based clustering algorithm well-suited for discovering arbitrarily shaped groups. This fully unsupervised process incurs zero labeling cost and allows bots—whose leveling behavior is highly systematic—to form dense clusters, while human players with irregular progression patterns remain isolated.

To ensure reliability, we visualize clustered groups using growth curve-based plots and leverage LLMs for secondary verification to assess machine-like behavior. While our model captures systematic patterns well, ambiguous cases may still arise when bot-like and human-like behaviors are similar. To address this, we delegate verification to LLMs, reducing manual effort and enabling human moderators to focus on higher-level decisions.

The contributions of this paper are as follows:

• •

We propose the first detection framework for auto-leveling bots in MMORPGs that operates in a fully unsupervised manner—requiring no labeled data—and supports intuitive and interpretable analysis through level-up interval visualizations of detected bot groups.

• •

To enhance the reliability of detection results, we further incorporate Large Language Model (LLM)-based secondary verification. This novel component sheds light on the decision-making process behind unsupervised detection and facilitates accountable bot regulation.

2. Related works

2.1. Bot detection tasks

The task of game bot detection varies by genre (Chen et al., 2008; Pao et al., 2010; Pinto et al., 2021; Kanervisto et al., 2022; Choi et al., 2023; Lee et al., 2018; Qi et al., 2022; Su et al., 2022; Tao et al., 2019; Zhao et al., 2022; Kim et al., 2025; Lee et al., 2016; Kang et al., 2016; Pu et al., 2022). Particularly, MMORPGs face a threat of large-scale bot farms driven by automation. These bots prioritize efficiency and profit over competition, using optimized scripts. Detecting such bots has been the focus of several studies.

Prior work has explored diverse features for detecting abnormal behavior in MMORPGs, such as status logs, event records, quest and trade histories, click (touch) patterns, movement paths, and self-similarity metrics (Lee et al., 2018; Qi et al., 2022; Su et al., 2022; Tao et al., 2019; Zhao et al., 2022; Kim et al., 2025; Lee et al., 2016; Kang et al., 2016; Pu et al., 2022).

Many recent approaches aim to reduce human intervention by leveraging multimodal inputs to enhance model performance (Qi et al., 2022; Su et al., 2022; Tao et al., 2019; Zhao et al., 2022; Lee et al., 2016; Kang et al., 2016; Pu et al., 2022). While these methods can improve automation, they often result in complex models that hinder effective human–model interaction. This presents a practical challenge, as accurate bot regulation still requires human oversight to prevent false positives and mitigate legal risks.

To address this, (Kim et al., 2025) introduced BotTRep, a framework that facilitates interaction between human experts and models through intuitive and explainable materials to reduce false positives. Building on this philosophy, our study positions the model as a supportive tool for both LLMs and game masters. We demonstrate the feasibility of replacing the labor-intensive verification process—previously handled by humans in BotTRep—with LLM-based automation.

2.2. LLM-assisted verification

Recently, there has been a growing interest in leveraging Large Language Models (LLMs) for time series tasks (Gruver et al., 2023; Jin et al., 2023; Dong et al., 2024; Liu et al., 2024c; Chow et al., 2024; Merrill et al., 2024; Xie et al., 2024; Zhang et al., 2025; Kong et al., 2025). In particular, we focus on recent efforts that utilize the general intelligence of LLMs in zero- or few-shot settings, without requiring task-specific training (Gruver et al., 2023; Jin et al., 2023; Dong et al., 2024; Liu et al., 2024c). Beyond time series applications, LLMs have also been actively explored in a wide range of judgment-based tasks, where they have in some cases demonstrated accuracy comparable to human-level decision making (Liu et al., 2024a; Gu et al., 2024; Zheng et al., 2023).

Particularly, as natural language models, LLMs not only make judgments on time series tasks, but also provide explanations for their decisions in natural language, facilitating effective human interaction. In this paper, we leverage the strengths of LLMs to enhance the reliability of game bot detection results. Specifically, we design a data flow where suspicious clusters detected by the auto-leveling bot model undergo secondary verification by the LLM. This ensures that the final output delivered to the game master has been double-checked, thereby reducing the risk of false positives.

3. Proposed Approach

This section presents our framework components, with the core mechanism shown in Figure 1.

3.1. Data description

3.1.1. Data preperation

We use time-series data collected from an MMORPG, where each record indicates a character’s level-up event with a timestamp. For each character $p\in\mathbf{P}$, we define the level-up time sequence as $T^{(p)}=\{t_{1},\ldots,t_{i},\ldots,t_{\min(50,l^{(p)})}\}$, where $l^{(p)}$ denotes the highest level reached, and $t_{i}$ indicates the time (in minutes) it took to reach level $i$ from level $i-1$.

To ensure consistency, we cap all sequences at level 50, since higher levels often involve irregular progression patterns due to PvP or social interactions, even for bots. This threshold provides a stable basis for automated behavior analysis.

In this study, we only conduct experiments on cases where character level-ups were properly logged. Characters with missing data or level-up logs influenced by paid items were excluded, as their progression could not be reliably observed.

3.2. Auto-leveling bot detection model

3.2.1. Represntation model

The model used in this study takes as input the sequence data $T^{(p)}$, which consists of the numerical values defined earlier, and extracts a representation from it. Since the sequence length varies by character, the model must be capable of handling variable-length inputs and producing appropriate representations accordingly. Specifically, the model is designed to generate similar representations for similar time-series sequences, and dissimilar ones for different sequences. Any model that meets these requirements can be applied within our framework.

In this study, we primarily used the TS2Vec model (Yue et al., 2022). However, we modified the original implementation to output only the representation corresponding to the input sequence. The process of extracting the representation vector from the model can be simply expressed as $r^{(p)}=\mathcal{M}(T^{(p)})$.

The rationale behind using a representation model lies in the observation that auto-leveling bots tend to follow highly optimized leveling routes, frequently repeating behaviors such as visiting the same hunting grounds or completing the same quests. These patterns result in highly consistent numerical signals, which are captured as closely located vectors in the latent space. In contrast, human players typically exhibit greater variation due to unstructured gameplay, resulting in more dispersed representations.

3.2.2. Clustering algorithm

The clustering algorithm described in this section performs clustering on these representation vectors, and we primarily adopt DBSCAN (Ester et al., 1996) for this task. To use DBSCAN effectively, two key parameters must be configured: $min\_sample$ and $\varepsilon$. DBSCAN clusters data points when at least $min\_sample$ points are within a distance of $\varepsilon$ from one another; otherwise, the points are treated as noise. The clustering process in our framework is formalized as $c^{(p)}=\mathbf{cluster}(r^{(p)})$, where $r^{(p)}$ is the representation of character $p$.

In our study, we set $min\_sample=3$, based on the observation that bot activity in the field typically occurs in groups of three or more. The parameter $\varepsilon$ was determined following the method proposed in BotTRep (Kim et al., 2025), which is based on the adaptive density estimation described in (Schubert et al., 2017). Specifically, we adopted $\varepsilon=\text{quantile}_{q}(dist)$, where $dist$ refers to the distance between each data point and its $k$th nearest neighbor. In our experiments, we set $q\in\{0.1,0.2\}$.

3.3. LLM-assisted verification

3.3.1. LLM-based Verification Module

After applying the clustering step, we incorporated a Large Language Model (LLM) to refine the results by filtering out potential false positives. Specifically, we provided the LLM with a list of character groups that had been pre-clustered by our model and tasked it with verifying whether all characters within each cluster were indeed bots. If any non-bot character was detected within a cluster, the character was excluded from the final list of bot candidates.

This task originally required manual inspection of leveling curves at the cluster level by human operators. However, this process is highly repetitive and labor-intensive. To address this, we designed our system to offload the task to an LLM. The LLM receives a predefined prompt along with the original time interval sequences $T^{(p)}$ of the characters in each cluster as input, and performs verification accordingly, as shown in Figure 1.

This process is defined as $\mathcal{B}=\mathbf{LLM}(\mathcal{T},\mathcal{C},pt)$, where $T^{(p)}\in\mathcal{T}$ and $c^{(p)}\in\mathcal{C}$. Here, $T^{(p)}$ denotes the original time interval sequences, $c^{(p)}$ represents the clustering result, and $pt$ is the task-specific prompt provided to guide the LLM. In this study, we used GPT-4o for our experiments.

To address this task, we employed a hybrid approach that integrates a time-series model with an LLM, rather than relying exclusively on an LLM-based solution. Although we also evaluated GPT-4o by providing raw level-up logs as input, this configuration suffered from input length limitations and model constraints, resulting in unreliable outputs.

3.3.2. Prompt engineering

We constructed prompts for the LLM based on the following strategy: 1) role assignment, 2) definition of criteria for determining whether a character should be sanctioned, and 3) input–output format design. As discussed earlier, the LLM is used to help filter out legitimate users who were incorrectly included in clusters. When normal users—who ideally should not be clustered—are grouped together, the LLM analyzes their level-up interval sequences in a zero-shot manner to determine whether they should be excluded from the list of sanction candidates. This task includes diverse cases where bots and legitimate users are mixed. To avoid potential bias from showing only a few samples in a few-shot setting, we adopted a zero-shot approach by providing explicit criteria within the prompt instead of giving specific examples.

In step 2), we instructed the LLM to distinguish between auto-leveled bots and individually-leveled legitimate characters. To improve performance, we adopted the Chain-of-Thought (CoT) prompting approach (Wei et al., 2022; Liu et al., 2024b), guiding the model through the following steps: a) understand the input, b) compare level-up intervals, c) check structural similarity, d) identify bot groups, e) exclude non-bot characters, and f) produce the final output. The LLM receives level-up interval data of characters, organized in cluster-based batches, as text input.

3.4. Level-up interval visualization

We propose a level-up interval visualization method to illustrate the outcomes of clustering and LLM-based refinement. This method sequentially shows the time (in minutes) taken to progress from one level to the next.

It helps identify false positives by visually highlighting legitimate users mistakenly grouped with bots, enhancing the interpretability of the detection results . When clustering is accurate, characters in a cluster exhibit nearly identical leveling curves, while normal users appear noticeably different.

In practice, the game master can use it to verify whether legitimate users are properly excluded before finalizing sanctions, as shown in Figure 1 (b).

4. Experiments

To systematically assess the effectiveness of the proposed approach, we carry out three types of evaluation.

4.1. Dataset

In this study, we use data from three large-scale mobile MMORPGs operated by a commercial game publisher, each with approximately 200K daily active users. For training, we use three months of gameplay logs (October 1 to December 31, 2024), and for evaluation, a separate two-week dataset (January 1 to 14, 2025). The training set consists of 1,005,522 data points, and the evaluation set includes 38,514 data points. Evaluation is performed on the three most recently opened worlds (as of the data collection date) from each anonymized title: G1, G2, and G3111Each game title was anonymized for review and will be disclosed upon publication..

4.2. Evaluation of embedding quality

4.2.1. Evaluation metric

The first evaluation assesses the embedding quality of the representation model. A better model more clearly separates bots, which should be clustered, from legitimate users, which should not.

To evaluate this, we generate ten perturbed variants of each character’s level-up interval sequence: $T^{(p)}_{\text{pert}}=T^{(p)}+\mathcal{N}_{lv}$.

Specifically, we implement a more realistic perturbation pipeline composed of three sequential operations: random deletion, additive perturbation applied with probability, and index-wise swapping. We first apply random deletion to the original sequence $T^{(p)}$: $T^{(p)}_{\text{del},lv}=[t_{i}\in T^{(p)}\mid u_{i}>p_{\text{del}},\ u_{i}\sim\text{Uniform}(0,1)],\ p_{\text{del}}=0.05\times lv$.

Then, we construct the perturbed sequence with conditional additive noise:

[TABLE]

Finally, we apply index-wise swapping to further distort the temporal order: $\text{pert}^{(p)}_{lv}=\text{Swap}\left(T^{(p)}_{\text{pert},lv},\ \{(a_{k},b_{k})\}_{k=1}^{lv}\right)$ where $\text{Swap}(\cdot)$ denotes the index-wise swapping operation applied to $lv$ randomly selected index pairs, and $a_{k}$ and $b_{k}$ are the indices selected for swapping. That is, when $lv=1$, one swap is performed; when $lv=2$, two swaps are performed, and so on.

This staged perturbation introduces increasing levels of structural corruption as $lv$ increases, enabling a controlled evaluation of representation robustness. Ideally, as $lv$ increases, the perturbed sequence $\text{pert}^{(p)}_{lv}$ diverges further from the original sequence $T^{(p)}$. Thus, a well-functioning representation model should satisfy the following condition:

[TABLE]

where $d(\cdot,\cdot)$ is the Euclidean distance. To assess how well the structure in Equation (1) is preserved, we use Kendall’s Tau (Kendall, 1938), which gives higher scores when the alignment is better maintained.

4.2.2. Baseline experiment

To identify the most suitable representation model for our dataset, we conducted a baseline experiment using three representative approaches. The first model is Dynamic Time Warping (DTW), a fundamental method for time-series comparison. The second is an Autoencoder, commonly used to extract representations from various types of sequential data. The third is TS2Vec, which has been reported to provide universal time-series representations. Among the three, TS2Vec demonstrated the best performance in our baseline experiment, as summarized in Table 1.

4.3. Evaluation of clustering results

4.3.1. Evaluation metric

The second evaluation metric assesses clustering performance. We evaluate the results using TS2Vec (which showed the best embedding quality) combined with DBSCAN.

As shown in Table 2, the evaluation covers datasets from three MMORPG titles. The column labeled LLM indicates whether an LLM is applied, and eps shows the strategy for selecting the DBSCAN parameter. The value $q$ refers to a quantile-based method from (Kim et al., 2025), while other entries use fixed eps values without adaptive tuning.

We report access information homogeneity (Acc_info) as a primary metric (Kim et al., 2025; Tao et al., 2019). In addition, we use three auxiliary indicators: #Det, max average difference (Max_avg), and mean average difference (Mean_avg).

Access information homogeneity, proposed in (Kim et al., 2025), quantifies behavioral similarity between characters based on their login/access patterns. Lower values indicate stronger similarity, suggesting that the characters may be controlled by the same player. The minimum value of access information homogeneity is 1, as noted in (Kim et al., 2025), and values closer to 1 are interpreted as better performance.

Additionally, #Det refers to the average number of bots detected per day. Max_avg and Mean_avg represent the maximum and mean pairwise differences in level-up intervals among all characters within the same cluster. Smaller values indicate that characters in the cluster exhibit more homogeneous progression behavior.

4.3.2. Clustering results

The results indicate that setting $q=0.1$ generally leads to lower acc_info scores across game datasets, indicating lower-risk clustering. For G3, while $\varepsilon=2.0$ yielded slightly better Max_avg and Mean_avg scores, $q=0.1$ achieved a lower acc_info. In DBSCAN, $\varepsilon$ controls clustering granularity: a larger value applies a looser criterion, while a smaller value results in stricter identification of suspicious accounts. As this study prioritizes minimizing false positives, we recommend $q=0.1$.

While excluding such clusters is important for building a low-risk sanction list, tuning $\varepsilon$ alone is insufficient. Thus, we introduce a double-checking mechanism using GPT-4o, with results discussed in later experiments.

4.4. LLM-based verification

4.4.1. Evaluation metric

This section evaluates the proposed method using the same metric as in Section 4.3. This metric assesses performance improvement after LLM-based refinement.

4.4.2. Effectiveness of LLM-based refinement

The effectiveness of LLM-based refinement is demonstrated in the rows where the LLM column is marked as used (✓) in Table 2. Experimental results show that the LLM effectively filtered out normal users from the sanction candidates in an appropriate direction, leading to a meaningful reduction in the access information homogeneity score across all three games.

5. Conclusion

This paper presents an unsupervised framework for detecting auto-leveling bots in MMORPGs using time-series representation learning and LLM-based verification. By clustering characters with similar level-up behaviors and refining the results with LLM, our method reduces labeling costs while achieving high accuracy. Experiments on real game data demonstrate its practical value for game security.

6. GenAI Usage Disclosure

GenAI was used for proofreading only. No content was generated.