VAC in 2026: How Valve Anti-Cheat Still Bans Cheaters Without a Kernel Driver

Every other major competitive shooter in 2026 runs a signed kernel driver on your machine. Riot Vanguard boots with Windows on eligible hardware (with on-demand loading on Windows 11 25H2), EasyAntiCheat and BattlEye load a driver at game launch, Byfron sits under Roblox. Counter-Strike 2 does not. Valve Anti-Cheat is still a usermode module in the same address space as the game, and a large share of the CS2 cheating economy has convinced itself that means VAC is a joke. It is not. The reason is not VAC itself, it is the systems bolted around it.

This piece walks through what Valve actually runs in 2026: usermode VAC, VAC Live's server-side kick, VACnet's ML classifier, and Trust Factor's matchmaking segregation. We also address the elephant in the room: CS:GO's Overwatch juror system was never truly revived for CS2, and enforcement branding has quietly shifted from VAC to VACNET. At KyTech we ship a CS2 product that has to survive this stack. For the wider picture see usermode vs kernel vs hybrid anti-cheat.

What VAC actually is in 2026

VAC is a usermode component. It is loaded into (or run as a sibling to) the game process, and its core job is a signature scan. It walks memory regions, hashes them, and compares against a database Valve maintains centrally. If a match hits, it does not immediately kick. It records the detection, and a ban lands weeks or months later in a batched wave. The delay is deliberate: it obscures which cheat feature triggered the detection, so authors cannot A/B test their way out of it in an afternoon.

That is roughly the architecture VAC has had since 2002. The signature database has grown and the scanner has been rewritten, but the core primitive is still "hash regions of the game process's own address space and match against a list." A usermode scanner cannot see another process's private memory without the Windows API, cannot enumerate kernel drivers, cannot walk PsActiveProcessHead, and cannot register ObRegisterCallbacks to strip handle rights before a cheat opens the game.

Here is what a VAC signature entry looks like conceptually. This is pseudocode illustrating the shape of the check, not a leaked format. For the general treatment see anti-cheat signature scanning:

// Conceptual VAC-style signature entry.
struct VacSignature {
    uint32_t   id;                // Detection id, opaque to the client
    uint8_t    pattern[64];       // Byte pattern to match
    uint8_t    mask[64];          // Wildcard mask (0xFF = must match, 0x00 = any)
    uint32_t   length;            // Meaningful bytes in pattern/mask
    uint32_t   region_flags;      // e.g. MODULE_CODE, HEAP_EXEC, MAPPED_IMAGE
    uint32_t   min_hits;          // Number of matches required to record
};

static bool ScanRegion(const uint8_t* base, size_t size,
                       const VacSignature& sig)
{
    if (size < sig.length) return false;
    const size_t end = size - sig.length;
    for (size_t i = 0; i <= end; ++i) {
        bool match = true;
        for (uint32_t j = 0; j < sig.length; ++j) {
            if ((base[i + j] ^ sig.pattern[j]) & sig.mask[j]) {
                match = false;
                break;
            }
        }
        if (match) return true;
    }
    return false;
}

In practice VAC does more than raw pattern matching. It walks module lists, sanity-checks import tables, hashes read-only sections of client.dll and engine2.dll against known-good digests, and looks for common overlay and injection framework fingerprints. If your overlay, window hook, or DLL loader has appeared in a public cheat, VAC has seen it. Results upload when the client next talks to Valve's back end. See our Source 2 reverse engineering post for how those same modules are exposed.

The limits of a usermode scanner

VAC's blind spots are well understood. A signed kernel driver like EasyAntiCheat's EasyAntiCheat.sys (or its EOS-branded successor EasyAntiCheat_EOS.sys) can intercept NtOpenProcess, verify caller stack frames, and walk system-wide structures VAC never sees. Anything running in another process, in a hypervisor, or on a second machine reading over DMA is invisible to VAC by construction. Our post on how kernel cheats bypass usermode AC covers the specific reasons a ring-3 scanner cannot audit ring-0 activity.

The public Windows kernel documentation makes the asymmetry clear: routines like MmCopyVirtualMemory, PsLookupProcessByProcessId, and the process-notify callback family are simply not addressable from usermode. A ring-3 scanner has to trust the very APIs a competent cheat has already redirected. If VAC were the whole system, CS2 would be unplayable. It is not the whole system.

VAC Live: the server-side kick

The layer people sleep on hardest is VAC Live. It runs on Valve's back end and can flag a suspected cheater during a live match, cancel the round, and evict the offender before the match concludes. Valve pushed a larger VAC Live wave in late 2025 targeting DMA and hardware-assisted cheats, and again in May 2026 with an update that renamed the in-client attribution string. Kill feeds now surface enforcement as "VACNET" rather than "VAC" in a growing share of cases, reflecting where the detection actually originates.

