返回博客

游戏服务器上的 AI Agent 检测:传统 Anti-Cheat 为何失效,以及如何构建问责机制

发布于 2026年11月10日
游戏服务器上的 AI Agent 检测:传统 Anti-Cheat 为何失效,以及如何构建问责机制 借助 AI 生成

概要

了解基于 LLM 的 AI Agent 如何绕过传统反作弊,并学习在游戏服务器后端用行为指纹、身份验证、声誉问责三层检测管道从零构建可追责的防护体系,提供实战指南,通过分级执法、会话打分和信任分机制实现高并发实时检测,保护市场经济与天梯竞技,避免玩家生态和公平体验被自动化工具持续侵蚀。

AI Agent 正在出现在游戏服务器上——它们不是脚本,不是 bot,也不是 CAPTCHA 解题器,而是完全自主、由 LLM 驱动的系统,看起来与你 Anti-Cheat 原本要拦截的威胁完全不同。

与传统 bot 以非人类速度狂发输入不同,现代 AI Agent 能操作游戏菜单、响应聊天、模拟人类操作节奏,并在受到挑战时调整行为。它们作为中介位于真实玩家与服务器之间,而你的 backend 没有可靠机制来区分二者。

这是一份 runbook,教你检测这些 Agent、为它们的行为打分,并在你的经济系统、matchmaking 公正性或排位天梯被破坏之前,把问责机制构建进游戏 backend。

为什么 AI Agent 不是 Bot(以及为什么这很重要)

传统 bot 检测依赖几个典型特征:

  • 非人类的输入模式:固定间隔点击、像素级瞄准、反应时零方差
  • 会话异常:玩家每天登录 23+ 小时、无空闲时间
  • 已知签名:与常见自动化工具做哈希匹配

AI Agent 打破了所有这些假设。

AI Agent 与传统 Bot 自动化的差异

检测信号 传统 Bot AI Agent
输入时序 固定间隔 可变、类人的分布
决策方式 脚本化、确定性 自适应、概率性
错误率 零错误或重复错误 会自然犯错并从错误中恢复
CAPTCHA 需要解题工具 通过多模态 LLM,成功率约 95%
会话时长 无限或固定 模拟人类玩法模式,包括休息
并行操作 单个脚本,多账号 云端托管,并发运行数百个会话

AI Agent 不只是点击按钮——它会推理游戏状态。它读取 UI、理解目标,并做出看起来像高玩的决策。当你的 anti-cheat 标记它后,Agent 会在下一个会话调整自身行为模式。

游戏 Backend 中的故障模式

当 AI Agent 在未被发现的情况下运作时,会引发特定的级联故障:

  1. 经济膨胀:Agent 24/7 刷资源,淹没拍卖行并让货币贬值。一个配置良好的 Agent 可同时运行 12-15 个会话,每个会话每日资源产出是普通真人玩家的 3-5 倍。

  2. Matchmaking 污染:由 Agent 控制的账号混入排位队列,抬高 MMR 计算,并制造出“死局”——一方是超高效率的非人类玩家。

  3. 工单队列被淹没:支持系统被 Agent 生成的工单淹没,这些工单看起来足够真实,能通过初步分类——消耗本应用于真实玩家的客服工时。

  4. 容量浪费:你的服务器基础设施为 Agent 会话支付计算成本,而这些会话不会产生任何真实参与或收入。

检测层 1:行为指纹

第一层是行为层——分析一个会话随时间如何行动,而不是查看单个输入。这一层能抓到那些已经绕过基于签名检测的 Agent。

关键行为信号

操作间隔分布:人类不会随机行动,但也不会固定间隔行动。人类的操作时序服从对数正态分布——大多数操作围绕一个基础节奏聚集,偶尔出现离群值。Bot 产生均匀或指数分布。AI Agent 则介于两者之间:它们近似对数正态,但方差小得可疑(变异系数通常在 0.10 到 0.25 之间,而真人为 0.30-0.60)。

决策熵:衡量玩家使用的不同游戏操作数量与其总操作数的比例。玩生存游戏的人类会自然地在采集、建造、探索和战斗之间切换。Bot 倾向于重复同一套动作。AI Agent 会使用多种操作,但选择最优操作的稳定性高到在统计上不可信。

