Назад к блогу

Обнаружение AI-агентов на игровых серверах: почему традиционный анти-чит не справляется и как выстроить подотчётность

Опубликовано 10 ноября 2026 г.
Обнаружение AI-агентов на игровых серверах: почему традиционный анти-чит не справляется и как выстроить подотчётность Создано с помощью ИИ

Коротко о главном

Узнайте, как выявлять AI-агентов на игровых серверах: поведенческий скоринг, верификация личности и репутация защищают экономику и матчмейкинг.

AI-агенты — не скрипты, не боты, не решатели CAPTCHA, а полностью автономные системы на базе LLM — появляются на игровых серверах, и они совсем не похожи на угрозы, против которых создавался ваш анти-чит.

В отличие от традиционных ботов, засыпающих сервер вводами с нечеловеческой скоростью, современные AI-агенты перемещаются по меню, отвечают в чат, имитируют человеческий тайминг и адаптируются при проверках. Они находятся между реальным игроком и вашим сервером как посредники, и ваш backend не имеет надёжного механизма, чтобы отличить их.

Это runbook по обнаружению таких агентов, оценке их поведения и встраиванию подотчётности в игровой backend, пока экономика, целостность матчмейкинга и соревновательные рейтинги не пострадали.

Почему AI-агенты — это не боты (и почему это важно)

Традиционное обнаружение ботов опирается на несколько признаков:

  • Нечеловеческие паттерны ввода: клики с фиксированным интервалом, идеальный аим, нулевая вариативность реакции
  • Аномалии сессий: игроки онлайн 23+ часов в сутки, нулевое время простоя
  • Известные сигнатуры: сопоставление хэшей с распространёнными инструментами автоматизации

AI-агенты ломают все эти предположения.

Чем AI-агенты отличаются от традиционной бот-автоматизации

Сигнал обнаружения Традиционный бот AI-агент
Тайминг ввода Фиксированные интервалы Изменчивые, человекоподобные распределения
Принятие решений Скриптовое, детерминированное Адаптивное, вероятностное
Частота ошибок Ноль ошибок или повторяющиеся ошибки Ошибается и естественно исправляется
CAPTCHA Требует инструмент для решения Проходит с ~95% успехом через мультимодальную LLM
Длительность сессии Бесконечная или фиксированная Имитирует человеческие паттерны игры, включая перерывы
Параллельные операции Один скрипт, много аккаунтов Облачный хостинг, сотни одновременных сессий

AI-агент не просто кликает по кнопкам — он анализирует состояние игры. Он читает интерфейс, интерпретирует цели и принимает решения, которые выглядят как выбор опытного игрока. Когда ваш анти-чит помечает его, агент адаптирует свою модель поведения к следующей сессии.

Типовой сценарий отказа в игровых backend'ах

Когда AI-агенты действуют незамеченными, они вызывают цепочки специфических сбоев:

  1. Инфляция экономики: агенты добывают ресурсы 24/7, заполняя аукционы и обесценивая валюту. Один хорошо настроенный агент может вести 12–15 параллельных сессий, каждая из которых производит в 3–5 раз больше дневного ресурса, чем обычный игрок.

  2. Разрушение матчмейкинга: аккаунты под управлением агентов сидят в рейтинговых очередях, завышая расчёты MMR и создавая «мёртвые» матчи, где одна из сторон — сверхэффективный нечеловек.

  3. Переполнение очереди тикетов: системы поддержки захлёбываются от тикетов, созданных агентами, которые выглядят достаточно легитимно, чтобы пройти первичную сортировку, — на это уходят часы работы, которые должны тратиться на реальных игроков.

  4. Пустая трата мощностей: ваша серверная инфраструктура платит за вычислительные ресурсы для сессий агентов, которые не приносят ни вовлечённости, ни дохода.

Слой обнаружения 1: поведенческий фингерпринтинг

Первый слой — поведенческий: анализирует, как сессия ведёт себя во времени, а не отдельные вводы. Именно здесь вы ловите агентов, которые уже обошли сигнатурное обнаружение.

Ключевые поведенческие сигналы

Распределение интервалов между действиями: люди действуют не случайно, но и не через фиксированные интервалы. Тайминг человеческих действий подчиняется логнормальному распределению — большинство действий группируется вокруг базового ритма с редкими выбросами. Боты дают равномерное или экспоненциальное распределение. AI-агенты дают нечто среднее: приближаются к логнормальному, но с подозрительно низкой дисперсией (коэффициент вариации обычно 0.10–0.25 против 0.30–0.60 у реальных людей).

Энтропия решений: измеряйте, сколько различных игровых действий совершает игрок относительно общего числа действий. Человек в survival-игре чередует сбор ресурсов, строительство, исследование и бой — органическими кластерами. Бот склонен повторять одну последовательность. AI-агент использует множество действий, но со статистически неправдоподобной стабильностью выбирает оптимальное.

