Powrót do Bloga

Wykrywanie agentów AI na serwerach gier: dlaczego tradycyjne anti-cheat zawodzi i jak zbudować odpowiedzialność

Opublikowano 10 listopada 2026
Wykrywanie agentów AI na serwerach gier: dlaczego tradycyjne anti-cheat zawodzi i jak zbudować odpowiedzialność Wygenerowano przy użyciu AI

W skrócie

Wykrywaj agentów AI na serwerach gier: warstwy detekcji behawioralnej, weryfikacji tożsamości i reputacji, zanim ekonomia gry upadnie na zawsze.

Agenci AI — nie skrypty, nie boty, nie narzędzia do rozwiązywania CAPTCHA, ale w pełni autonomiczne systemy oparte na LLM — pojawiają się na serwerach gier i w niczym nie przypominają zagrożeń, do wykrywania których zaprojektowano twoje anti-cheat.

W przeciwieństwie do tradycyjnych botów, które spamują inputy z nieludzką prędkością, nowoczesne agenty AI nawigują po menu gry, odpowiadają na czacie, imitują ludzkie tempo i adaptują się, gdy zostaną zakwestionowane. Działają jako pośrednicy między prawdziwym graczem a twoim serwerem, a twój backend nie ma niezawodnego mechanizmu, by odróżnić jednych od drugich.

To jest runbook do wykrywania tych agentów, oceniania ich zachowania i budowania odpowiedzialności w backendzie gry, zanim twoja ekonomia, integralność matchmakingu czy rankingi rywalizacji zostaną naruszone.

Dlaczego agenty AI to nie boty (i dlaczego to ma znaczenie)

Tradycyjne wykrywanie botów opiera się na kilku cechach charakterystycznych:

  • Nieludzkie wzorce inputów: Kliknięcia w stałych interwałach, celność na poziomie piksela, zero wariancji reakcji
  • Anomalie sesji: Gracze zalogowani 23+ godzin dziennie, zero czasu bezczynności
  • Znane sygnatury: Dopasowanie hashujące do popularnych narzędzi automatyzacji

Agenci AI łamią wszystkie te założenia.

Czym agenty AI różnią się od tradycyjnej automatyzacji botów

Sygnał wykrywania Tradycyjny bot Agent AI
Timing inputów Stałe interwały Zmienne, przypominające ludzkie rozkłady
Podejmowanie decyzji Skryptowane, deterministyczne Adaptacyjne, probabilistyczne
Współczynnik błędów Zero błędów lub powtarzające się błędy Popełnia i naturalnie naprawia błędy
CAPTCHA Wymaga narzędzia do rozwiązywania Przechodzi z ~95% skutecznością przez multimodalny LLM
Czas trwania sesji Nieskończony lub stały Imituje ludzkie wzorce gry, w tym przerwy
Operacje równoległe Pojedynczy skrypt, wiele kont Hostowany w chmurze, uruchamia setki równoczesnych sesji

Agent AI nie tylko klika przyciski — rozumuje o stanie gry. Czyta UI, interpretuje cele i podejmuje decyzje, które wyglądają jak wybory wprawnego gracza. Gdy twoje anti-cheat go oznaczy, agent dostosowuje swój wzorzec zachowania w następnej sesji.

Tryb awarii w backendach gier

Gdy agenty AI działają niewykryte, powodują konkretne kaskadowe awarie:

  1. Inflacja ekonomii: Agenty grindują zasoby 24/7, zalewając aukcje i dewaluując walutę. Jeden dobrze skonfigurowany agent może uruchomić 12-15 równoczesnych sesji, z których każda generuje 3-5x dzienną produkcję zasobów typowego ludzkiego gracza.

  2. Korupcja matchmakingu: Konta kontrolowane przez agentów siedzące w kolejkach rankingowych zawyżają obliczenia MMR i tworzą „martwe" mecze, w których jedna strona ma hiperefektywnego nie-ludzkiego gracza.

  3. Zalewanie kolejki ticketów: Systemy wsparcia zostają przytłoczone ticketami pochodzącymi od agentów, które wyglądają na wystarczająco legalne, by przejść wstępną segregację — pochłaniając godziny pracy personelu, które powinny iść do prawdziwych graczy.

  4. Marnowanie mocy obliczeniowej: Twoja infrastruktura serwerowa płaci koszty obliczeniowe za sesje agentów, które generują zero prawdziwego zaangażowania lub przychodów.

Warstwa detekcji 1: Behavioral Fingerprinting