恢复模式:当人类犯错——撞墙、漏掉输入——他们会表现出特征性的修正延迟,然后调整。AI Agent 也会犯错(这是有意设计的),但它们的修正时序分布更紧凑,因为“错误”是生成的,而非自然产生的。

会话耐力:人类会疲劳。他们的每分钟操作数在两小时会话中会下降 15-30%。他们会休息,会切到别的窗口。AI Agent 在整个会话中保持 ±3% 的一致性,除非被明确编程去伪装疲劳。

Agent 打分实现

这是一个实用的会话打分系统,作为 middleware 运行在游戏服务器前面:

import time
import numpy as np
from collections import deque

class SessionBehaviorAnalyzer:
    """
    Scores a player session for agent probability based on
    behavioral signals collected during gameplay.
    """
    
    # Weights for each signal (tune against known samples)
    WEIGHTS = {
        'interval_regularity': 0.30,
        'entropy_score':       0.25,
        'recovery_pattern':    0.20,
        'session_consistency': 0.15,
        'decision_optimality': 0.10,
    }
    
    # Thresholds
    AGENT_THRESHOLD  = 0.72   # flag as probable agent
    REVIEW_THRESHOLD = 0.55   # escalate to human review
    
    def __init__(self, session_id: str, window_size: int = 200):
        self.session_id = session_id
        self.window_size = window_size
        self.action_times = deque(maxlen=window_size)
        self.action_types = deque(maxlen=window_size)
        self.error_recovery_deltas = deque(maxlen=50)
        self.last_error_time = None
    
    def record_action(self, action_type: str):
        """Record a player action with timestamp."""
        now = time.monotonic()
        self.action_times.append(now)
        self.action_types.append(action_type)
    
    def record_error_event(self):
        """Record a collision/stuck/miss event for recovery analysis."""
        self.last_error_time = time.monotonic()
    
    def record_error_correction(self):
        """Record when the player corrects after an error."""
        if self.last_error_time is not None:
            delta = time.monotonic() - self.last_error_time
            self.error_recovery_deltas.append(delta)
            self.last_error_time = None
    
    def _interval_regularity(self) -> float:
        """
        Returns 0-1. Higher = more suspicious.
        Humans: CV ~0.3-0.6 on action intervals.
        Bots: CV near 0.
        AI agents: CV ~0.1-0.25 (tight but not rigid).
        """
        if len(self.action_times) < 30:
            return 0.0
        
        intervals = np.diff(list(self.action_times))
        if len(intervals) < 2 or np.mean(intervals) == 0:
            return 0.0
        
        cv = np.std(intervals) / np.mean(intervals)
        
        # Suspicious if CV is too low (inhuman consistency)
        if cv < 0.10:
            return 1.0
        elif cv < 0.20:
            return 1.0 - (cv - 0.10) / 0.10
        return 0.0
    
    def _entropy_score(self) -> float:
        """
        Returns 0-1. Higher = more suspicious.
        Measures action variety via Shannon entropy.
        """
        if len(self.action_types) < 50:
            return 0.0
        
        types = list(self.action_types)
        unique, counts = np.unique(types, return_counts=True)
        probabilities = counts / counts.sum()
        
        entropy = -np.sum(probabilities * np.log2(probabilities + 1e-10))
        max_entropy = np.log2(len(unique))
        
        if max_entropy == 0:
            return 0.0
        normalized = entropy / max_entropy
        
        # Suspiciously perfect entropy (too diverse) or too low
        if normalized < 0.2:
            return 0.8   # repetitive — scripted loop
        elif normalized > 0.96:
            return 0.6   # artificially balanced — randomized masking
        return 0.0
    
    def _recovery_pattern(self) -> float:
        """
        Returns 0-1. Higher = more suspicious.
        Humans show log-normal recovery times with high variance.
        AI agents recover in near-constant time.
        """
        if len(self.error_recovery_deltas) < 10:
            return 0.0
        
        deltas = np.array(list(self.error_recovery_deltas))
        cv = np.std(deltas) / (np.mean(deltas) + 1e-10)
        
        if cv < 0.15:
            return 0.9   # near-constant recovery time
        elif cv < 0.25:
            return 0.5
        return 0.0
    
    def _session_consistency(self) -> float:
        """
        Returns 0-1. Higher = suspicious.
        Checks for inhuman stamina — no pauses, no degradation.
        """
        if len(self.action_times) < 100:
            return 0.0
        
        times = list(self.action_times)
        total_duration = times[-1] - times[0]
        
        if total_duration < 300:  # <5 min, skip
            return 0.0
        
        intervals = np.diff(times)
        long_breaks = np.sum(intervals > 300)  # >5 min gaps = breaks
        
        # A 2-hour session should have at least 1 natural break
        expected_breaks = total_duration / 3600
        if expected_breaks > 1 and long_breaks == 0:
            return 0.7
        
        # Split into thirds, compare action rates for degradation
        third = len(intervals) // 3
        if third < 10:
            return 0.0
        rates = [
            1.0 / (np.mean(intervals[i*third:(i+1)*third]) + 1e-10)
            for i in range(3)
        ]
        
        rate_cv = np.std(rates) / (np.mean(rates) + 1e-10)
        if rate_cv < 0.05:   # no degradation at all = suspicious
            return 0.6
        
        return 0.0
    
    def _decision_optimality(self) -> float:
        """
        Returns 0-1. Higher = suspicious.
        Track how often the player picks the optimal action.
        Requires game-specific integration — your server must log
        whether each action was optimal given game state.
        """
        # Placeholder — returns 0 until enough data.
        return 0.0
    
    def compute_agent_score(self) -> dict:
        """Compute the composite agent probability score."""
        signals = {
            'interval_regularity': self._interval_regularity(),
            'entropy_score':       self._entropy_score(),
            'recovery_pattern':    self._recovery_pattern(),
            'session_consistency': self._session_consistency(),
            'decision_optimality': self._decision_optimality(),
        }
        
        composite = sum(
            self.WEIGHTS[k] * signals[k] for k in self.WEIGHTS
        )
        
        verdict = 'clean'
        if composite >= self.AGENT_THRESHOLD:
            verdict = 'agent_likely'
        elif composite >= self.REVIEW_THRESHOLD:
            verdict = 'review'
        
        return {
            'session_id': self.session_id,
            'score': round(composite, 4),
            'verdict': verdict,
            'signals': {k: round(v, 3) for k, v in signals.items()},
        }