Паттерны восстановления: когда человек ошибается — врезается в стену, промахивается вводом — у него есть характерная задержка перед исправлением, после чего он подстраивается. AI-агенты тоже ошибаются (это заложено в их конструкцию), но время их корректировки укладывается в более узкое распределение, потому что «ошибка» генерируется, а не возникает естественно.

Выносливость сессии: человек устаёт. Его действий в минуту падает на 15–30% за двухчасовую сессию. Он делает перерывы. Он переключается на другие окна. AI-агенты держат равномерность ±3% в течение всей сессии, если только их явно не запрограммировали имитировать утомление.

Реализация скоринга агентов

Вот практическая система скоринга сессий, которая работает как 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-агент, которого прогоняют через цикл fine-tuning на игровом населении вашего проекта, рано или поздно научится имитировать его поведенческие распределения. Поэтому нужны следующие два уровня — и поэтому укрепление вашего netcode против эксплойт-паттернов является обязательным условием независимо от того, что обнаруживает система.

Слой обнаружения 2: верификация личности

Поведенческий скоринг говорит вам, как действует объект. Верификация личности отвечает на вопрос, кто действует — и гарантировано ли, что за сессией стоит подтверждённый человек.

Здесь ключевой становится концепция «доверенного делегирования». AI-агент — это посредник, нечто между реальным пользователем и вашим сервером. Ваш сервер видит трафик агента, а не человека. Чтобы восстановить связь, нужен механизм, гарантирующий привязку подтверждённой человеческой личности к каждой сессии.

Привязка личности к каждому запросу

Практическая архитектура состоит из трёх компонентов:

1. Шлюз аутентификации перед сессией: прежде чем игрок попадёт на ваш игровой сервер, он проходит аутентификацию через identity provider. Создаётся токен, привязывающий подтверждённую человеческую личность (email, OAuth-аккаунт, номер телефона) к сессии.

2. Пробрасывание токена: токен аутентификации передаётся с каждым API-вызовом и RPC игрового сервера. Сервер валидирует токен на каждом запросе, а не только при входе.

3. Привязка токена к сессии: токен криптографически привязан к конкретной сессии. Если агент попытается переиспользовать токен в параллельных сессиях, привязка не пройдёт, и сессия будет отклонена.

[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-агентов

Для работы AI-агенту нужны учётные данные. Если вы требуете аутентификацию с подтверждением человека — не просто сгенерированный email, а OAuth-провайдера, который сам проверил пользователя, или аккаунт, привязанный к номеру телефона, — оператору агента придётся массово добывать настоящие учётные данные.

Это не делает работу агентов невозможной, но меняет экономику. Один агент с 50 параллельными сессиями теперь требует 50 подтверждённых аккаунтов, каждый с реальным email, каждый проходит ваш процесс аутентификации. Затраты на сессию вырастают до уровня, при котором многие сценарии эксплуатации становятся нерентабельными.

Для инди и средних команд реализация надёжного слоя аутентификации с нуля обычно занимает 2–4 недели: нужна интеграция OAuth, логика обновления токенов, привязка сессий и обработка пограничных случаев с истёкшими токенами и восстановлением аккаунта. Такие платформы, как horizOn, предоставляют аутентификацию конечных пользователей и привязанные к аккаунту сессии из коробки с поддержкой email, анонимного входа, Google и Apple Sign-In — это превращает задачу из проекта разработки в шаг конфигурации.

Утечка данных, раскрывающая таблицы с учётными данными, особенно опасна при наличии AI-агентов — украденные учётные данные используются на машинной скорости. Наш разбор того, как проектировать 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]

Подотчётность: кто отвечает, когда что-то идёт не так

Подотчётность означает: когда агент наносит ущерб — обрушивает экономику маркетплейса, эксплуатирует баг, портит матчи — за этим стоит реальный человек, которого можно привлечь к ответственности и отследить.

Для игровых backend'ов это означает:

  • Блокировка аккаунта перманентна: поскольку сессии привязаны к подтверждённым личностям, вы баните оператора-человека, а не одноразовый игровой аккаунт. Цена бана выше, и это сдерживает развёртывание агентов.

  • Откат экономики точечный: вы точно знаете, какая подтверждённая личность создала мошеннические ресурсы. Откат хирургический, а не серверный.

  • Апелляции обрабатываемы: человек может обжаловать ложное срабатывание. Его цепочка верификации доказывает, что он реальный. Без этой цепочки каждый забаненный аккаунт превращается в генератор шума.

Собираем всё вместе: полный конвейер обнаружения

