Bloga Dön

Game Sunucularında AI Agent Tespiti

Yayınlanma tarihi 10 Kasım 2026
Game Sunucularında AI Agent Tespiti Yapay zekâ yardımıyla oluşturuldu

Özet olarak

Game sunucularında geleneksel anti-cheat sistemlerini atlatan otonom AI agent'ları tespit etmek, davranışsal puanlama yapmak ve hesap verebilirlik mimarisi kurmak için pratik bir rehber.

Game sunucularınızda geleneksel anti-cheat sistemlerinin neden yetersiz kaldığını ve hesap verebilirlik mimarisi kurmanın yollarını öğrenin.

AI agent'lar — script'ler, botlar veya CAPTCHA çözücüler değil, tamamen otonom LLM destekli sistemler — game sunucularında görünmeye başladı ve anti-cheat sisteminizin yakalamak üzere tasarlandığı tehditlere hiç benzemiyorlar.

Girdi verilerini insan dışı bir hızla spam'leyen geleneksel botların aksine, modern AI agent'lar oyun menülerinde gezinir, sohbetlere yanıt verir, insan zamanlamasını taklit eder ve zorluklarla karşılaştıklarında adapte olur. Gerçek oyuncu ile sunucunuz arasında aracı olarak otururlar ve backend'iniz aradaki farkı anlamak için güvenilir bir mekanizmaya sahip değildir.

Bu rehber, ekonominiz, matchmaking bütünlüğünüz veya rekabetçi sıralamalarınız zarar görmeden önce bu agent'ları tespit etmek, davranışlarını puanlamak ve game backend'inize hesap verebilirlik inşa etmek için yazılmıştır.

AI Agent'lar Neden Bot Değildir (Ve Bu Neden Önemlidir)

Geleneksel bot tespiti birkaç temel özelliğe dayanır:

  • İnsan dışı girdi kalıpları: Sabit aralıklı tıklamalar, piksel mükemmelliğinde nişan alma, sıfır tepki varyansı
  • Oturum anomalileri: Günde 23 saatten fazla oturum açan oyuncular, sıfır boşta kalma süresi
  • Bilinen imzalar: Yaygın otomasyon araçlarına karşı hash eşleştirme

AI agent'lar bu varsayımların tümünü altüst eder.

AI Agent'lar ile Geleneksel Bot Otomasyonu Arasındaki Farklar

Tespit Sinyali Geleneksel Bot AI Agent
Girdi zamanlaması Sabit aralıklar Değişken, insana benzer dağılımlar
Karar verme Script'e dayalı, deterministik Adaptif, olasılıksal
Hata oranı Sıfır hata veya tekrarlayan hatalar Hata yapar ve bunlardan doğal şekilde kurtulur
CAPTCHA Çözücü araç gerektirir Çok modlu LLM ile ~%95 başarıyla geçer
Oturum süresi Sonsuz veya sabit Molalar dahil insan oyun kalıplarını taklit eder
Paralel operasyonlar Tek script, birçok hesap Bulut tabanlı, yüzlerce eşzamanlı oturum çalıştırır

Bir AI agent yalnızca düğmelere tıklamaz; oyun durumu hakkında muhakeme yapar. UI'ı okur, hedefleri yorumlar ve yetenekli bir oyuncunun seçimlerine benzeyen kararlar alır. Anti-cheat'iniz bunu işaretlediğinde, agent sonraki oturumda davranış kalıbını adapte eder.

Game Backend'lerindeki Hata Modu