这并非银弹。如果 AI Agent 针对你游戏的特定玩家群体做微调循环,最终会学会模仿他们的行为分布。这就是为什么你需要接下来两层——以及为什么加固 netcode 以防御 exploit 模式是无论检测系统抓到了什么都必须具备的前提。

检测层 2:身份验证

行为打分告诉你某个对象如何行动。身份验证则问谁在行动——以及是否保证该会话背后是一个经过验证的人类。

这就是“可信委托”概念变得关键的地方。AI Agent 是一个中介——处在真实用户和你的服务器之间的东西。你的服务器看到的是 Agent 的流量,而不是人类的流量。要恢复这种关系,你需要一种机制,保证每个会话都绑定一个经过验证的人类身份。

让每个请求都带上身份

实用架构包含三个部分:

1. 会话前认证门禁:在玩家到达你的游戏服务器之前,先通过身份提供方完成认证。这会创建一个 token,将已验证的人类身份(邮箱、OAuth 账号、手机号)绑定到该会话。

2. Token 传播:认证 token 随每次 API 调用和游戏服务器 RPC 一起传输。你的服务器在每个请求上都验证 token——而不仅仅在登录时。

3. Token 与会话绑定:token 以密码学方式绑定到具体会话。如果 Agent 尝试在并行会话中复用 token,绑定会失败,会话被拒绝。

[Human Player]
     │
     ▼
[Auth Provider ──Verifies email/OAuth──▶ Issues session token]
     │
     ▼
[Game Client ──Sends token with each request──▶ Game Server]
     │
     ▼
[Game Server ──Validates token + checks session binding]
     │
     ├── Valid + single session  → Allow
     ├── Valid + session conflict → Reject + flag account
     └── Invalid token            → Reject + log

为什么这能阻止 AI Agent

AI Agent 需要凭据才能运作。如果你要求的是人工验证过的认证——不是随便生成的邮箱地址,而是本身验证过用户的 OAuth 提供方,或绑定手机号的账号——Agent 运营者就需要大规模获取真实凭据。

这不会让 Agent 无法运作,但会改变经济账。一个 Agent 要跑 50 个并发会话,现在需要 50 个通过验证的账号,每个都要真实邮箱,每个都要走你的认证流程。单会话成本会高到让很多滥用场景无利可图。

