게임 서버에서의 AI 에이전트 탐지: 기존 Anti-Cheat가 실패하는 이유와 책임 추적성 구축 방법
핵심 요약
게임 서버에서 AI 에이전트를 효과적으로 탐지하고 행동 점수화, 신원 검증, 평판 기반 책임 추적성으로 Backend를 안전하게 보호하는 단계별 실행 가이드를 통해 기존 Anti-Cheat의 한계를 극복하고 경제와 Matchmaking 무결성을 지키세요.
AI 에이전트 — 스크립트도, 봇도, CAPTCHA 해결사도 아닌, 완전 자율적인 LLM 기반 시스템 — 이 게임 서버에 나타나고 있으며, 기존 Anti-Cheat가 잡도록 설계된 위협과는 전혀 다르게 보입니다.
전통적인 봇이 비인간적인 속도로 입력을 쏟아내는 것과 달리, 최신 AI 에이전트는 게임 메뉴를 탐색하고, 채팅에 응답하고, 인간의 타이밍을 흉내 내며, 도전을 받으면 적응합니다. 이들은 실제 플레이어와 서버 사이에 중개자로 자리 잡으며, Backend에는 이를 구별할 신뢰할 만한 메커니즘이 없습니다.
이 글은 이러한 에이전트를 탐지하고, 행동을 점수화하며, 경제, Matchmaking 무결성, 경쟁 래더가 훼손되기 전에 게임 Backend에 책임 추적성을 구축하기 위한 런북입니다.
AI 에이전트가 봇이 아닌 이유 (그리고 그것이 중요한 이유)
전통적인 봇 탐지는 몇 가지 특징에 의존합니다:
- 비인간적인 입력 패턴: 고정 간격 클릭, 픽셀 완벽한 조준, 반응 분산 0
- 세션 이상 징후: 하루 23시간 이상 로그인, 유휴 시간 0
- 알려진 시그니처: 일반적인 자동화 도구에 대한 해시 매칭
AI 에이전트는 이러한 모든 가정을 깨뜨립니다.
AI 에이전트가 전통적인 봇 자동화와 다른 점
| 탐지 신호 | 전통적인 봇 | AI 에이전트 |
|---|---|---|
| 입력 타이밍 | 고정 간격 | 가변적, 인간과 유사한 분포 |
| 의사 결정 | 스크립트 기반, 결정적 | 적응형, 확률적 |
| 오류율 | 오류 0 또는 반복 오류 | 실수를 자연스럽게 하고 회복 |
| CAPTCHA | 솔버 도구 필요 | 멀티모달 LLM으로 ~95% 성공률 통과 |
| 세션 지속 시간 | 무한 또는 고정 | 휴식을 포함한 인간 플레이 패턴 모방 |
| 병렬 작업 | 단일 스크립트, 다중 계정 | 클라우드 호스팅, 수백 개 동시 세션 실행 |
AI 에이전트는 단순히 버튼을 클릭하지 않습니다. 게임 상태를 추론합니다. UI를 읽고, 목표를 해석하며, 숙련된 플레이어의 선택처럼 보이는 결정을 내립니다. Anti-Cheat가 이를 플래그하면, 에이전트는 다음 세션에서 행동 패턴을 적응시킵니다.
게임 Backend에서의 실패 모드
AI 에이전트가 탐지되지 않고 작동하면 특정한 연쇄 실패를 일으킵니다:
경제 인플레이션: 에이전트가 24/7 리소스를 파밍하여 경매장을 넘치게 하고 통화 가치를 하락시킵니다. 잘 구성된 단일 에이전트는 12-15개의 동시 세션을 실행할 수 있으며, 각 세션은 일반 인간 플레이어의 일일 리소스 생산량의 3-5배를 생성합니다.
Matchmaking 오염: 에이전트가 제어하는 계정이 랭크 큐에 상주하여 MMR 계산을 부풀리고, 한쪽에 초효율적인 비인간이 있는 "죽은" 매치를 만듭니다.
티켓 큐 홍수: 지원 시스템이 초기 분류를 통과할 만큼 그럴듯해 보이는 에이전트 발신 티켓으로 압도되어, 실제 플레이어에게 돌아가야 할 직원 시간을 잡아먹습니다.
용량 낭비: 서버 인프라는 실제 참여나 수익을 전혀 생성하지 않는 에이전트 세션에 컴퓨팅 비용을 지불합니다.
탐지 레이어 1: 행동 핑거프린팅
첫 번째 레이어는 행동 기반입니다. 개별 입력을 보는 대신 세션이 시간에 따라 어떻게 행동하는지 분석합니다. 이미 시그니처 기반 탐지를 뚫은 에이전트를 여기서 잡아냅니다.
주요 행동 신호
액션 간격 분포: 인간은 무작위로 행동하지 않지만, 고정된 간격으로 행동하지도 않습니다. 인간의 액션 타이밍은 로그정규 분포를 따릅니다. 대부분의 액션은 기본 리듬 주변에 모여 있고 가끔 이상치가 있습니다. 봇은 균등 분포 또는 지수 분포를 생성합니다. AI 에이전트는 그 중간에 해당하는 것을 생성합니다. 로그정규에 근접하지만 의심스러울 정도로 타이트한 분산을 보입니다(변동 계수는 일반적으로 0.100.25, 실제 인간은 0.300.60).
결정 엔트로피: 플레이어가 전체 액션 대비 얼마나 다양한 게임 액션을 사용하는지 측정합니다. 서바이벌 게임을 하는 인간은 채집, 건설, 탐험, 전투를 유기적인 클러스터로 오가며 사용합니다. 봇은 하나의 시퀀스를 반복하는 경향이 있습니다. AI 에이전트는 여러 액션을 사용하지만 최적의 액션을 선택하는 데 통계적으로 불가능할 정도의 일관성을 보입니다.
회복 패턴: 인간이 실수를 하면 — 벽에 부딪히거나 입력을 놓치면 — 특징적인 교정 지연을 보인 후 조정합니다. AI 에이전트도 실수를 합니다(이것은 설계된 것입니다). 하지만 "실수"가 유기적이 아니라 생성된 것이기 때문에 교정 타이밍이 더 타이트한 분포를 따릅니다.
세션 스태미나: 인간은 피로해집니다. 2시간 세션 동안 분당 액션 수가 15-30% 감소합니다. 휴식을 취하고, 알트탭을 합니다. AI 에이전트는 피로를 가장하도록 명시적으로 프로그래밍되지 않는 한 전체 세션에서 ±3% 일관성을 유지합니다.
에이전트 점수화 구현
다음은 게임 서버 앞에서 미들웨어로 실행되는 실용적인 세션 점수화 시스템입니다:
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 에이전트는 결국 그들의 행동 분포를 모방하는 법을 배우게 됩니다. 그래서 다음 두 레이어가 필요하며, 탐지 시스템이 무엇을 잡든 익스플로잇 패턴에 대비한 Netcode 강화가 전제 조건입니다.
탐지 레이어 2: 신원 검증
행동 점수화는 무언가가 어떻게 행동하는지 알려줍니다. 신원 검증은 누가 행동하는지, 그리고 검증된 인간이 세션 뒤에 있다는 것이 보장되는지 묻습니다.
여기서 "신뢰할 수 있는 위임(trusted delegation)" 개념이 중요해집니다. AI 에이전트는 중개자입니다. 실제 사용자와 서버 사이에 있는 무언가입니다. 서버는 인간의 트래픽이 아닌 에이전트의 트래픽을 봅니다. 관계를 복원하려면 모든 세션에 바인딩된 검증된 인간 신원을 보장하는 메커니즘이 필요합니다.
모든 요청 뒤에 신원 배치
실용적인 아키텍처는 세 가지 구성 요소로 이루어집니다:
1. 사전 세션 인증 게이트: 플레이어가 게임 서버에 도달하기 전에 ID 제공자를 통해 인증합니다. 이렇게 하면 검증된 인간 신원(이메일, 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 에이전트가 작동하려면 자격 증명이 필요합니다. 생성된 이메일 주소가 아니라 사용자를 직접 검증한 OAuth 제공자 또는 전화번호 연동 계정과 같은 인간 검증 인증을 요구하면, 에이전트 운영자는 실제 자격 증명을 대규모로 확보해야 합니다.
이것이 에이전트 운영을 불가능하게 만들지는 않지만, 경제성을 바꿉니다. 50개의 동시 세션을 실행하는 단일 에이전트는 이제 각각 실제 이메일이 있고 인증 흐름을 통과하는 50개의 검증된 계정을 필요로 합니다. 세션당 비용이 올라가 많은 익스플로잇 시나리오가 수익성이 없어지는 지점에 도달합니다.
인디 및 중소 규모 팀의 경우 견고한 인증 레이어를 처음부터 구현하는 데 일반적으로 2-4주가 걸립니다. OAuth 통합, 토큰 갱신 로직, 세션 바인딩, 만료된 토큰 및 계정 복구에 대한 엣지 케이스 처리가 필요합니다. horizOn과 같은 플랫폼은 이메일, 익명, Google, Apple 로그인을 지원하는 최종 사용자 인증 및 계정 바인딩 세션을 기본 제공하므로, 개발 프로젝트가 아닌 구성 단계로 줄여줍니다.
자격 증명 테이블을 노출하는 데이터 유출은 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개의 동시 세션을 처리하는 배포 환경의 현실적인 수치는 다음과 같습니다:
- 행동 분석: 액션 배치당 약 2ms(50개 액션마다). 게임 루프에 추가되는 지연 시간은 무시할 수 있습니다.
- 평판 조회: 캐시된 경우 약 0.5ms, 캐시 미스 시 약 3ms(세션의 첫 번째 액션). Redis 또는 이에 상응하는 인메모리 저장소로 구현합니다.
- 인증 토큰 검증: 로컬 검증을 통한 JWT는 약 1ms, 원격 인증 엔드포인트 호출은 약 5-15ms. 사전 검증하고 적극적으로 캐시합니다.
세션당 추가 지연 시간은 정상 부하에서 액션 배치당 3-5ms입니다. 행동 분석이 가장 CPU 집약적인 구성 요소이며, 10,000개의 동시 세션에서 약 1개의 추가 vCPU를 소비합니다. 일주일 동안 12개의 병렬 세션을 실행하는 단일 무검사 에이전트가 수천 달러 상당의 프리미엄 통화에 해당하는 플레이어 경제 가치를 고갈시킬 수 있다는 점을 고려하면 감수할 만한 트레이드오프입니다.
모범 사례
첫 신호만으로 차단하지 마세요: 비정상적인 점수를 생성한 단일 세션은 증거가 아닙니다. 숙련된 플레이어와 AI 에이전트 모두 이상치 행동 신호를 생성합니다. 계정 수준 페널티를 적용하기 전에 최소 5개 세션의 롤링 윈도우를 사용하세요. 세션 전반에 걸친 반복적인 높은 점수가 신뢰할 수 있는 지표입니다.
자체 플레이어 인구에 맞게 가중치를 조정하세요: 위 코드의 점수 가중치는 시작점입니다. 모든 게임은 행동 규범이 다릅니다. 리듬 게임은 오픈월드 RPG보다 더 타이트한 타이밍 기대치를 가집니다. 집행을 활성화하기 전에 최소 2주 동안 검증된 인간 플레이어의 기준 데이터를 수집하세요.
집행을 단계적으로 적용하고, 이진 차단을 하지 마세요: 허용/차단 대신 점진적인 마찰을 사용하세요. 평판이 낮은 계정은 섀도우 매치 세션(다른 낮은 평판 계정과만 매칭)에 대기시키거나, 더 엄격한 속도 제한에 직면하거나, 2차 검증 과제를 트리거합니다. 이렇게 하면 오탐을 유발한 합법적인 플레이어를 보존하면서 에이전트 피해를 억제할 수 있습니다.
모든 것을 로깅하고, 보정을 위해 샘플링하세요: 모든 행동 신호, 모든 평판 조정, 모든 집행 조치를 로깅하세요. 플래그된 세션의 5-10%를 수동으로 검토하여 오탐률을 보정하세요. 오탐률을 0.5% 미만으로 목표하세요. 합법적인 플레이어의 2%만 플래그해도 에이전트 문제 자체가 생성하는 것보다 더 많은 지원 티켓이 발생합니다.
서버 측 인증과 클라이언트 측 핑거프린팅을 결합하세요: 서버 측 인증은 신원을 검증합니다. 클라이언트 측 핑거프린팅(기기 시그니처, OS 수준 신호, 하드웨어 ID)은 에이전트 운영자가 여러 봇 머신에서 자격 증명을 재사용하기 어렵게 만드는 두 번째 상관 지점을 추가합니다. 단일 검증 계정이 24시간 안에 8개의 다른 하드웨어 핑거프린트에서 연결된다면, 이는 조치를 취할 가치가 있는 신호입니다.
직접 구축할 때 vs. 구매할 때
게임이 출시 전이거나 일일 활성 사용자가 1,000명 미만인 얼리 액세스 단계라면 더 중요한 우선순위가 있을 것입니다. 기본적인 속도 제한과 시그니처 기반 봇 탐지로 당분간 충분합니다.
에이전트가 경제적으로 매력적인 대상이 되는 규모 — 일반적으로 플레이어 주도 경제 또는 경쟁 랭크 모드가 있는 게임의 경우 DAU 5,000 이상 — 에 도달하면 위에서 설명한 레이어드 접근 방식이 필요합니다. 행동 점수화 시스템은 게임의 특정 액션 어휘와 타이밍 규범에 의존하기 때문에 직접 소유하는 맞춤 코드입니다.
신원 및 인증 레이어는 맞춤 제작이 필요 없습니다. horizOn은 이메일, 익명, Google, Apple 로그인에 걸친 계정 바인딩 세션과 함께 최종 사용자 인증을 제공하여 책임 추적성에 필요한 검증된 인간 신원 바인딩을 구축합니다. OAuth와 토큰 관리를 처음부터 다시 구축하는 대신 게임을 차별화하는 행동 점수화에 엔지니어링 시간을 집중하세요.
다음 단계
섀도우 모드에서 행동 점수화 시스템을 시작하세요. 점수를 로깅하되 집행 조치는 취하지 마세요. 실제 플레이어 기반을 대상으로 2주간 실행하여 특정 인구에 대한 기준을 수립하세요. 그런 다음 신뢰 등급과 집행 조치를 정의하고, 임계값을 튜닝한 후, 새 세션부터 집행을 활성화하세요.
탐지 파이프라인을 인증 레이어에 연결하여 모든 세션이 검증된 신원으로 추적되도록 하세요. 행동 점수화와 신원 검증의 조합은 Cloudflare가 새로운 AI 중개자 물결을 관리하는 데 필수적이라고 식별한 세 가지 메커니즘을 제공합니다. 누가 행동하는지 알고, 신뢰할 수 있는지 측정하며, 문제가 발생했을 때 누군가에게 책임을 묻습니다.