AI agent'lar tespit edilemeden çalıştığında, belirli zincirleme hatalara neden olurlar:

  1. Ekonomi enflasyonu: Agent'lar 7/24 kaynak kasar, müzayedeleri doldurur ve para biriminin değerini düşürür. İyi yapılandırılmış tek bir agent, her biri tipik bir insan oyuncunun günlük kaynak üretiminin 3-5 katını üreten 12-15 eşzamanlı oturum çalıştırabilir.

  2. Matchmaking bozulması: Sıralı kuyruklarda oturan agent kontrollü hesaplar MMR hesaplamalarını şişirir ve bir tarafın hiper verimli insan olmayan bir oyuncuya sahip olduğu "ölü" maçlar yaratır.

  3. Destek kuyruğu dolması: Destek sistemleri, ilk triyajı geçecek kadar meşru görünen agent kaynaklı biletlerle dolup taşar; bu da gerçek oyunculara gitmesi gereken personel saatlerini harcar.

  4. Kapasite israfı: Sunucu altyapınız, sıfır gerçek etkileşim veya gelir üreten agent oturumları için işlem maliyeti öder.

Tespit Katmanı 1: Davranışsal Parmak İzi (Behavioral Fingerprint)

İlk katman davranışsaldır; bireysel girdilere bakmak zaman bir oturumun zaman içinde nasıl davrandığını analiz eder. İmza tabanlı tespiti çoktan atlatan agent'ları burada yakalarsınız.

Temel Davranış Sinyalleri

Aksiyon aralığı dağılımı: İnsanlar rastgele hareket etmez, ancak sabit aralıklarla da hareket etmezler. Bir insanın aksiyon zamanlaması log-normal bir dağılım izler; çoğu aksiyon ara sıra gelen uç değerlerle birlikte taban bir ritim etrafında kümelenir. Botlar uniform veya üstel dağılımlar üretir. AI agent'lar ise ikisi arasında bir şey üretir: log-normal dağılıma yaklaşırlar, ancak şüpheli derecede dar bir varyansa sahiptirler (gerçek insanlar için 0.30-0.60 olan varyasyon katsayısı, agent'larda tipik olarak 0.10 ile 0.25 arasındadır).

Karar entropisi: Bir oyuncunun toplam aksiyonlarına göre kaç farklı oyun aksiyonu kullandığını ölçün. Hayatta kalma oyunu oynayan bir insan; toplama, inşa etme, keşfetme ve savaşma arasında organik kümelerle geçiş yapar. Bir bot genellikle aynı diziyi tekrarlamaya meyillidir. Bir AI agent ise birden fazla aksiyonu, en optimal olanı seçmede istatistiksel olarak improbable bir tutarlılıkla kullanır.

Kurtarma kalıpları: Bir insan hata yaptığında — bir duvara çarptığında, bir girdiyi kaçırdığında — karakteristik bir düzeltme gecikmesi sergiler ve ardından uyum sağlar. AI agent'lar da hata yapar (bu duruma göre tasarlanmıştır), ancak düzeltme zamanlamaları daha dar bir dağılım izler çünkü "hata" organik olmaktan ziyade üretilmiştir.

Oturum dayanıklılığı: İnsanlar yorulur. İki saatlik bir oturum boyunca dakikadaki aksiyonları %15-30 oranında düşer. Mola verirler. Alt-tab yaparlar. AI agent'lar, yorgunluğu taklit etmek üzere açıkça programlanmadıkları sürece tüm oturum boyunca ±%3 tutarlılık korurlar.

Agent Puanlama Uygulaması

Game sunucunuzun önünde middleware olarak çalışan pratik bir oturum puanlama sistemi:

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()},
        }

Bu sihirli bir çözüm değildir. Spesifik oyununuzun oyuncu popülasyonuna karşı bir fine-tuning döngüsünden geçen bir AI agent, zamanla onların davranışsal dağılımlarını taklit etmeyi öğrenecektir. Bu yüzden sonraki iki katmana ihtiyacınız var; ve tespit sisteminin ne yakaladığından bağımsız olarak netcode'unuzu exploit kalıplarına karşı güçlendirmek bu yüzden bir ön koşuldur.

Tespit Katmanı 2: Kimlik Doğrulama (Identity Verification)

Davranışsal puanlama size bir şeyin nasıl davrandığını söyler. Kimlik doğrulama ise kimin hareket ettiğini — ve oturumun arkasında doğrulanmış bir insanın olduğunun garanti edilip edilemediğini sorar.