Pierwsza warstwa to behawioralna — analizowanie, jak sesja zachowuje się w czasie, zamiast patrzenia na pojedyncze inputy. To tutaj łapiesz agenty, które już pokonały wykrywanie oparte na sygnaturach.

Kluczowe sygnały behawioralne

Rozkład interwałów akcji: Ludzie nie działają losowo, ale też nie działają w stałych interwałach. Timing akcji człowieka podlega rozkładowi log-normalnemu — większość akcji skupia się wokół podstawowego rytmu z okazjonalnymi odchyleniami. Boty produkują rozkłady jednostajne lub wykładnicze. Agenty AI produkują coś pomiędzy: przybliżają rozkład log-normalny, ale z podejrzanie ciasną wariancją (współczynnik zmienności zazwyczaj między 0.10 a 0.25, w porównaniu do 0.30-0.60 dla prawdziwych ludzi).

Entropia decyzyjna: Zmierz, ile różnych akcji gry używa gracz w stosunku do swoich całkowitych akcji. Człowiek grający w grę survivalową przełącza się między zbieraniem, budowaniem, eksploracją i walką — z organicznymi skupiskami. Bot zwykle powtarza jedną sekwencję. Agent AI używa wielu akcji, ale ze statystycznie nieprawdopodobną konsekwencją w wybieraniu optymalnej.

Wzorce odzyskiwania: Gdy człowiek popełnia błąd — wchodzi w ścianę, spudłuje input — wykazuje charakterystyczne opóźnienie korekty, a potem się dostosowuje. Agenty AI również popełniają błędy (to jest zaprojektowane), ale ich timing korekty podlega ciaśniejszemu rozkładowi, ponieważ „błąd" jest generowany, a nie organiczny.

Wytrzymałość sesji: Ludzie się męczą. Ich akcje na minutę spadają o 15-30% podczas dwugodzinnej sesji. Robią przerwy. Alt-tabulują. Agenty AI utrzymują ±3% konsystencji przez całe sesje, chyba że są jawnie zaprogramowane do udawania zmęczenia.

Implementacja oceniania agentów

Oto praktyczny system oceniania sesji, który działa jako middleware przed twoim serwerem gry:

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

To nie jest srebrna kula. Agent AI, który przechodzi pętlę fine-tuningu na populacji graczy twojej konkretnej gry, w końcu nauczy się imitować ich rozkłady behawioralne. Dlatego potrzebujesz kolejnych dwóch warstw — i dlatego wzmocnienie netcode'u przeciw wzorcom exploitów jest warunkiem wstępnym niezależnie od tego, co wykryje system detekcji.

Warstwa detekcji 2: Weryfikacja tożsamości

Ocena behawioralna mówi ci, jak coś działa. Weryfikacja tożsamości pyta, kto działa — i czy zweryfikowany człowiek jest gwarantowany za sesją.

To tutaj koncepcja „zaufanej delegacji" staje się krytyczna. Agent AI jest pośrednikiem — czymś między prawdziwym użytkownikiem a twoim serwerem. Twój serwer widzi ruch agenta, nie człowieka. Aby przywrócić relację, potrzebujesz mechanizmu, który gwarantuje zweryfikowaną ludzką tożsamość powiązaną z każdą sesją.

Umieszczenie tożsamości za każdym żądaniem

Praktyczna architektura ma trzy komponenty:

1. Brama uwierzytelniania przed sesją: Zanim gracz w ogóle dotrze do twojego serwera gry, uwierzytelnia się przez dostawcę tożsamości. To tworzy token wiążący zweryfikowaną ludzką tożsamość (email, konto OAuth, numer telefonu) z sesją.

2. Propagacja tokenu: Token uwierzytelniający podróżuje z każdym wywołaniem API i RPC serwera gry. Twój serwer waliduje token przy każdym żądaniu — nie tylko przy logowaniu.

3. Wiązanie tokenu z sesją: Token jest kryptograficznie powiązany z konkretną sesją. Jeśli agent spróbuje użyć tokenu ponownie w równoległych sesjach, wiązanie zawodzi i sesja jest odrzucana.