对独立和中型团队来说,从零实现一个健壮的 auth 层通常需要 2-4 周——你需要 OAuth 集成、token 刷新逻辑、会话绑定,以及过期 token 和账号恢复等边界情况处理。像 horizOn 这样的平台开箱即用地提供终端用户认证和账号绑定会话,支持邮箱、匿名、Google 和 Apple 登录,把这从开发项目变成配置步骤。

当 AI Agent 存在时,暴露凭据表的数据泄露尤其危险——被盗凭据会以机器速度被武器化。我们关于如何架构 backend 以在凭据泄露中幸存的拆解,覆盖了限制爆炸半径的存储和轮换模式。

检测层 3:声誉与问责

身份告诉你是谁。声誉告诉你你是否信任他们。问责告诉你出问题时谁来负责。

构建每账号声誉分

声誉系统为每个经过认证的身份分配一个信任分,信任分随合法行为增加,随可疑活动减少。高声誉账号获得更多自主权;低声誉账号则面对越来越大的摩擦。

import time

class ReputationEngine:
    """
    Maintains a per-account reputation score that adjusts
    based on behavioral analysis outcomes and account age.
    """
    
    BASE_SCORE    = 50      # starting reputation (0-100 scale)
    DECAY_FACTOR  = 0.995   # daily score decay toward baseline
    
    # Score adjustments
    ADJUSTMENTS = {
        'clean_session':       +1.0,
        'review_flag':         -3.0,
        'agent_likely':       -15.0,
        'auth_anomaly':       -10.0,
        'manual_appeal_pass': +20.0,
        'purchase_made':       +5.0,
        'account_age_30d':    +10.0,
        'reported_by_player':  -5.0,
    }
    
    def __init__(self, account_id: str, initial_score: float = BASE_SCORE):
        self.account_id = account_id
        self.score = initial_score
        self.history = []
    
    def adjust(self, event_type: str, context: dict = None):
        """Apply a reputation adjustment based on an event."""
        delta = self.ADJUSTMENTS.get(event_type, 0)
        self.score = max(0, min(100, self.score + delta))
        
        self.history.append({
            'event': event_type,
            'delta': delta,
            'new_score': self.score,
            'timestamp': time.time(),
            'context': context or {},
        })
    
    def apply_daily_decay(self):
        """Decay score toward baseline over time."""
        self.score = self.BASE_SCORE + (self.score - self.BASE_SCORE) * self.DECAY_FACTOR
    
    def get_trust_tier(self) -> str:
        """Return the current trust tier for rate limiting."""
        if self.score >= 80:
            return 'trusted'      # minimal friction
        elif self.score >= 50:
            return 'standard'     # normal monitoring
        elif self.score >= 25:
            return 'elevated'     # higher frequency behavioral checks
        else:
            return 'restricted'   # strict limits, possible queue delays
    
    def get_rate_limit_multiplier(self) -> float:
        """Multiplier < 1.0 for rate limiting low-rep accounts."""
        tier = self.get_trust_tier()
        return {
            'trusted':    1.0,
            'standard':   1.0,
            'elevated':   0.6,
            'restricted': 0.3,
        }[tier]

问责:出问题时谁来负责

问责意味着,当 Agent 造成损害——冲垮市场经济、利用 bug、恶意破坏对局——存在一个真实、可追溯的负责人。

对游戏 backend 来说,这意味着:

  • 账号封禁是永久性的:由于会话绑定已验证身份,你封禁的是真人运营者,而不是一个可随时抛弃的游戏账号。被封禁的代价更高,这会威慑 Agent 部署。

  • 经济回滚有明确范围:你确切知道哪些已验证身份产生了欺诈资源。回滚是外科手术式的,而不是全服范围。

  • 申诉可处理:真人可以对误判提出申诉。他们的验证链能证明自己是真实的。没有这条链,每个被封禁的账号都只是在制造噪音。

整合起来:完整检测管道

这三个层组成一个请求管道,对每个入站连接运行:

Inbound Connection
        │
        ▼
┌─────────────────────┐
│  Auth Gate           │  ← Reject unauthenticated sessions
│  (Identity Layer)    │    Check token binding, single-session lock
└────────┬────────────┘
         │
         ▼
