The Template's anti-cheat checks what the server can verify, keeps a decaying suspicion score per player, and alerts staff or removes the player when its configured thresholds are reached. It supports the server's own checks; a gameplay handler must still verify every request before granting anything.
src/core/server/Services/AntiCheatService/ owns enforcement. Its optional switch is Config/Features.antiCheat, on by default. Thresholds, weights, tolerances, messages and the watchlist size live in the server-only src/core/server/Config/AntiCheat.luau (a game's own in src/core/server/Config/Overrides/AntiCheat.luau), merged once by AntiCheatService/Config, so no client can read how a detection is judged. The shared src/core/shared/Config/AntiCheat.luau holds only what the client sensor needs (client) and historyServer. Pure calculations live in src/core/shared/Rules/AntiCheat.luau.
Every detection the anti-cheat makes
The check modules under AntiCheatService/Checks/ feed these detection kinds into the same scoring service.
- speed, teleport, fly, noclip, fling
Movementsamples character roots every 0.2 seconds. A horizontal distance budget follows the server's walk speed, tolerances and bounded ping allowance. It also checks excessive upward travel or hovering, a collidable wall crossed between samples, and root spin above 150 radians per second. A wall counts only when it is anchored, thicker than a corner cut, has no clear way round its side or over it by a jump, and is still there, unmoved, on the next sample, so a door that shut behind the player is not noclip; a wall thicker than one step is judged from where the character went in to where it came out. Movement detections return the character to its last legal position and hold it there until its client can have caught up.- character_tamper
Characterchecks a living character's Humanoid, root and head being removed or replaced. It waits half a second so an ordinary death resolves first; engine removal belowFallenPartsDestroyHeightis excluded. It watches what leaves the character, so the head an outfit put on is watched like the first, and a part that is there again by then was put there by the game (a client's deletion reaches the server; nothing a client creates does):Humanoid:ApplyDescriptionswapping the head or a morph replacing the Humanoid is not tampering. A detected character is respawned. With the serverConfig/AntiCheat.enabledfalse the check does nothing: no detection and no respawn.- invalid_arguments, wrong_direction, honeypot, remote_flood
NetworkconsumesRemoteGuardreports: malformed or extra arguments, a client firing a server-to-client remote, a trap remote, or too much traffic across all remotes. The traffic bucket refills at 45 calls a second (network.callsPerSecond) and holds a burst of 90 plusnetwork.lagSeconds(60) of calls at that rate: a reconnect or a lag spike delivers everything queued meanwhile in one frame, which is never a flood, while a client that bursts and pauses is held to the same average. Each misuse kind counts at most once per player a second, and a flood once every 5 seconds.- economy_spike
EconomyobservesCurrencyService.changedand judges each gain by its reason's prefix, the text before the first:(economy.reasons). A"counted"reason (earned by playing; an unlisted reason too) counts towards the currency'seconomy.maxGainPerWindowin a 60-second window. A reason ineconomy.maxGainPerReasoncounts towards that ceiling alone. An"uncounted"reason is never judged: purchases (iap), staff changes (admin), refunds (refund) and every claim the save or the account records and pays once (quests, the season pass, daily, playtime, Premium, subscription and group rewards, codes, referrals, offline production, rewarded ads, shop exchanges). A flag names the largest contributing reason. Both limit maps are empty by default, so a game's economy needs its own ceilings.- client_tamper, heartbeat_missing
Clientcompares the sensor with the server's character values, verifies reported body movers, checks report sequence numbers, and detects silence. A value the server changed within the replication grace is not compared (the client sent what it had), and a mover the server took off since the last report still counts as the server's. A client report alone does not establish that its claimed fact is true; the server checks it.- unauthorized_admin
Calling an admin remote from below the suite role is a detection. A tester requesting a staff-only read is refused quietly. Command permissions are described in The admin suite.
- robotic_input
An owning handler calls
observeAction(player, action). The pure rule flags input that keeps a beat no hand can: a run of 500 actions (robotic.samples) with every gap between 0.01 and 0.25 seconds, none of which arrived further than 0.02 seconds from a perfectly even beat (robotic.maximumDriftSeconds). Gaps are not compared with each other: the server reads remote calls once a frame, which makes a steady hand's gaps as identical as a macro's, while a hand's drift from the beat grows with every action. A longer gap starts the run again, a shorter one (queued input arriving in one frame) is not counted, and a run that crossed a server frame longer than 0.04 seconds is dropped unjudged. Judgment pauses for 120 seconds (robotic.cooldownSeconds) after a finding, by when that finding's points have decayed away: a macro alerts staff every two minutes while it runs and is never kicked for by itself. A game that treats auto-clicking as cheating raises the weight or shortens the cooldown in its overrides. Merely installing the Template does not instrument every gameplay action.- custom
A gameplay service calls
flagwhen it can verify an impossible request, such as selling an item the player does not own. Keep the detail specific and based on server facts.
How the suspicion score becomes a response
Each detection adds its configured weight to the player's current score. The default score decays by 8 points a minute, alerts at 15 and kicks at 60. banAt = 0 disables score-based automatic bans; if enabled, the configured ban duration is three days. Staff alerts repeat at most once every 30 seconds per player.
| Detection | Default weight | Detection | Default weight |
|---|---|---|---|
speed | 6 | teleport | 15 |
fly | 10 | noclip | 10 |
fling | 30 | character_tamper | 20 |
invalid_arguments | 8 | remote_flood | 10 |
wrong_direction | 60 | honeypot | 100 |
unauthorized_admin | 60 | client_tamper | 12 |
heartbeat_missing | 5 | economy_spike | 10 |
robotic_input | 15 | custom | 10 |
Honeypots also force network.honeypotAction, kick by default. The traps are admin.execute, economy.giveCurrency, economy.setCurrency and character.setWalkSpeed; honest game code never calls them. An ordinary movement detection cannot kick a previously clean player by itself.
Staff at Config/Permissions.staffRole and above are watched and logged but never kicked or banned by this service: staff see the would-be response as an alert. Testers are enforced like ordinary players. Studio enforcement is off unless enforceInStudio is set. Kick and ban messages never name the detection. A ban's private reason counts every detection of the player, the one that caused the ban included. A successful Roblox ban is recorded in the admin ban list; a refused ban falls back to a kick and is not listed as an accepted ban.
How movement avoids punishing ordinary play
The horizontal budget absorbs short lag bursts and motion from anchored conveyors or server-owned platforms. It excludes motion from loose parts controlled by clients. Ground probes cover the character's footprint, recognize believable climbs and read terrain water around the root on the server; a client's Swimming state is not evidence of water.
A character thrown near another player or a fast part it does not control is set back without a flag. A stationary grounded character is probed every sixth sample rather than every sample. Every character has five seconds of spawn grace from its first sample, at every spawn.
The server's own writes are followed as they happen, not polled. A character a server script moved (PivotTo, setting CFrame) is not judged until its client can have caught up: twice the ping plus half a second (replicationSlackSeconds), at least one second (teleportGraceSeconds) and at most three (maxGraceSeconds), the same grace AntiCheatService.teleport gives. The speed of a velocity the server set (a knockback, a launch pad), of a mover it took off or of a moving seat the player left is allowed, with the rise it can give, for launchSeconds (3) or until the character lands and slows, up to maxLaunchSpeed (250). A walk speed, jump or gravity the server lowered still counts until the client can have heard. A character a server-made mover is pushing is not judged, nor is one whose updates have stopped arriving (a frozen or disconnected client) for up to stallSeconds (5); what arrives next is judged over the whole gap.
Game code that moves characters faster or higher than a plain Roblox character (a sprint, a dash) does it on the server, where the check sees it: the humanoid's WalkSpeed or jump, a velocity set on the root, a mover put on the character. What only a client does to its own character (a LocalScript's sprint, a client-side glider or launch pad, an Explosion's blast) the server cannot tell from a cheat: call AntiCheatService.exempt for its length, and name the client's own body movers in the shared Config/AntiCheat client.allowedMoverNames (empty in the Template) so the sensor does not report them. A spinner moved by setting its CFrame has no velocity the check can see: exempt the players it throws.
AntiCheatService.teleport(player, spawnCFrame, "respawn")AntiCheatService.exempt(player, 2)AntiCheatService.excuse(player, "glider", true)-- When the glider mode ends:AntiCheatService.excuse(player, "glider", false)if not AntiCheatService.isNear(player, chest.Position, 12) then returnendAntiCheatService.observeAction(player, "open_chest")teleport first streams a destination farther than Config/Streaming.streamAroundBeyondStuds to the player, so a far move yields up to Config/Streaming.streamAroundTimeoutSeconds (see Streaming); if the character changes during that wait, the move is dropped. It fires AntiCheatService.teleported(player, reason) even when anti-cheat is off. Setbacks fire the same signal with reason setback, so game code that times a run can void it when something else moved the player. With movement.setback off (flag only), nobody is moved back: the move stands and is tracked from where the player landed, so one move is one detection.
The movement check does not count the motion of ground no client can drive: an anchored conveyor or a platform the server simulates. A character that is seated, anchored, welded to something anchored or simulated by the server is not judged at all, and an empty server does no movement work. A game's moving platform should be anchored or server-owned physics (SetNetworkOwner(nil)), or its riders are rubber-banded. A launch pad that sets the velocity on the server needs nothing more; one that launches from the client calls exempt for the flight, only once the server sees the character standing on the pad, and a launch the server did not see is judged like any other movement. Do not leave a server-made mover on a character for good: while it is there, that character's movement is the game's and is not judged.
What the client sensor reports
AntiCheatController sends antiCheat.report every 10 seconds. It sends a sequence number, up to eight findings of at most 160 bytes, and the configured probes in order: WalkSpeed, JumpPower, JumpHeight and Gravity. The server compares probe discrepancies twice before flagging them, checks whether a reported body mover was server-created, and detects backwards sequence numbers. A skipped sequence is allowed.
Three missed heartbeat intervals in which the character moved can flag silence, after 90 seconds of join grace; the silence of a client that is not running (frozen, in the background, still loading: its character does not move either) is not a finding. The sensor indexes mover additions and removals after scanning a character once; replacing the character clears that index and its connections. Staff flight omits its own AdminFlight movers while the server lists that player as flying. Staff output uses fixed labels and verified classes rather than client-supplied free text.
How the shared watchlist works
An anti-cheat alert adds a player once per visit; kicks and bans always record them. Staff can also watch or unwatch a user. The list is the shared antiCheatWatchlist value through DataService.updateShared, capped at 200 entries. When full, automatically added entries leave before staff-added ones, then lower peak scores, then older entries. Repeat findings merge with the existing row; they do not take ownership away from a staff-added entry.
Each server caches its read for five minutes. A staff edit publishes on BlockoutWatchlist, causing refreshes at most once a minute per server. Automatic entries are seen by other servers when their cached read expires. Current staff are not added; testers and suspended staff can be. A watched user joining a server alerts staff across servers (one already in the server when its services start is announced the same way), and follow <id> can take staff there.
What staff can inspect and change
The admin Anti-cheat tab and feed show detections, scores and responses; the Watchlist tab shows retained users. The service keeps up to 50 detections per player and 200 in the server feed. suspicion, acclear, acexempt, acflag, watch, unwatch and follow expose the corresponding staff tools; use help <command> for arguments and the caller's permitted commands.
Switching antiCheat off stops detections, kicks, bans and the reports of invalid remote calls and honeypot hits. RemoteGuard still validates arguments. Teleports still work and watchlist commands remain available. The admin Dashboard's remote traffic and net keep counting, because MetricsService counts calls itself.
What will not be flagged
The checks are held by a false-flag corpus: specs that play honest scenarios through the real checks and require zero detections, beside cheats that must still be caught within a stated time (Checks/Network.corpus, Checks/Economy.corpus, AntiCheatService.robotic, AntiCheatService.honest and AntiCheatService.cheats under tests/core/server/Services/).
| Check | Honest play that raises nothing |
|---|---|
| Remote flood | Any button clicked or held as fast as a hand can; a mobile double-tap; a reconnect or lag spike that delivers up to lagSeconds (60) of queued calls in one frame, again and again; every system firing on join; a full server joining in one frame. A client under network.callsPerSecond on average is never flagged. |
| Invalid arguments | Everything the Template's own client sends, the admin console, panel and command forms included. |
| Robotic input | Clicking at 8 to 18 a second, a trained steady rhythm, mobile tapping, a held button (the Template's client acts once per press), hold to interact, on a server at any frame rate. Queued input arriving together is not counted, and a slow frame voids the run. |
| Economy spike | Every claim the Template pays, at any size and any number in one window (a whole season pass and every quest at once), staff grants, purchases, refunds and test sessions, on top of flat-out play at the cap. |
| Movement | Rooms, doorways, stairs, ramps, ladders and water at 50 to 1000 ms of ping and 10 to 60 frames a second; packet loss and client hitches of up to 3 seconds; long falls, slides, jump spam; seats, vehicles, lifts, conveyors and platforms the server moves; a knockback or launch pad that sets velocity on the server; a sprint, dash or jump boost set on the server; PivotTo by game code, AntiCheatService.teleport, staff flight; death and respawn. |
| Character | Death, a reset, LoadCharacter while alive, the void, an outfit applied by the server, a morph that replaces the Humanoid. |
| Client sensor | Reports at every ping; a client frozen or in the background for up to two minutes; a sensor that starts minutes after joining; a walk speed, jump power and gravity the server keeps changing; movers the server adds for a moment or leaves on. |
What a game must still do:
Set
economy.maxGainPerWindowfor honest play at its best: the largest boost, event and Premium multipliers together. Give a large honest source its own line ineconomy.reasonsormaxGainPerReasoninstead of raising the cap.Observe presses, never repeats.
observeActionsees only timing: an action the game's own client repeats while a button is held is a machine's beat, and is flagged as one.Keep the client inside the validators. A value the client can send and
Remotes.luaurejects (text longer than its check allows) is reported as a modified client: cap it before sending.Move characters on the server, or say so. Anything only the client does to its own character needs
exempt; a platform players ride is anchored or server-owned.Do not leave a mover on a character for good. While a server-made mover is on a character, its movement is not judged.
The tolerance has a price in time. A remote flood is reported once the bucket is empty (3 seconds at 1000 calls a second, 18 at 200, 51 at 100), and a client may send the bucket's 2790 calls at once unreported; each handler's own throttle still applies. A macro is reported at the end of its first full run (25 seconds at 20 actions a second, 50 at 10), only while the server holds 25 frames a second, and each robotic_input detection alerts staff (its weight is score.alertAt) without ever reaching a kick alone. A speed cheat at three times the walk speed is caught in about 1.4 seconds, a teleport or a fling spin in 0.2, noclip through a wall in under 2, and a client-made body mover or an edited WalkSpeed or Gravity by the sensor's next one or two reports.
Covering a new feature
A feature is covered by doing whichever of these five apply to it. Each is one or two lines, and lune run check fails on the first three when one is missing: tests/core/server/Services/AntiCheatService.coverage.spec.luau requires every currency reason in Config/Analytics.economy to be classified, every server file that moves characters to call teleport, exempt or excuse (or be listed there with its reason), and every client file that creates a body mover to name it in client.allowedMoverNames.
1. It pays currency: classify the reason, by its prefix, in src/core/server/Config/Overrides/AntiCheat.luau. "uncounted" is for what is not a rate of play: paid for, given by staff, a refund, or a claim recorded in the same write that pays it. When in doubt, "counted". A reason with its own ceiling allows for its largest boost and event multiplier.
return { economy = { reasons = { chest = "counted", -- earned by playing: counts towards maxGainPerWindow mailbox = "uncounted", -- a claim the save records and pays once: never judged }, maxGainPerReason = { fishing = 2000, -- or its own expected maximum per window, judged alone }, },}2. It moves a player, or changes how they move: say so first. Use teleport for a destination, exempt for anything with a known end, and excuse for a mode that lasts until switched off. The server decides the trigger: call them only after it has checked the cause (isNear the pad, a Cooldown on the dash), for the shortest time that covers the move, and end an excuse on a server event, never on a client's say-so. An exemption a client can ask for at will is an off switch for the movement checks. A sprint or a jump boost that sets WalkSpeed, JumpPower or JumpHeight on the server needs nothing else.
AntiCheatService.teleport(player, cframe, "checkpoint") -- a move to a place; fires `teleported`AntiCheatService.exempt(player, 2) -- before a launch pad, knockback, cutscene or ragdollAntiCheatService.excuse(player, "mount", true) -- a lasting mode; `false` when it ends3. Its client code pushes the character: name the mover. A dash that creates a LinearVelocity on the client names it, and the game lists the name in the shared src/core/shared/Config/Overrides/AntiCheat.luau: client = { allowedMoverNames = { "Dash" } }.
4. A request cannot happen in honest play: flag it, in the handler, after the meaning checks. Flag only what the unmodified client can never send: a refusal an honest player can reach (not enough coins, a cooldown, a full inventory) is a Result, not a flag.
if not AntiCheatService.isNear(player, chest.Position, 12) then -- Flagged only where lag cannot reach. if not AntiCheatService.isNear(player, chest.Position, 48) then AntiCheatService.flag(player, "custom", "opened a chest from across the map") end returnend5. An auto-clicker would matter: observe the press, with AntiCheatService.observeAction(player, "swing") once per press the player makes, never for a repeat the game's own client generates while a button is held.
The feature's remotes are covered by building them: intent, query, fact and trap in Remotes.luau pass every call through RemoteGuard. The whole API is teleport, exempt, excuse, isExempt, isNear, flag and observeAction, with the detected and teleported signals.
What the anti-cheat costs
Per call, whatever the player count: a remote call is one token-bucket take and the argument checks; a currency change looks its reason's judgement up (worked out once per reason) and, only when a limit applies, appends to a window with running sums; an observed action appends one time, and a run is judged once per robotic.samples actions. AntiCheatService.load.spec measures all three with 1, 20 and 100 players.
The movement check is measured per player a minute (AntiCheatService.movementCost.spec, 1 to 100 players): a walker costs two rays a sample, the ground under it and the path it took, 600 a minute; a player standing still one ground ray every sixth sample, 50 a minute. A climb's overlap query and water's voxel read are asked only when no ground was found, and the rays that look for a way round a wall only when a path crosses one. The filter every query shares, a list of every character, is rebuilt only on the frame after a character spawns or goes, so not at all in a quiet minute. Players are sampled in turn, a few per frame, so a full server never judges everyone in one frame, and an empty server does no movement work. The client sensor works once every heartbeat interval: it walks an index of the movers on the character (none, for an honest player) and reads four values.
What the checks cannot see
The anti-cheat cannot see what never reaches the server: a handler that trusts a client value is exploitable whatever this service does. The movement check alone does not catch speed up to about 1.7 times the walk speed made by moving the root (a server cannot tell it from lag) or a slow fall; the usual ways to make either (a WalkSpeed or Gravity edit, a client mover) are caught by the sensor. Noclip through a wall within a few studs of its end, or one a jump clears, is not flagged.
Honest play that can still be flagged or rubber-banded:
A player who stood still, then walked more than about 27 studs during one total blackout of their connection: one
speed, which does not alert by itself.A lift faster than about 12 studs a second, boarded or left by a player with 600 ms of ping or more: use a seat or
exempt.Standing two characters high on other players: set back, not flagged.
A client frozen in the air for longer than
stallSeconds(5): onefly.Collision made only on the client (a door or floor a LocalScript makes solid) is not ground or a wall to the server: set it on the server, or
exemptthe players it carries.
The corpus runs the real checks over a simulated world, so a few assumptions about Roblox are worth one look in a live server: a property signal fires on the server for a script's write and not for what a client's physics replicates; a frozen client's character stays where its last update left it; positions a client sent before it learned of a server move still arrive; and a part a client deletes from its character is gone on the server, while nothing it creates arrives.
Extending and checking the anti-cheat
Start with the owning gameplay handler
Check the meaning of its request before applying it, then do whichever steps of Covering a new feature apply:
flagfor a server-verifiable impossibility,observeActionfor a relevant press, and the movement helpers before legitimate launches or teleports.Add an independent check only when needed
Put a module returning
start(engine)inAntiCheatService/Checks/. The service loads it. Add its detection kind to the sharedConfig/AntiCheattype and its weight to the serverConfig/AntiCheat, test pure calculations inRules/AntiCheat, and give it honest scenarios in a corpus spec: what must never be flagged is decided before what is.Tune from observed play
Run the Template's verification pass and inspect false positives in real playtests before reducing tolerances or enabling score-based bans. Follow the Template's balance workflow for existing thresholds.
The detailed source note is docs/systems/Anti-Cheat.md in the Template vault. The systems catalogue maps related services.
Updated