Guardian TrueSight is a powerful, non-invasive cheat detection overlay that can run entirely server-side. Using advanced statistical analysis and behavioral modeling, it flags suspicious gameplay without touching the game client — no hooks, no risks, no interference.
Built for competitive integrity, Guardian TrueSight delivers unbiased, transparent data trusted by tournament organizers and esports platforms. It’s the gold standard for detecting foul play before payouts, reviews, or rulings — clear, objective, and battle-tested.
We are not standing still; Guardian is constantly evolving with new ideas, enhanced robustness, and continuous adaptability. It learns and quickly adjusts to new types of cheats.
Professional dashboards help admins and reviewers visualize detection data in real time. See examples below:
Guardian TrueSight is a fully automated system that reviews gameplay videos for cheating, suspicious patterns, and stat manipulation. Using advanced AI and statistical modeling, it identifies aimbots, soft aim, spinbot, aim assists, and more—catching even the subtlest signs of foul play.
Every session is automatically analyzed and scored. Guardian provides trust ratings, detailed anomaly reports, and visual overlays for reviewers. No client modifications or risky integrations—everything happens securely on the server side, making it safe and completely tamper-proof.
| •Trust score | Real-time scoring and grading of every player session for instant integrity checks |
|---|---|
| •Anchor lock | Locks detection to valid targets only when AI confidence is high, reducing false flags |
| •Entropy analysis | Measures randomness and pattern consistency in aiming and hits to spot unnatural behavior |
| •Statfreeze protection | Detects stat manipulation attempts by analyzing abnormal hit ratios and entropy shifts |
| •Soft aim detection | Reveals low-variance, micro-adjusted aim that signals subtle or hidden aim-assist scripts |
| •Snap aim detection | Flags rapid, inhuman crosshair snaps and flicks typical of aimbots and macros |
| •Aim velocity tracking | Continuously monitors aim speed and acceleration to profile human vs. scripted motion |
| •Spinbot detection | Identifies high-frequency rotational patterns used in anti-aim or spinbot cheats |
| •Aimbot detection | Spots sustained inhuman accuracy, extreme headshot rates, and mechanical precision |
| •Aim assist abuse detection | Flags scripted or automated exploitation of in-game aim assist—beyond normal controller use |
| •ShadowSight analysis | Monitors for shadow aim, recoil scripts, and advanced cheat overlays invisible to viewers |
| •Buffered region sampling | Uses rolling hit and aim data windows to reduce noise and improve detection confidence |
| •Event logging | Full audit trail: every anomaly, violation, and detection event is time-stamped and exportable |
| •Visual overlays | Live overlays for entropy, hit zones, and detection flags—perfect for review and VOD |
| •Guardian Law | Applies transparent, published rules for every detection—ensuring unbiased, reviewable decisions |
| •PDF & CSV reports | Automated, exportable reports with session charts, trust grades, and violation breakdowns |
| •Payout eligibility | Flags or clears players for tournament rewards and payouts based on trust rating |
| •False positive suppression | Excludes known false-positive zones and time ranges for maximum detection accuracy |
| •Customizable settings | Flexible configuration for overlays, thresholds, and detection modes—fits any event |
| •️Guardian Review Mode | Secure playback with overlays for admins and reviewers to investigate flagged moments |
Every Guardian review session generates a professional, tamper-proof PDF whitepaper with real-time charts and data breakdowns. Reports summarize detection breakdowns, trust scores, aim distribution, entropy trends, and a clear payout recommendation for admins and players. Instantly shareable, visually clear, and always audit-ready.
When the stakes are highest, choose the system trusted by the future of competitive gaming.
Guardian TrueSight—see everything, miss nothing.
Guardian TrueSight is a sophisticated, AI-driven anti-cheat detection tool designed for analyzing gameplay video footage to identify potential cheating behaviors in first-person shooter (FPS) games. Leveraging advanced computer vision techniques, the system processes video frames with high accuracy to detect enemy entities, segment their bounding boxes into anatomical regions (head, upper torso, lower torso, legs), and track the player's aim point (crosshair) relative to these regions.
By modeling aim distribution as a probabilistic process, it computes weighted Shannon entropy to quantify the randomness and naturalness of hit patterns—low entropy signals repetitive, automated aiming (e.g., aimbots), while high entropy reflects human variability. Additional modules detect snap-aim (abrupt, high-speed target acquisitions) and soft-aim (unnaturally smooth deceleration near targets) through kinematic analysis of aim trajectories.
The system aggregates these metrics into a trust score (0-100) and categorical grade (e.g., "Excellent" to "Critical"), flagging violations such as anomalies, abnormalities, and explicit cheats. Outputs include an annotated video overlay with real-time diagnostics, CSV logs of entropy and hit data, and a comprehensive PDF report with visualizations.
The system initializes with a pre-trained computer vision model for entity detection and processes each video frame as follows:
# Pseudo Code for Frame Processing Pipeline:
function process_frame(frame, model, config):
# Step 1: Detect enemies using computer vision
detections = model.predict(frame)
filtered_detections = filter(detections, confidence >= config.CLASS_CONFIDENCE[class_id])
# Step 2: Segment bounding boxes into body regions
for detection in filtered_detections:
box = [x1, y1, x2, y2]
regions = segment_box(box, [proportional_divisions])
# Step 3: Determine if aim point hits a region
aim_x, aim_y = extract_aim_point(frame)
hit_region = check_hit(aim_x, aim_y, regions)
if hit_region:
append_to_buffers(hit_region)
# Step 4: Update entropy and detect cheats
entropy = compute_entropy(buffers, config.WEIGHTS)
zone = classify_zone(entropy, config.THRESHOLDS)
detect_snap_aim(aim_trajectory)
detect_soft_aim(aim_deltas)
# Step 5: Update trust score
trust_score = 100 - penalties + bonuses - detection_penalty
# Step 6: Overlay diagnostics and log
overlay_frame(frame, entropy, zone, trust_score, hits)
log_event(zone_changes, detections)
return annotated_frame
Entropy serves as the primary metric for assessing aim naturalness. It measures the uncertainty in hit distributions across body regions, weighted to penalize extremes. Hits are accumulated in multi-scale buffers to capture varying patterns, triggering entropy recalibration.
# Pseudo Code for Weighted Entropy Computation:
function compute_entropy(buffer, weights):
if buffer.empty:
return 0.0
counts = counter(buffer)
total = sum(counts.values)
entropy = 0.0
for region, count in counts:
p = count / total
w = weights[region]
if p > 0:
entropy -= p * log2(p) * w
return normalize(entropy, config.MAX)
Identifies sudden aim shifts by analyzing trajectory kinematics over time. Uses speed, angle, and inward motion thresholds to detect non-human aim behavior.
# Pseudo Code for Snap-Aim Detection:
function detect_snap_aim(trajectory, config):
if trajectory.short:
return False
for window in trajectory.windows:
speed = compute_speed(window)
angle = compute_angle(window)
inward = compute_inward_delta(window)
if speed_high and angle_acute and inward_significant:
flag_violation("SNAP")
return True
return False
Detects aim-assist cheats via low-variance movement profiles. Uses variance checks and pattern similarity to catch smooth, unnatural aim deceleration near targets.
# Pseudo Code for Soft-Aim Detection:
function detect_soft_aim(deltas, config):
speeds = compute_speeds(deltas)
variance = compute_variance(speeds)
if variance_low and mean_speed_low:
similarity = check_pattern_similarity(deltas)
if similarity_high:
flag_violation("SOFT-AIM")
return True
return False
Below is a technical overview of the key mechanisms, buffers, and anti-cheat systems powering Guardian TrueSight's detection logic. Each module is engineered for precise, consistent, and reviewable results.
Guardian TrueSight helps tournament organizers confirm the legitimacy of finalist gameplay using forensic-level review tools.
Guardian will soon be providing complete protection for tournament orginzers helping them to make an informed descrion weather or not to issue the payout.
Soon, tournament hosts will be able to upload full match replays or share direct VOD links — Guardian will analyze aim decay, frame pacing, and unnatural smoothness at a forensic level.
Results are delivered to your dashboard or inbox, including a downloadable match archive and a full technical whitepaper for official rulings.
Built for fairness. Engineered for trust. Coming soon to Guardian TrueSight.
We welcome partnerships, advertising opportunities, and collaborations to protect your game from cheats using server-side technology. All submissions are completely anonymous, and no information is shared with third parties.
📩 contact@guardiantruesight.com
We typically reply within 24 hours.