┌─────────────────────┐
│  Behavioral Engine   │  ← Score session in real-time
│  (Detection Layer)   │    Analyze every 50-action window
└────────┬────────────┘
         │
         ▼
┌─────────────────────┐
│  Reputation Service  │  ← Adjust trust score, set rate limits
│  (Accountability)    │    Persist across sessions
└────────┬────────────┘
         │
         ▼
┌─────────────────────┐
│  Enforcement Action  │  ← Block, throttle, allow, or flag
│                      │    Route to game server
└─────────────────────┘

开销与成本

运行这条管道并不是免费的。以下是一个处理约 10,000 并发会话的部署的真实数据:

  • 行为分析:每个操作批次约 2ms(每 50 个操作)。对游戏循环增加的延迟可忽略不计。

  • 声誉查询:缓存命中约 0.5ms,缓存未命中约 3ms(会话的第一个操作)。用 Redis 或等价内存存储实现。

  • Auth token 验证:本地验证 JWT 约 1ms;远程 auth 端点命中约 5-15ms。积极预验证和缓存。

每个会话增加的总延迟:正常负载下每个操作批次 3-5ms。行为分析是 CPU 密集度最高的组件;在 10,000 并发会话下,大约消耗额外一个 vCPU。这是一笔值得做的取舍,因为一个不受控制的 Agent 一周内跑 12 个并行会话,就能抽走相当于数千美元付费货币的玩家经济价值。

最佳实践

  1. 不要一有信号就封禁:单个会话出现异常分数并不算证据。高玩和 AI Agent 都会产生离群行为信号。在施加账号级处罚前,使用至少 5 个会话的滚动窗口。跨会话反复出现高分才是可靠指标。

  2. 根据你自己的玩家群体调整权重:上面代码中的打分权重只是起点。每个游戏都有不同的行为规范——节奏游戏比开放世界 RPG 有更严格的时序预期。在激活处置机制之前,至少花 2 周从已验证真人玩家收集基线数据。

  3. 分级处置,不要二元封禁:用渐进式摩擦代替允许/阻断。低声誉账号会被排入影子匹配会话(只与其他低声誉账号匹配),或面临更严格的频率限制,或触发二次验证挑战。这既保护了被误判的真实玩家,又限制了 Agent 造成的损害。

  4. 记录一切,抽样校准:记录每个行为信号、每次声誉调整和每次处置动作。人工审查 5-10% 被标记的会话,以校准误报率。目标是把误报率控制在 0.5% 以下——哪怕标记 2% 的真实玩家,产生的客服工单也会超过 Agent 问题本身制造的工单。

  5. 把服务端 auth 与客户端指纹结合:服务端 auth 验证身份。客户端指纹(设备签名、操作系统级信号、硬件 ID)增加了第二个关联点,让 Agent 运营者更难在不同 bot 机器间复用凭据。如果同一个已验证账号在 24 小时内从 8 个不同硬件指纹连接,那就是一个值得采取行动的信号。

自建 vs. 采购

如果你的游戏尚未上线,或仍处于 early access 阶段且日活用户少于 1,000,你很可能有更重要的事要做。基础的 rate limiting 和基于签名的 bot 检测暂时够用。

一旦你达到 Agent 在经济上值得攻击的规模——通常是在有玩家驱动经济或竞技排位模式的游戏中达到 5,000+ DAU——就需要上面描述的分层方案。行为打分系统是归你所有的定制代码,因为它依赖你游戏特有的操作词汇和时序规范。

身份与认证层不需要定制。horizOn 提供终端用户认证和账号绑定会话,支持邮箱、匿名、Google、Apple 登录,从而建立问责所需的已验证人类身份绑定。你可以把工程时间专注于能让你游戏与众不同的行为打分上,而不是从零重建 OAuth 和 token 管理。

后续步骤

先从 shadow mode(影子模式) 下的行为打分系统开始——记录分数,但不采取任何处置动作。在你的真实玩家群体上运行两周,为你的特定人群建立基线。然后定义信任等级和处置动作,调整阈值,并优先对新会话启用处置。

将检测管道连接到你的 auth 层,确保每个会话都能追溯到一个已验证身份。行为打分与身份验证的结合,为你提供了 Cloudflare 认为治理新一波 AI 中介所必需的三种机制:你知道谁在行动,你衡量是否信任他们,并且出问题时有人会被问责。


来源:Agent 不是人类(但也可以说是)