Три слоя собираются в конвейер запросов, который применяется к каждому входящему подключению:

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 одновременных сессий:

  • Поведенческий анализ: ~2 мс на пачку действий (каждые 50 действий). Добавляемая задержка пренебрежимо мала для игрового цикла.
  • Запросы к репутации: ~0,5 мс при кэше, ~3 мс при промахе (первое действие сессии). Реализуйте через Redis или аналогичное in-memory хранилище.
  • Валидация токенов: ~1 мс для JWT с локальной проверкой; ~5–15 мс при обращении к удалённому auth endpoint. Предварительно валидируйте и агрессивно кэшируйте.

Суммарная добавленная задержка на сессию: 3–5 мс на пачку действий при нормальной нагрузке. Поведенческий анализ — самый требовательный к CPU компонент; при 10 000 одновременных сессий он потребляет примерно один дополнительный vCPU. Это оправданный обмен: один незамеченный агент с 12 параллельными сессиями за неделю способен вывести из экономики ценность, эквивалентную тысячам долларов в премиум-валюте.

Лучшие практики

  1. Не баньте по первому сигналу: одна сессия с аномальным скорингом — не доказательство. И сильные игроки, и AI-агенты дают выбросы в поведенческих сигналах. Используйте скользящее окно минимум из 5 сессий, прежде чем применять наказания уровня аккаунта. Надёжный индикатор — повторяющиеся высокие оценки на протяжении нескольких сессий.

  2. Настраивайте веса под свою аудиторию: веса скоринга в коде выше — отправная точка. В каждой игре свои поведенческие нормы: в ритм-игре требования к таймингу строже, чем в open-world RPG. Собирайте базовые данные с подтверждённых игроков минимум 2 недели до включения правоприменения.

  3. Дозируйте правоприменение, не баньте бинарно: используйте нарастающие ограничения вместо разрешить/заблокировать. Аккаунты с низкой репутацией попадают в очередь на скрытый матчмейкинг (только с другими аккаунтами с низкой репутацией), получают более строгие лимиты запросов или проходят дополнительную верификацию. Это сохраняет легитимных игроков, попавших под ложное срабатывание, и сдерживает ущерб от агентов.

  4. Логируйте всё и семплируйте для калибровки: логируйте каждый поведенческий сигнал, каждое изменение репутации и каждое правоприменительное действие. Вручную пересматривайте 5–10% помеченных сессий для калибровки уровня ложных срабатываний. Цель — уровень ложных срабатываний ниже 0,5%: даже 2% ложных отметок легитимных игроков создают больше тикетов в поддержку, чем сама проблема агентов.

  5. Комбинируйте server-side аутентификацию с client-side фингерпринтингом: server-side аутентификация подтверждает личность. Client-side фингерпринтинг (сигнатуры устройств, сигналы уровня ОС, ID оборудования) добавляет вторую точку корреляции, которая затрудняет переиспользование учётных данных оператором агента на разных машинах с ботами. Если один подтверждённый аккаунт за 24 часа подключается с 8 разными аппаратными отпечатками, это сигнал, на который стоит реагировать.

Когда строить самостоятельно, а когда покупать

Если ваша игра ещё до запуска или в раннем доступе и у неё меньше 1 000 DAU, у вас наверняка есть задачи поважнее. Базовых лимитов запросов и сигнатурного обнаружения ботов пока достаточно.

Когда вы достигнете масштаба, при котором агенты становятся экономически выгодной целью, — обычно от 5 000+ DAU для игр с экономикой, управляемой игроками, или соревновательными ранговыми режимами, — нужен многослойный подход, описанный выше. Система поведенческого скоринга — это ваш собственный код, потому что она зависит от специфического словаря действий и тайминговых норм вашей игры.

Слой идентичности и аутентификации не обязан быть кастомным. horizOn предоставляет аутентификацию конечных пользователей с привязкой сессий к аккаунту через email, анонимный вход, Google и Apple Sign-In, что создаёт привязку к подтверждённой личности человека, необходимую для подотчётности. Вы направляете инженерное время на поведенческий скоринг, который отличает вашу игру, а не пересобираете OAuth и управление токенами с нуля.

Следующие шаги

Начните с поведенческого скоринга в shadow mode — логируйте оценки, но не применяйте никаких мер. Прогоните его две недели на живом игровом сообществе, чтобы получить базовые показатели для вашей аудитории. Затем определите уровни доверия и меры правоприменения, настройте пороги и включите правоприменение сначала для новых сессий.

Подключите конвейер обнаружения к вашему слою аутентификации, чтобы каждая сессия вела к подтверждённой личности. Сочетание поведенческого скоринга и верификации личности даёт вам три механизма, которые Cloudflare называет необходимыми для управления новой волной AI-посредников: вы знаете, кто действует, вы оцениваете, можно ли ему доверять, и вы привлекаете кого-то к ответственности, когда что-то идёт не так.


Источник: Агенты — не люди (но почти)