Обнаружение AI-агентов на игровых серверах: почему традиционный анти-чит не справляется и как выстроить подотчётность
Коротко о главном
Узнайте, как выявлять AI-агентов на игровых серверах: поведенческий скоринг, верификация личности и репутация защищают экономику и матчмейкинг.
AI-агенты — не скрипты, не боты, не решатели CAPTCHA, а полностью автономные системы на базе LLM — появляются на игровых серверах, и они совсем не похожи на угрозы, против которых создавался ваш анти-чит.
В отличие от традиционных ботов, засыпающих сервер вводами с нечеловеческой скоростью, современные AI-агенты перемещаются по меню, отвечают в чат, имитируют человеческий тайминг и адаптируются при проверках. Они находятся между реальным игроком и вашим сервером как посредники, и ваш backend не имеет надёжного механизма, чтобы отличить их.
Это runbook по обнаружению таких агентов, оценке их поведения и встраиванию подотчётности в игровой backend, пока экономика, целостность матчмейкинга и соревновательные рейтинги не пострадали.
Почему AI-агенты — это не боты (и почему это важно)
Традиционное обнаружение ботов опирается на несколько признаков:
- Нечеловеческие паттерны ввода: клики с фиксированным интервалом, идеальный аим, нулевая вариативность реакции
- Аномалии сессий: игроки онлайн 23+ часов в сутки, нулевое время простоя
- Известные сигнатуры: сопоставление хэшей с распространёнными инструментами автоматизации
AI-агенты ломают все эти предположения.
Чем AI-агенты отличаются от традиционной бот-автоматизации
| Сигнал обнаружения | Традиционный бот | AI-агент |
|---|---|---|
| Тайминг ввода | Фиксированные интервалы | Изменчивые, человекоподобные распределения |
| Принятие решений | Скриптовое, детерминированное | Адаптивное, вероятностное |
| Частота ошибок | Ноль ошибок или повторяющиеся ошибки | Ошибается и естественно исправляется |
| CAPTCHA | Требует инструмент для решения | Проходит с ~95% успехом через мультимодальную LLM |
| Длительность сессии | Бесконечная или фиксированная | Имитирует человеческие паттерны игры, включая перерывы |
| Параллельные операции | Один скрипт, много аккаунтов | Облачный хостинг, сотни одновременных сессий |
AI-агент не просто кликает по кнопкам — он анализирует состояние игры. Он читает интерфейс, интерпретирует цели и принимает решения, которые выглядят как выбор опытного игрока. Когда ваш анти-чит помечает его, агент адаптирует свою модель поведения к следующей сессии.
Типовой сценарий отказа в игровых backend'ах
Когда AI-агенты действуют незамеченными, они вызывают цепочки специфических сбоев:
Инфляция экономики: агенты добывают ресурсы 24/7, заполняя аукционы и обесценивая валюту. Один хорошо настроенный агент может вести 12–15 параллельных сессий, каждая из которых производит в 3–5 раз больше дневного ресурса, чем обычный игрок.
Разрушение матчмейкинга: аккаунты под управлением агентов сидят в рейтинговых очередях, завышая расчёты MMR и создавая «мёртвые» матчи, где одна из сторон — сверхэффективный нечеловек.
Переполнение очереди тикетов: системы поддержки захлёбываются от тикетов, созданных агентами, которые выглядят достаточно легитимно, чтобы пройти первичную сортировку, — на это уходят часы работы, которые должны тратиться на реальных игроков.
Пустая трата мощностей: ваша серверная инфраструктура платит за вычислительные ресурсы для сессий агентов, которые не приносят ни вовлечённости, ни дохода.
Слой обнаружения 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 параллельными сессиями за неделю способен вывести из экономики ценность, эквивалентную тысячам долларов в премиум-валюте.
Лучшие практики
Не баньте по первому сигналу: одна сессия с аномальным скорингом — не доказательство. И сильные игроки, и AI-агенты дают выбросы в поведенческих сигналах. Используйте скользящее окно минимум из 5 сессий, прежде чем применять наказания уровня аккаунта. Надёжный индикатор — повторяющиеся высокие оценки на протяжении нескольких сессий.
Настраивайте веса под свою аудиторию: веса скоринга в коде выше — отправная точка. В каждой игре свои поведенческие нормы: в ритм-игре требования к таймингу строже, чем в open-world RPG. Собирайте базовые данные с подтверждённых игроков минимум 2 недели до включения правоприменения.
Дозируйте правоприменение, не баньте бинарно: используйте нарастающие ограничения вместо разрешить/заблокировать. Аккаунты с низкой репутацией попадают в очередь на скрытый матчмейкинг (только с другими аккаунтами с низкой репутацией), получают более строгие лимиты запросов или проходят дополнительную верификацию. Это сохраняет легитимных игроков, попавших под ложное срабатывание, и сдерживает ущерб от агентов.
Логируйте всё и семплируйте для калибровки: логируйте каждый поведенческий сигнал, каждое изменение репутации и каждое правоприменительное действие. Вручную пересматривайте 5–10% помеченных сессий для калибровки уровня ложных срабатываний. Цель — уровень ложных срабатываний ниже 0,5%: даже 2% ложных отметок легитимных игроков создают больше тикетов в поддержку, чем сама проблема агентов.
Комбинируйте 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-посредников: вы знаете, кто действует, вы оцениваете, можно ли ему доверять, и вы привлекаете кого-то к ответственности, когда что-то идёт не так.
Источник: Агенты — не люди (но почти)