AI-agentdetectie op game servers: waarom traditionele anti-cheat faalt en hoe je verantwoordelijkheid opbouwt
Kort samengevat
Ontdek hoe je AI-agents op game servers detecteert, waarom traditionele anti-cheat faalt en hoe je verantwoordelijkheid in je game-backend inbouwt.
AI-agents — geen scripts, geen bots, geen CAPTCHA-oplossers, maar volledig autonome systemen op basis van LLM's — duiken op game servers op en lijken in geen enkel opzicht op de bedreigingen waarvoor je anti-cheat is gebouwd.
In tegenstelling tot traditionele bots die met bovenmenselijke snelheid inputs spammen, navigeren moderne AI-agents door gamemenu's, reageren ze op chat, imiteren ze menselijke timing en passen ze zich aan wanneer ze worden uitgedaagd. Ze fungeren als tussenpersoon tussen de echte speler en je server, en je backend heeft geen betrouwbaar mechanisme om het verschil te zien.
Dit is een runbook voor het detecteren van deze agents, het scoren van hun gedrag en het inbouwen van verantwoordelijkheid in je game-backend voordat je economie, matchmaking-integriteit of competitieve ranglijsten worden gecompromitteerd.
Waarom AI-agents geen bots zijn (en waarom dat ertoe doet)
Traditionele botdetectie vertrouwt op een paar kenmerken:
- Bovenmenselijke invoerpatronen: klikken op vaste intervallen, pixel-perfecte aim, geen variatie in reactietijd
- Sessie-anomalieën: spelers die 23+ uur per dag ingelogd zijn, geen idle-tijd
- Bekende handtekeningen: hash-matching tegen veelgebruikte automatiseringstools
AI-agents doorbreken al deze aannames.
Hoe AI-agents verschillen van traditionele botautomatisering
| Detectiesignaal | Traditionele bot | AI-agent |
|---|---|---|
| Invoertiming | Vaste intervallen | Variabele, mensachtige verdelingen |
| Besluitvorming | Scriptmatig, deterministisch | Adaptief, probabilistisch |
| Foutpercentage | Nul fouten of herhaalde fouten | Maakt fouten en herstelt natuurlijk |
| CAPTCHA | Vereist solvertool | Slaagt met ~95% succes via multimodale LLM |
| Sessieduur | Oneindig of vast | Bootst menselijke speelpatronen na, inclusief pauzes |
| Parallelle operaties | Enkel script, veel accounts | Cloud-gehost, draait honderden gelijktijdige sessies |
Een AI-agent klikt niet zomaar op knoppen — hij redeneert over de gamestate. Hij leest de UI, interpreteert doelstellingen en neemt beslissingen die lijken op de keuzes van een vaardige speler. Wanneer je anti-cheat hem markeert, past de agent zijn gedragspatroon aan in de volgende sessie.
De faalmodus in game-backends
Wanneer AI-agents onopgemerkt opereren, veroorzaken ze specifieke cascade-fouten:
Economische inflatie: Agents grinden 24/7 resources, overspoelen veilingen en devalueren valuta. Een enkele goed geconfigureerde agent kan 12-15 gelijktijdige sessies draaien, die elk 3-5x de dagelijkse resource-output van een typische menselijke speler genereren.
Corrupte matchmaking: Door agents aangestuurde accounts in ranked-queues blazen MMR-berekeningen op en creëren "dode" wedstrijden waarin één kant een hyperefficiënte niet-mens is.
Overstromende ticketqueue: Supportsystemen worden overspoeld met tickets die door agents zijn gegenereerd en legitiem genoeg lijken om de eerste triage te passeren — waardoor personeelsuren worden verspild die naar echte spelers zouden moeten gaan.
Capaciteitsverspilling: Je serverinfrastructuur betaalt rekenkosten voor agentsessies die nul echte betrokkenheid of omzet genereren.
Detectielaag 1: Gedragsfingerprinting
De eerste laag is gedragsmatig — analyseren hoe een sessie zich in de loop van de tijd gedraagt in plaats van naar individuele inputs te kijken. Dit is waar je agents betrapt die op handtekeningen gebaseerde detectie al hebben verslagen.
Belangrijke gedragssignalen
Actie-intervalverdeling: Mensen handelen niet willekeurig, maar ook niet op vaste intervallen. De timing van menselijke acties volgt een log-normale verdeling — de meeste acties clusteren rond een basisritme met af en toe uitschieters. Bots produceren uniforme of exponentiële verdelingen. AI-agents produceren iets daartussenin: ze benaderen log-normaal, maar met een verdacht strakke variantie (variatiecoëfficiënt doorgaans tussen 0,10 en 0,25, vergeleken met 0,30-0,60 voor echte mensen).
Beslissingsentropie: Meet hoeveel verschillende game-acties een speler gebruikt ten opzichte van zijn totale acties. Een mens die een survivalgame speelt, wisselt af tussen verzamelen, bouwen, verkennen en vechten — met organische clusters. Een bot herhaalt doorgaans één sequentie. Een AI-agent gebruikt meerdere acties, maar met statistisch onwaarschijnlijke consistentie in het kiezen van de optimale.
Herstelpatronen: Wanneer een mens een fout maakt — tegen een muur loopt, een input mist — vertoont hij een karakteristieke correctievertraging en past zich daarna aan. AI-agents maken ook fouten (dat is ingebouwd), maar hun correctietiming volgt een strakkere verdeling omdat de "fout" gegenereerd is in plaats van organisch.
Sessie-uithoudingsvermogen: Mensen gaan achteruit. Hun acties per minuut dalen 15-30% over een sessie van twee uur. Ze nemen pauzes. Ze alt-tabben. AI-agents handhaven ±3% consistentie over hele sessies, tenzij ze expliciet zijn geprogrammeerd om vermoeidheid te faken.
Implementatie van agentscoring
Hier is een praktisch sessiescoresysteem dat als middleware voor je game server draait:
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()},
}
Dit is geen wondermiddel. Een AI-agent die via een fine-tuning-loop tegen de spelerspopulatie van jouw specifieke game wordt getraind, zal uiteindelijk leren om hun gedragsverdelingen na te bootsen. Daarom heb je de volgende twee lagen nodig — en waarom het harden van je netcode tegen exploitpatronen een vereiste is, ongeacht wat het detectiesysteem oppikt.
Detectielaag 2: Identiteitsverificatie
Gedragsscoring vertelt je hoe iets handelt. Identiteitsverificatie vraagt wie er handelt — en of er gegarandeerd een geverifieerd mens achter de sessie zit.
Hier wordt het concept van "vertrouwde delegatie" cruciaal. Een AI-agent is een tussenpersoon — iets tussen de echte gebruiker en je server. Je server ziet het verkeer van de agent, niet dat van de mens. Om de relatie te herstellen, heb je een mechanisme nodig dat garandeert dat een geverifieerde menselijke identiteit aan elke sessie is gekoppeld.
Identiteit achter elk verzoek plaatsen
De praktische architectuur heeft drie componenten:
1. Pre-sessie-authenticatiepoort: Voordat een speler je game server bereikt, authenticeert hij via een identityprovider. Dit creëert een token dat een geverifieerde menselijke identiteit (e-mail, OAuth-account, telefoonnummer) aan de sessie bindt.
2. Tokenpropagatie: Het authenticatietoken reist mee met elke API-call en game server RPC. Je server valideert het token bij elk verzoek — niet alleen bij het inloggen.
3. Token-sessiebinding: Het token is cryptografisch gebonden aan de specifieke sessie. Als een agent een token probeert te hergebruiken over parallelle sessies, faalt de binding en wordt de sessie afgewezen.
[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
Waarom dit AI-agents stopt
Een AI-agent heeft credentials nodig om te kunnen opereren. Als je mensgeverifieerde authenticatie vereist — niet zomaar een gegenereerd e-mailadres, maar een OAuth-provider die de gebruiker zelf heeft geverifieerd, of een account dat aan een telefoonnummer is gekoppeld — moet de agentoperator op schaal echte credentials verkrijgen.
Dit maakt de exploitatie van agents niet onmogelijk, maar het verandert de economie. Een enkele agent die 50 gelijktijdige sessies draait, vereist nu 50 geverifieerde accounts, elk met een echt e-mailadres, elk door je auth-flow. De kosten per sessie stijgen naar een punt waarop veel exploitscenario's onrendabel worden.
Voor indie- en middelgrote teams kost het implementeren van een robuuste auth-laag vanaf nul doorgaans 2-4 weken — je hebt OAuth-integratie, token-refresh-logica, sessiebinding en edge-case-afhandeling voor verlopen tokens en accountherstel nodig. Platforms zoals horizOn bieden end-user-authenticatie en accountgebonden sessies out of the box, met ondersteuning voor e-mail, anoniem, Google en Apple-inloggen, waardoor dit een configuratiestap wordt in plaats van een ontwikkelproject.
Een datalek dat credentialtabellen blootlegt, is bijzonder gevaarlijk wanneer AI-agents bestaan — gestolen credentials worden op machinesnelheid ingezet als wapen. Onze uiteenzetting over hoe je backends architecteert om credential-compromissen te overleven behandelt de opslag- en rotatiepatronen die de blast radius beperken.
Detectielaag 3: Reputatie en verantwoordelijkheid
Identiteit vertelt je wie. Reputatie vertelt je of je ze vertrouwt. Verantwoordelijkheid vertelt je wie betaalt wanneer er iets misgaat.
Een reputatiescore per account opbouwen
Een reputatiesysteem kent elke geverifieerde identiteit een vertrouwensscore toe die stijgt bij legitiem gedrag en daalt bij verdachte activiteit. Accounts met een hoge reputatie krijgen meer autonomie; accounts met een lage reputatie krijgen te maken met toenemende frictie.
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]
Verantwoordelijkheid: wie antwoordt wanneer dingen misgaan
Verantwoordelijkheid betekent dat wanneer een agent schade veroorzaakt — een markteconomie laten crashen, een bug exploiteren, matches griefen — er een echt mens is die verantwoordelijk en traceerbaar is.
Voor game-backends betekent dit:
Accountsuspensie is permanent: Omdat sessies aan geverifieerde identiteiten zijn gebonden, ban je een menselijke operator, niet een wegwerp-gameaccount. De kosten van een ban zijn hoger, wat agentinzet ontmoedigt.
Economische rollback is gericht: Je weet precies welke geverifieerde identiteit de frauduleuze resources heeft gegenereerd. Rollback is chirurgisch in plaats van serverbreed.
Bezwaren zijn verwerkbaar: Een mens kan bezwaar maken tegen een false positive. Hun verificatieketen bewijst dat ze echt zijn. Zonder die keten is elk geband account een ruisgenerator.
Alles samen: de volledige detectiepipeline
De drie lagen vormen een requestpipeline die op elke inkomende verbinding draait:
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
└─────────────────────┘
Overhead en kosten
Het draaien van deze pipeline is niet gratis. Realistische cijfers van een deployment die ~10.000 gelijktijdige sessies verwerkt:
Gedragsanalyse: ~2ms per actiebatch (elke 50 acties). Verwaarloosbare latentie toegevoegd aan de gameloop.
Reputatie-opzoekingen: ~0,5ms gecached, ~3ms bij een cache miss (eerste actie van een sessie). Implementeer met Redis of een gelijkwaardige in-memory store.
Auth-tokenvalidatie: ~1ms voor JWT met lokale verificatie; ~5-15ms voor remote auth-endpoint-aanroepen. Pre-valideer en cache agressief.
Totale toegevoegde latentie per sessie: 3-5ms per actiebatch onder normale belasting. De gedragsanalyse is het meest CPU-intensieve onderdeel; bij 10.000 gelijktijdige sessies verbruikt het ongeveer één extra vCPU. Dat is een afweging die de moeite waard is, aangezien een enkele ongecontroleerde agent die een week lang 12 parallelle sessies draait, spelerseconomie kan leegtrekken ter waarde van duizenden dollars aan premiumvaluta.
Best practices
Ban niet op het eerste signaal: Een enkele sessie met een afwijkende score is geen bewijs. Vaardige spelers en AI-agents produceren allebei uitschieters in gedragssignalen. Gebruik een rollend venster van ten minste 5 sessies voordat je accountniveau-straffen toepast. Herhaalde hoge scores over meerdere sessies zijn de betrouwbare indicator.
Stem gewichten af op je eigen spelerspopulatie: De scoringsgewichten in de code hierboven zijn startpunten. Elke game heeft andere gedragsnormen — een ritmegame heeft strakkere timingverwachtingen dan een open-wereld-RPG. Verzamel ten minste 2 weken basisgegevens van geverifieerde menselijke spelers voordat je handhaving activeert.
Trapeer je handhaving, ban niet binair: Gebruik geleidelijke frictie in plaats van toestaan/blokkeren. Accounts met een lage reputatie worden in shadow-matched sessies geplaatst (alleen gekoppeld aan andere accounts met een lage reputatie), krijgen strengere rate limits of triggeren secundaire verificatie-uitdagingen. Dit behoudt legitieme spelers die false positives veroorzaakten terwijl agentschade wordt ingeperkt.
Log alles, steekproef voor kalibratie: Log elk gedragssignaal, elke reputatie-aanpassing en elke handhavingsactie. Beoordeel handmatig 5-10% van de gemarkeerde sessies om je false-positive-percentage te kalibreren. Streef naar een false-positive-percentage onder 0,5% — het markeren van zelfs 2% van de legitieme spelers genereert meer supporttickets dan het agentprobleem zelf veroorzaakt.
Combineer server-side auth met client-side fingerprinting: Server-side auth verifieert identiteit. Client-side fingerprinting (apparaat-handtekeningen, signalen op OS-niveau, hardware-ID's) voegt een tweede correlatiepunt toe dat het moeilijker maakt voor een agentoperator om credentials te hergebruiken over verschillende botmachines. Als een enkel geverifieerd account binnen 24 uur verbinding maakt vanaf 8 verschillende hardware-fingerprints, is dat een signaal om op te acteren.
Wanneer bouwen vs. wanneer kopen
Als je game pre-launch of in early access is met minder dan 1.000 dagelijks actieve gebruikers, heb je waarschijnlijk grotere prioriteiten. Basale rate limiting en op handtekeningen gebaseerde botdetectie zijn voorlopig voldoende.
Zodra je de schaal bereikt waarop agents economisch interessante doelwitten worden — doorgaans rond 5.000+ DAU voor games met spelergestuurde economieën of competitieve ranked-modi — heb je de hierboven beschreven gelaagde aanpak nodig. Het gedragsscoresysteem is eigen custom code, omdat het afhangt van de specifieke actiewoordenschat en timingnormen van je game.
De identiteits- en authenticatielaag hoeft niet custom te zijn. horizOn biedt end-user-authenticatie met accountgebonden sessies via e-mail, anoniem, Google en Apple-inloggen, waarmee de geverifieerde menselijke identiteitsbinding wordt gevestigd die verantwoordelijkheid vereist. Je richt je engineeringtijd op de gedragsscoring die je game onderscheidt, in plaats van OAuth en tokenbeheer vanaf nul opnieuw op te bouwen.
Volgende stappen
Start met het gedragsscoresysteem in shadow mode — log scores maar voer geen handhavingsacties uit. Draai het twee weken tegen je live spelersbestand om basislijnen voor je specifieke populatie vast te stellen. Definieer daarna vertrouwensniveaus en handhavingsacties, stem je drempels af en activeer handhaving eerst voor nieuwe sessies.
Verbind de detectiepipeline met je auth-laag om ervoor te zorgen dat elke sessie terug te voeren is naar een geverifieerde identiteit. De combinatie van gedragsscoring en identiteitsverificatie geeft je de drie mechanismen die Cloudflare identificeert als essentieel voor het beheersen van de nieuwe golf AI-tussenpersonen: je weet wie er handelt, je meet of je ze vertrouwt, en je houdt iemand verantwoordelijk wanneer dingen misgaan.
Bron: Agents zijn geen mensen (maar eigenlijk een beetje wel)