"Güvenilir delegasyon" (trusted delegation) kavramının kritik hale geldiği nokta burasıdır. Bir AI agent bir aracıdır — gerçek kullanıcı ile sunucunuz arasında bir şeydir. Sunucunuz insanı değil, agent'ın trafiğini görür. İlişkiyi yeniden kurmak için, her oturuma bağlı doğrulanmış bir insan kimliğini garanti eden bir mekanizmaya ihtiyacınız vardır.

Her İstek Sahibinin Arkasına Kimlik Koymak

Pratik mimari üç bileşenden oluşur:

1. Oturum öncesi kimlik doğrulama kapısı: Bir oyuncu game sunucunuza asla ulaşmadan önce bir kimlik sağlayıcı üzerinden kimlik doğrulaması yapar. Bu, doğrulanmış bir insan kimliğini (e-posta, OAuth hesabı, telefon numarası) oturuma bağlayan bir token oluşturur.

2. Token yayılımı: Kimlik doğrulama token'ı her API çağrısı ve game server RPC ile birlikte seyahat eder. Sunucunuz token'ı yalnızca girişte değil, her istekte doğrular.

3. Token-oturum bağlama: Token, kriptografik olarak belirli bir oturuma bağlanır. Bir agent paralel oturumlar arasında bir token'ı yeniden kullanmaya çalışırsa, bağlama başarısız olur ve oturum reddedilir.

[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

Bu Neden AI Agent'ları Durdurur?

Bir AI agent'ın çalışmak için kimlik bilgilerine ihtiyacı vardır. İnsan tarafından doğrulanmış kimlik doğrulaması gerektiriyorsanız — sadece üretilmiş bir e-posta adresi değil, kullanıcının kendisini doğrulamış bir OAuth sağlayıcısı veya telefon numarasına bağlı bir hesap — agent operatörünün ölçekli bir şekilde gerçek kimlik bilgileri edinmesi gerekir.

Bu, agent operasyonunu imkansız kılmaz ancak ekonomiyi değiştirir. 50 eşzamanlı oturum çalıştıran tek bir agent artık her biri gerçek e-postaya sahip, her biri auth akışınızdan geçen 50 doğrulanmış hesap gerektirir. Oturum başına maliyet, birçok exploit senaryosunun karlı olmaktan çıkacağı bir noktaya yükselir.

Bağımsız (indie) ve orta ölçekli ekipler için sıfırdan sağlam bir auth katmanı uygulamak tipik olarak 2-4 hafta sürer — OAuth entegrasyonu, token yenileme mantığı, oturum bağlama ve süresi dolmuş token'lar ile hesap kurtarma için uç durum (edge case) yönetimine ihtiyacınız vardır. horizOn gibi platformlar; e-posta, anonim, Google ve Apple ile oturum açma desteği sunarak son kullanıcı kimlik doğrulamasını ve hesaba bağlı oturumları hazır olarak sağlar; bu da durumu bir geliştirme projesinden ziyade bir yapılandırma adımına indirger.

Kimlik bilgisi tablolarını ifşa eden bir veri ihlali, AI agent'lar mevcut olduğunda özellikle tehlikelidir; çalınan kimlik bilgileri makine hızında silaha dönüştürülür. Kimlik bilgisi uzlaşmalarından sağ çıkmak için game backend'leri mimari olarak nasıl tasarlanır hakkındaki incelememiz, patlama yarıçapını sınırlayan depolama ve rotasyon kalıplarını ele almaktadır.

Tespit Katmanı 3: İtibar ve Hesap Verebilirlik (Reputation & Accountability)

Kimlik size kim olduğunu söyler. İtibar, onlara güvenip güvenmeyeceğinizi söyler. Hesap verebilirlik ise bir şeyler ters gittiğinde kimin ödeyeceğini söyler.

Hesaba Dayalı İtibar Puanı Oluşturma

Bir itibar sistemi, kimlik doğrulaması yapılmış her kimliğe, meşru davranışla artan ve şüpheli aktiviteyle azalan bir güven puanı atar. Yüksek itibar puanına sahip hesaplar daha fazla özerklik alırken, düşük itibar puanına sahip hesaplar artan sürtünmeyle karşılaşır.

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]