[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

Dlaczego to powstrzymuje agenty AI

Agent AI potrzebuje poświadczeń do działania. Jeśli wymagasz uwierzytelniania zweryfikowanego przez człowieka — nie tylko wygenerowanego adresu email, ale dostawcy OAuth, który sam zweryfikował użytkownika, lub konta powiązanego z numerem telefonu — operator agenta musi zdobyć prawdziwe poświadczenia na skalę.

To nie czyni działania agentów niemożliwym, ale zmienia ekonomię. Pojedynczy agent uruchamiający 50 równoczesnych sesji wymaga teraz 50 zweryfikowanych kont, każde z prawdziwym emailem, każde przechodzące przez twój przepływ uwierzytelniania. Koszt na sesję rośnie do punktu, w którym wiele scenariuszy exploitacji staje się nieopłacalnych.

Dla zespołów indie i średniej wielkości wdrożenie solidnej warstwy uwierzytelniania od zera zwykle zajmuje 2-4 tygodnie — potrzebujesz integracji OAuth, logiki odświeżania tokenów, wiązania sesji i obsługi przypadków brzegowych dla wygasłych tokenów oraz odzyskiwania kont. Platformy takie jak horizOn zapewniają uwierzytelnianie użytkowników końcowych i sesje powiązane z kontem od razu po wyjęciu z pudełka, obsługując logowanie emailem, anonimowo, przez Google i Apple, co redukuje to do kroku konfiguracji, a nie projektu deweloperskiego.

Naruszenie danych, które ujawnia tabele poświadczeń, jest szczególnie niebezpieczne, gdy istnieją agenty AI — skradzione poświadczenia są uzbrajane z prędkością maszynową. Nasza analiza jak architektować backendy, by przetrwały kompromitacje poświadczeń omawia wzorce przechowywania i rotacji, które ograniczają promień rażenia.

Warstwa detekcji 3: Reputacja i odpowiedzialność

Tożsamość mówi ci, kto. Reputacja mówi ci, czy im ufasz. Odpowiedzialność mówi ci, kto płaci, gdy coś pójdzie nie tak.

Budowanie wyniku reputacji na konto

System reputacji przypisuje każdej uwierzytelnionej tożsamości wynik zaufania, który rośnie wraz z legalnym zachowaniem i maleje wraz z podejrzaną aktywnością. Konta o wysokiej reputacji dostają więcej autonomii; konta o niskiej reputacji napotykają rosnące tarcia.

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]

Odpowiedzialność: kto odpowiada, gdy coś pójdzie nie tak

Odpowiedzialność oznacza, że gdy agent powoduje szkody — załamuje ekonomię rynku, wykorzystuje błąd, griefuje mecze — istnieje prawdziwy człowiek, który jest odpowiedzialny i możliwy do wyśledzenia.

Dla backendów gier oznacza to:

  • Zawieszenie konta jest trwałe: Ponieważ sesje są powiązane ze zweryfikowanymi tożsamościami, banujesz ludzkiego operatora, a nie jednorazowe konto gry. Koszt zbanowania jest wyższy, co odstrasza od wdrażania agentów.
  • Cofnięcie ekonomiczne jest zakresowane: Dokładnie wiesz, która zweryfikowana tożsamość wygenerowała oszukańcze zasoby. Cofnięcie jest chirurgiczne, a nie na cały serwer.
  • Odwołania są przetwarzalne: Człowiek może odwołać się od fałszywego pozytywu. Ich łańcuch weryfikacji dowodzi, że są prawdziwi. Bez tego łańcucha każde zbanowane konto jest generatorem szumu.

Składanie całości: pełny pipeline detekcji

Trzy warstwy składają się w pipeline żądań, który działa na każdym przychodzącym połączeniu:

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

Narzut i koszt

Uruchomienie tego pipeline'u nie jest darmowe. Realistyczne liczby z wdrożenia obsługującego ~10 000 równoczesnych sesji:

  • Analiza behawioralna: ~2ms na partię akcji (co 50 akcji). Pomijalne opóźnienie dodane do pętli gry.
  • Zapytania o reputację: ~0.5ms z cache, ~3ms przy braku cache (pierwsza akcja sesji). Zaimplementuj z Redis lub równoważnym magazynem w pamięci.
  • Walidacja tokenu uwierzytelniającego: ~1ms dla JWT z lokalną weryfikacją; ~5-15ms dla trafień w zdalny endpoint uwierzytelniania. Pre-waliduj i cache'uj agresywnie.

Całkowite dodane opóźnienie na sesję: 3-5ms na partię akcji przy normalnym obciążeniu. Analiza behawioralna jest najbardziej CPU-intensywnym komponentem; przy 10 000 równoczesnych sesji zużywa mniej więcej jedno dodatkowe vCPU. To kompromis, który warto ponieść, biorąc pod uwagę, że pojedynczy niekontrolowany agent uruchamiający 12 równoległych sesji przez tydzień może wyssać wartość ekonomii graczy odpowiadającą tysiącom dolarów w walucie premium.