VAC Live matters because it decouples enforcement from the client entirely. There is no local scanner state to fingerprint, no signature list to poll for, no telltale API touch to hook. The client gets a disconnect; the account gets a mark. From a cheat author's perspective, this is the worst possible failure mode: detection happens somewhere you cannot see, on data you cannot withhold.

VACnet: the classifier that never sleeps

Valve announced VACnet at GDC 2018 in a talk by engineer John McDonald titled "Using Deep Learning to Combat Cheating in CSGO." Coverage from PC Gamer reported Valve running the pipeline on roughly 1,700 CPU cores. That number has grown. VACnet is a server-side ML classifier that ingests input telemetry and outputs a suspicion score. Because it runs on Valve's infrastructure, no ring-0 wizardry on the client can hide from it. A cheat can spoof its process list, hide its driver from EnumDeviceDrivers, and route reads through a PCIe FPGA; VACnet still sees the same thing: the input stream that turns into +attack commands and view-angle deltas on the server.

The feature vector VACnet operates on is not public, but Valve engineers have described the class of signals at conferences. A plausible per-engagement feature set looks like this:

# Illustrative VACnet-style feature vector for a single engagement.
features = {
    "time_to_first_shot_ms":      74,     # target visible -> trigger pull
    "peak_angular_velocity_dps":  1420.0, # degrees/sec at snap peak
    "snap_curvature":             0.94,   # 1.0 = single ballistic arc
    "overshoot_correction_deg":   0.12,   # post-snap corrective jitter
    "prefire_offset_ms":         -18,     # negative = fired before visible
    "crosshair_placement_score":  0.71,   # pre-engagement head alignment
    "mouse_sample_variance":      0.008,  # human hands are noisy; bots are not
    "click_to_fire_delay_ms":     3.1,
    "wallbang_prior_visibility":  0.0,    # was the target ever rendered?
}

None of those signals require kernel access on the client. They are all derivable from the input and network telemetry the game already sends. A classifier trained on years of Overwatch-labeled matches can weight them into a confidence score, and Valve has been iterating that model since 2017. Early versions were convolutional classifiers over per-tick input windows; the current generation is almost certainly a transformer over sequence data, though Valve has not published architecture details in years.

Two things make VACnet dangerous even against a clean, undetected cheat. First, it does not care whether your kernel driver hides from PatchGuard. It cares whether your input distribution looks human. Second, its output does not have to be "ban." A suspect score is enough to push the account into a lower Trust Factor bucket, where the social cost compounds on its own.

Trust Factor: the invisible sorting hat

Trust Factor is Valve's matchmaking-level classifier. Every CS account has a hidden trust score derived from account age, hours played, purchase history, report volume, VAC ban history on linked accounts, phone verification, and VACnet signals. High-trust players match with high-trust; low-trust with low-trust.

The effect on the cheating economy is structural. A brand-new account that just spent $15 on Prime, has no games attached, and plays from an IP block Valve has flagged will land in matches full of other low-trust accounts, which in practice means a much higher concentration of visible cheaters. It functions as a soft-ban tier: no explicit action, no notification, just a slow degradation of match quality until the account either builds trust or gets abandoned.

None of that score is visible to the user. The only Trust-adjacent artifacts on the client live in Steam's loginusers.vdf and a handful of HKCU:\Software\Valve\Steam values, and they say nothing about the actual bucket you land in:

# Inspect Steam VAC status for the currently logged-in account.
# VAC-banned accounts show a status in Steam's local config; VACBanned flag lives in
# HKCU:\Software\Valve\Steam plus loginusers.vdf under Steam's install directory.
$loginUsers = 'C:\Program Files (x86)\Steam\config\loginusers.vdf'
if (Test-Path $loginUsers) {
    Select-String -Path $loginUsers -Pattern '"AccountName"|"PersonaName"|"WantsOfflineMode"|"AllowAutoLogin"'
}
# Trust Factor is server-side and not exposed as a readable value. Any client-side
# "Trust checker" tool is guessing from hours-played / friends-list / market-usage heuristics.

This is the whole client-side visibility surface. Anything sold as a "Trust Factor score checker" is either scraping public Steam profile metadata or straight fabrication. Valve does not publish the score, does not expose it through a Steam API, and does not return it in any match join payload the client can log. The classifier lives on the server side and stays there.

A comparison of Valve's active enforcement layers:

None of these are individually devastating. Together they form a funnel: VACnet flags suspicious matches, high-confidence cases feed VAC Live and the batched VAC pipeline, and everything left over quietly modifies Trust Factor. A cheat can beat classic VAC and still get chewed apart by the other three.