Hesap Verebilirlik: İşler Ters Gittiğinde Kim Hesap Verir?

Hesap verebilirlik, bir agent zarar verdiğinde — bir pazar ekonomisini çökerttiğinde, bir bug'ı istismar ettiğinde, maçları sabote ettiğinde — sorumlu ve izlenebilir gerçek bir insan olduğu anlamına gelir.

Game backend'leri için bu şu anlama gelir:

  • Hesap askıya alma işlemi kalıcıdır: Oturumlar doğrulanmış kimliklere bağlı olduğundan, atılabilir bir game hesabını değil, insan operatörü banlarsınız. Banlanmanın maliyeti daha yüksektir, bu da agent dağıtımını caydırır.
  • Ekonomik geri alma (rollback) kapsamlıdır: Hangi doğrulanmış kimliğin hileli kaynaklar ürettiğini tam olarak bilirsiniz. Geri alma, sunucu genelinde olmaktan ziyade cerrahi müdahale gibidir.
  • İtirazlar işlenebilirdir: Bir insan yanlış pozitif (false positive) karara itiraz edebilir. Doğrulama zinciri gerçek olduklarını kanıtlar. Bu zincir olmadan, banlanan her hesap bir gürültü üretecidir.

Hepsini Bir Araya Getirmek: Tam Tespit Pipeline'ı

Üç katman, gelen her bağlantıda çalışan bir istek pipeline'ı oluşturur:

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
└─────────────────────┘

Ek Yük ve Maliyet

Bu pipeline'ı çalıştırmak ücretsiz değildir. Yaklaşık 10.000 eşzamanlı oturumu yöneten bir deployment'tan gerçekçi rakamlar:

  • Davranışsal analiz: Aksiyon grubu başına ~2ms (her 50 aksiyonda bir). Oyun döngüsüne eklenen gecikme ihmal edilebilir düzeydedir.
  • İtibar sorgulamaları: Cache'lendiğinde ~0.5ms, cache miss durumunda ~3ms (bir oturumun ilk aksiyonu). Redis veya eşdeğer bir in-memory store ile uygulayın.
  • Auth token doğrulaması: Yerel doğrulamalı JWT için ~1ms; uzak auth endpoint istekleri için ~5-15ms. Önceden doğrulayın ve agresif bir şekilde cache'leyin.

Oturum başına eklenen toplam gecikme: Normal yük altında aksiyon grubu başına 3-5ms. Davranışsal analiz en çok CPU tüketen bileşendir; 10.000 eşzamanlı oturumda kabaca ek bir vCPU tüketir. Bir haftada 12 paralel oturum çalıştıran kontrolsüz tek bir agent'ın, binlerce dolarlık premium para birimi değerine eşdeğer oyuncu tarafı ekonomi değerini tüketebileceği düşünüldüğünde, bu verilmeye değer bir takastır.