Najlepsze praktyki

  1. Nie banuj przy pierwszym sygnale: Pojedyncza sesja z anomalnym wynikiem nie jest dowodem. Zarówno wprawni gracze, jak i agenty AI produkują odstające sygnały behawioralne. Użyj przesuwnego okna co najmniej 5 sesji przed zastosowaniem kar na poziomie konta. Powtarzające się wysokie wyniki w wielu sesjach są wiarygodnym wskaźnikiem.

  2. Dostrajaj wagi do własnej populacji graczy: Wagi oceniania w kodzie powyżej to punkty startowe. Każda gra ma inne normy behawioralne — gra rytmiczna ma ciaśniejsze oczekiwania timingowe niż open-world RPG. Zbieraj dane bazowe od zweryfikowanych ludzkich graczy przez co najmniej 2 tygodnie przed aktywacją egzekwowania.

  3. Stopniuj egzekwowanie, nie banuj binarnie: Używaj stopniowanego tarcia zamiast allow/block. Konta o niskiej reputacji trafiają do sesji shadow-matchowanych (matchowanych tylko z innymi kontami o niskiej reputacji), napotykają surowsze limity rate'ów lub wyzwalają wtórne wyzwania weryfikacyjne. To chroni legalnych graczy, którzy wyzwolili fałszywe pozytywy, jednocześnie ograniczając szkody agentów.

  4. Loguj wszystko, próbkuj do kalibracji: Loguj każdy sygnał behawioralny, każdą korektę reputacji i każdą akcję egzekwowania. Ręcznie przeglądaj 5-10% oznaczonych sesji, aby skalibrować współczynnik fałszywych pozytywów. Celuj we wskaźnik fałszywych pozytywów poniżej 0.5% — oznaczanie nawet 2% legalnych graczy generuje więcej ticketów wsparcia niż sam problem agentów.

  5. Połącz uwierzytelnianie po stronie serwera z fingerprintingiem po stronie klienta: Uwierzytelnianie po stronie serwera weryfikuje tożsamość. Fingerprinting po stronie klienta (sygnatury urządzeń, sygnały na poziomie OS, ID sprzętu) dodaje drugi punkt korelacji, który utrudnia operatorowi agentów ponowne użycie poświadczeń na różnych maszynach botów. Jeśli pojedyncze zweryfikowane konto łączy się z 8 różnych fingerprintów sprzętowych w ciągu 24 godzin, to sygnał, na który warto zareagować.

Kiedy budować, a kiedy kupować

Jeśli twoja gra jest przed premierą lub we wczesnym dostępie z mniej niż 1 000 dziennie aktywnych użytkowników, prawdopodobnie masz większe priorytety. Podstawowe rate limiting i wykrywanie botów oparte na sygnaturach wystarczą na razie.

Gdy osiągniesz skalę, w której agenty stają się ekonomicznie opłacalnymi celami — zwykle około 5 000+ DAU dla gier z ekonomią napędzaną przez graczy lub konkurencyjnymi trybami rankingowymi — potrzebujesz warstwowego podejścia opisanego powyżej. System oceniania behawioralnego to kod, który posiadasz, ponieważ zależy od specyficznego słownika akcji i norm timingowych twojej gry.

Warstwa tożsamości i uwierzytelniania nie musi być customowa. horizOn zapewnia uwierzytelnianie użytkowników końcowych z sesjami powiązanymi z kontem przez logowanie emailem, anonimowo, Google i Apple, co ustanawia wiązanie zweryfikowanej ludzkiej tożsamości, którego wymaga odpowiedzialność. Skupiasz czas inżynieryjny na ocenianiu behawioralnym, które różnicuje twoją grę, zamiast odbudowywać OAuth i zarządzanie tokenami od zera.

Następne kroki

Zacznij od systemu oceniania behawioralnego w trybie cienia — loguj wyniki, ale nie podejmuj akcji egzekwowania. Uruchom go na dwa tygodnie na swojej żywej bazie graczy, aby ustalić baseline'y dla swojej konkretnej populacji. Następnie zdefiniuj poziomy zaufania i akcje egzekwowania, dostroj progi i aktywuj egzekwowanie najpierw dla nowych sesji.

Podłącz pipeline detekcji do swojej warstwy uwierzytelniania, aby zapewnić, że każda sesja prowadzi do zweryfikowanej tożsamości. Połączenie oceniania behawioralnego i weryfikacji tożsamości daje ci trzy mechanizmy, które Cloudflare identyfikuje jako niezbędne do zarządzania nową falą pośredników AI: wiesz, kto działa, mierzysz, czy mu ufasz, i pociągasz kogoś do odpowiedzialności, gdy coś pójdzie nie tak.


Źródło: Agenci nie są ludźmi (ale trochę są)