The Overwatch question

Here is where a lot of 2024 and 2025 blog posts got it wrong. The CS:GO Overwatch juror system, which let trusted community players review demos of reported accounts, was never truly reactivated in CS2. The menu entry that briefly appeared during the transition is gone, no new cases are being distributed as of mid-2026, and Valve has not published an official Overwatch policy page for CS2. What used to be the labeled-data engine feeding VACnet has been replaced by VAC Live's evictions and by internal review pipelines Valve has not documented publicly. Community requests for its return are constant; treat any post that claims Overwatch is live in 2026 as running on 2019-era knowledge.

The permanence problem

VAC bans are permanent and retroactive: a signature added today can catch a cheat you ran six months ago, and the ban lands on the account you played it on. They apply to the entire Steam account, so a VAC ban on your CS2 account revokes VAC-secured server access for every other VAC-protected game you own. They cannot be appealed, and Steam Support will refuse to discuss the specifics.

The retroactive property is what makes VAC's slow detection cadence work. A cheat author does not know whether their new build is detected until a ban wave lands. If users start getting banned in week 8, that build's cover is blown and so are all the accounts that used it. The economic pressure this puts on the cheating market is one reason serious CS2 products cost what they cost.

Why Valve still refuses to ship a kernel driver

Valve engineers have said on record for years that they consider a kernel anti-cheat an unacceptable trust ask for Steam's user base. The marginal detection a ring-0 driver would provide is not worth the platform risk of running privileged code on hundreds of millions of machines. That position has not changed in 2026. Contrast this with Riot, which now offers Vanguard On-Demand as a partial concession on Windows 11 25H2 hardware, and with Epic, whose EAC driver was ported to Windows on ARM in EOS SDK 1.17.1.3 (August 2025).

The consequence is that Valve has to invest in server-side systems a kernel driver would otherwise pick up. VACnet has been in development for close to a decade; VAC Live is the second-order effect of finally trusting that pipeline to act in real time. Rumors about a "VAC kernel driver rollout" surface in cheating forums, but as of mid-2026 no Valve source, Steamworks entry, or official Counter-Strike blog post announces one.

What this means for a CS2 cheat in 2026

If you assumed VAC was the only threat, you would ship a public build in a weekend and every user would be banned within three months. The actual constraints are shaped by VACnet, VAC Live, and Trust Factor:

1. Never generate input that violates the mouse-movement distribution VACnet is trained on. No instant snaps, no zero-variance micro-adjustments, no sub-frame reactions.
2. Never generate an engagement whose network-visible pattern differs from a human's. Prefire timing, crosshair placement history, and pre-visibility trigger holds all get logged.
3. Model human input noise explicitly. A cheat that draws perfectly smooth Bezier curves onto every head is easier to classify than one that misses sometimes.
4. Assume every kill will be reviewed against your account's other kills. Consistency is what a classifier finds.
5. Assume VAC Live can kick you mid-match. Fail closed the moment the game process disappears.

At KyTech we call this "playing under the classifier." It is not the same problem as evading a kernel driver, and treating it as one is how cheats end up in ban waves. The Windows-side integrity work still matters (VAC will still catch a lazy DLL injection), but it is not where the interesting engineering happens.

How KyTech handles this

Our CS2 product (/product/kytech-cs2) is built around the assumption that classic VAC is the easy problem and VACnet plus VAC Live is the hard one. The kernel component on the client side handles the usual work: hiding artifacts from any usermode integrity scanner, keeping the injected feature module out of the game's private module list, and gating memory reads through mechanisms that do not touch the API surface VAC and community anti-tamper tools fingerprint. Table stakes for a kernel-architected cheat.

The harder work is how aim assist, trigger, and visuals emit input. Every movement is generated from a per-user profile that models human latency variance, overshoot, mouse acceleration, and post-target correction. Trigger delays are drawn from a distribution, not a constant. Aim assist scales down when a target is being pushed toward too fast, because a snap peaking at 2000 degrees per second is a VACnet feature no matter how invisible the cheat is on the client. No visual auto-fire, no obvious wallbang trigger, no perfect prefire.

KyTech was founded in 2025 by two engineers, and CS2 has been in our product line since we launched. We ship six games: Apex Legends, CS2, Overwatch 2, Black Ops 7, Forza Horizon 6, and Roblox. The HWID spoofer in the Apex build is in beta and Apex-only. We do not run affiliate programs, publish user counts, or ship the same code to every customer. For the architectural tradeoffs, how kernel cheats bypass usermode AC is the right next read. Current tier and slot availability live on our pricing page. See the full product lineup for current availability.