En İyi Uygulamalar

  1. İlk sinyalde banlamayın: Anomalous bir puan üreten tek bir oturum kanıt değildir. Yetenekli oyuncular da AI agent'lar da uç davranışsal sinyaller üretir. Hesap düzeyinde cezalar uygulamadan önce en az 5 oturumluk kayan bir pencere (rolling window) kullanın. Oturumlar arası tekrarlayan yüksek puanlar güvenilir göstergedir.

  2. Ağırlıkları kendi oyuncu popülasyonunuza göre ayarlayın: Yukarıdaki kodda yer alan puanlama ağırlıkları birer başlangıç noktasıdır. Her oyunun farklı davranış normları vardır — bir ritim oyununun zamanlama beklentileri açık dünya RPG'ye göre daha katıdır. Yaptırımları etkinleştirmeden önce, doğrulanmış insan oyunculardan en az 2 hafta boyunca taban veri toplayın.

  3. İkili (binary) banlamayın, yaptırımlarınızı kademelendirin: İzin ver/engelle yerine kademeli sürtünme kullanın. Düşük itibarlı hesapları gölge eşleşmeli (shadow-matched) oturumlara yönlendirin (yalnızca diğer düşük itibarlı hesaplarla eşleştirin), daha katı rate limit'ler uygulayın veya ikincil doğrulama zorluklarını tetikleyin. Bu, yanlış pozitif tetikleyen meşru oyuncuları korurken agent zararını sınırlar.

  4. Her şeyi loglayın, kalibrasyon için örnekleyin: Her davranışsal sinyali, her itibar ayarını ve her yaptırım aksiyonunu loglayın. Yanlış pozitif oranınızı kalibre etmek için işaretlenen oturumların %5-10'unu manuel olarak inceleyin. %0.5'in altında bir yanlış pozitif oranını hedefleyin — meşru oyuncuların %2'sini bile işaretlemek, agent sorununun kendisinden daha fazla destek talebi üretir.

  5. Sunucu tarafı auth'u istemci tarafı parmak iziyle birleştirin: Sunucu tarafı auth kimliği doğrular. İstemci tarafı parmak izi (cihaz imzaları, işletim sistemi düzeyinde sinyaller, donanım kimlikleri), agent operatörünün kimlik bilgilerini farklı bot makineleri arasında yeniden kullanmasını zorlaştıran ikinci bir korelasyon noktası ekler. Doğrulanmış tek bir hesap 24 saat içinde 8 farklı donanım parmak izinden bağlanıyorsa, bu harekete geçmeye değer bir sinyaldir.

Ne Zaman Geliştirmeli, Ne Zaman Satın Almalı?

Oyununuz ön lansmanda veya 1.000'den az günlük aktif oyuncuya (DAU) sahip erken erişim aşamasındaysa, muhtemelen daha büyük öncelikleriniz vardır. Temel rate limiting ve imza tabanlı bot tespiti şimdilik idare edecektir.

Agent'ların ekonomik olarak uygulanabilir hedefler haline geldiği ölçeğe ulaştığınızda — tipik olarak oyuncu odaklı ekonomilere veya rekabetçi sıralı modlara sahip oyunlar için 5.000+ DAU civarında — yukarıda açıklanan katmanlı yaklaşıma ihtiyacınız vardır. Davranışsal puanlama sistemi size ait özel bir koddur, çünkü oyununuzun spesifik aksiyon kelime dağarcığına ve zamanlama normlarına bağlıdır.

Kimlik ve kimlik doğrulama katmanının özel olmasına gerek yoktur. horizOn; e-posta, anonim, Google ve Apple ile oturum açma desteğiyle hesaba bağlı oturumlar sunan son kullanıcı kimlik doğrulaması sağlar ve hesap verebilirliğin gerektirdiği doğrulanmış insan kimliği bağını kurar. Siz OAuth ve token yönetimini sıfırdan yeniden kurmak yerine, mühendislik sürenizi oyununuzu farklılaştıran davranışsal puanlamaya odaklarsınız.

Sonraki Adımlar

Davranışsal puanlama sistemiyle gölge modda (shadow mode) başlayın — puanları loglayın ancak hiçbir yaptırım aksiyonu almayın. Spesifik popülasyonunuz için taban çizgiler oluşturmak üzere canlı oyuncu tabanınıza karşı iki hafta çalıştırın. Ardından güven katmanlarını ve yaptırım aksiyonlarını tanımlayın, eşiklerinizi ayarlayın ve önce yeni oturumlar için yaptırımları etkinleştirin.

Her oturumun doğrulanmış bir kimliğe kadar izlenebilmesini sağlamak için tespit pipeline'ını auth katmanınıza bağlayın. Davranışsal puanlama ve kimlik doğrulamanın kombinasyonu, Cloudflare'in yeni yapay zeka aracıları dalgasını yönetmek için temel olarak tanımladığı üç mekanizmayı size sağlar: kimin hareket ettiğini bilirsiniz, onlara güvenip güvenmediğinizi ölçersiniz ve bir şeyler ters gittiğinde birini sorumlu tutarsınız.


Kaynak: Agents aren’t humans (but they kinda are)