When you buy your third item and the enemy jungler is ahead, should you go armor or more damage? A static build guide gives you the same answer every game. Real-time AI tools give you the answer for this game, right now — because they read live game state data while you play. Here is exactly what that data looks like, where it comes from, and why it changes every decision.
What Is Game State Data in League of Legends?
Game state data is the complete, moment-by-moment snapshot of every variable inside your active match. It is not your historical win rate or your ranked MMR — those are account-level stats. Game state data is what is happening right now: your current gold, your exact item build, how many Dragon stacks the enemy team has, and what time the next Baron spawns.
Think of it as a scoreboard that updates every few hundred milliseconds. At minute 14 it might say: you have 2,200 gold, a completed Doran’s Blade and Long Sword, your KDA is 3/1/2, the enemy mid laner is 4/0, and they have secured one Infernal Dragon. At minute 18 the same scoreboard looks completely different.
This distinction matters enormously for build decisions. A database like U.GG or Mobafire stores aggregated historical data — average builds from millions of games. It can tell you what items have the highest win rate for Jinx overall. What it cannot tell you is whether you should buy a Quicksilver Sash in this game, at this exact gold threshold, against this specific enemy team composition. For that, you need live game state.
There are two technical layers where LoL data lives:
- Historical data (post-game): match history, win rates, champion stats — accessible via Riot’s Match v5 API after a game ends.
- Live game state data: everything happening inside the current match, available only during an active game via a separate interface called the Live Client Data API.
AI build tools that make real-time recommendations depend entirely on the second layer. The first layer is what every static build site has already been using for years.
The Live Client Data API — LoL’s Real-Time Data Layer
When you join a League of Legends game, the LoL client automatically opens a local web server on port 2999 of your machine. Any application running on the same computer can query https://127.0.0.1:2999 and receive real-time JSON responses describing exactly what is happening in your match.
This interface is Riot’s Live Client Data API — and it is entirely official. Riot documents it on the Riot Developer Portal and explicitly permits third-party tools to read from it, as long as they do not modify game files or inject code. Every legitimate overlay app — whether using Overwolf or running standalone — reads game state through this same mechanism.
The API exposes three main endpoints during an active game:
/liveclientdata/allgamedata— A single comprehensive response containing all available data: active player stats, all players in the match, game events, and game metadata. This is the endpoint AI tools call most frequently./liveclientdata/activeplayer— Focused on the local player only: abilities, current stats (attack damage, ability power, armor, magic resistance), rune choices, and level./liveclientdata/eventdata— A running log of in-game events (kills, towers destroyed, Dragon secured, Baron spawned) with precise timestamps.
Because these requests go to localhost, no data ever leaves your machine during a game session. The tool reads what the game client already has in memory — it is not connecting to an external server and waiting for a response. This is why latency is near-zero and updates happen in real time.
The API only works while a game is active. The moment you return to the client lobby, port 2999 closes and the data stream ends. There is no persistent access to your account, your MMR, or your match history through this channel — that data lives in Riot’s servers and requires OAuth authentication to access.
Tools like Mobalytics, Porofessor, and buildzcrank all build on top of this same data foundation. The difference is what each tool does with the data once it has it.
The Six Data Categories AI Tools Can Read Mid-Game
The /liveclientdata/allgamedata endpoint returns a structured JSON object that falls into six broad categories. Each one feeds a different part of the AI decision-making process.
1. Player-Level Stats
This covers everything tied to the local player: current gold (unspent gold available right now), total gold earned (a proxy for how far ahead or behind you are vs. your average power curve), champion level, CS (creep score and CS/min), KDA, and individual stat values like attack damage, ability power, armor, and magic resistance as they are right now with all item bonuses applied.
The currentGold field is updated in real time — it ticks up every time you last-hit a minion and ticks down when you buy an item. An AI model can use it to determine whether you are 200 gold away from completing a core item or whether you have enough to skip an item and go straight to a mythic.
2. Item State
The API exposes the exact items occupying your six item slots, including starter items and trinkets. This means the AI knows not just what your build will be but what it is right now — which components you have, which slots are empty, and how much gold you have invested so far.
This category is critical for adaptive recommendations. If you have Passive: Spell shield that blocks the next enemy ability.
Edge of Night Edge of Night 2800 gold
3. Rune State
Rune data goes beyond just knowing which keystone you selected. For stacking runes like Dark Harvest (ID: 8128) or Conqueror (ID: 8010), the API exposes current stacks in real time. Dark Harvest stacks reset on takedown; Conqueror stacks build during extended combat.
This allows an AI to weigh whether your keystone is already delivering value or whether a different item path might synergize better with how many stacks you have realistically accumulated by this point in the game.
4. Team and Map State
The API provides objective data for both teams: Dragon stack count (and which elemental types have been secured), Baron Nashor buff status, Rift Herald usage, and tower count by team. It also exposes the position of all players currently visible on the minimap.
At 23 minutes with three Infernal Dragon stacks, the AI knows your team’s damage output has scaled significantly and can adjust item priority accordingly — for example, deprioritizing damage amplification items and recommending ones that improve your ability to close out a fight quickly.
5. Event Stream
Every in-game event is timestamped and logged: kills, assists, deaths, towers destroyed, inhibitors broken, Dragon and Baron secured, and champion resurrection events (Aatrox passive, Guardian Angel). Death events include a respawn timer.
The event stream is what allows an AI to detect power spikes. A 4/0 Zed at 12 minutes is not just a KDA number — it is a pattern of events (four kills, zero deaths, probably snowballing) that correlates with specific build divergences in the training data.
6. Time-Based Triggers
Game time in minutes and seconds is available as a continuous field. Combined with event data, this enables the AI to detect timing windows that are crucial for itemization: the 14-minute first recall decision, the Rift Herald spawn at 8 minutes, the Baron Nashor window opening at 20 minutes, the 15-minute item advantage checkpoints many coaching tools use.
Static guides recommend a build path but they cannot tell you whether it is appropriate to rush your second item or sit on components for three more minutes to answer an early objective. Game time plus gold state together answer that question.
How AI Build Recommenders Process This Data
Reading the data is step one. Using it intelligently is where AI tools diverge from each other — and from every static guide on the internet.
A naive approach would be to feed game state data into a lookup table: “if gold > 2500 and level > 10, recommend item X.” Real AI build systems do something fundamentally different: they use a trained model that has learned relationships between thousands of game state variables and match outcomes across millions of historical games.
Here is how that plays out in practice during a real game:
Scenario: You are playing Zed mid. It is minute 13. You have 1,400 gold, a completed Youmuu’s Ghostblade, and a Long Sword. The event stream shows the enemy Lux mid is 0/2, but their Malzahar jungle is 3/0 and their Lissandra top is 2/1. Your /allgamedata read shows three AP champions on the enemy team, and the game state records that Lissandra has already used her ultimate twice.
A static guide says: “Buy Duskblade next — highest win rate in the 1,400 gold range for Zed.”
An AI reading live game state considers the full picture:
- Gold: 1,400 — enough to finish Serylda’s Grudge component or start a Maw of Malmortius component.
- Enemy AP threat: 3 AP sources including a tanky top laner with CC ultimate already built.
- Kill threat on you: The 3/0 Malzahar jungle can one-shot an Zed with no magic resistance at this gold level.
- Model prediction: Games where Zed skips magic resistance with this enemy composition at minute 13 lose teamfights at a 67% rate once Elder Dragon contest starts.
The recommendation surfaces Maw of Malmortius component as the priority next buy — not because a human wrote a rule for this situation, but because the model learned it from outcomes in the training data.
Tools like buildzcrank apply this same approach: cross-referencing your live game state against patterns learned from high-ELO matches at the relevant patch version, then surfacing the most statistically grounded recommendation for your game, not the average game.
The AI does not play for you. It does not control your inputs or make decisions. It reads data, runs inference, and surfaces a recommendation — what you do with it is still entirely your call.
Why Static Build Guides Cannot React to Game State
Static build sites like U.GG, Mobafire, and OP.GG calculate their recommended builds by aggregating outcomes across millions of completed games. They take the items that appeared most frequently in winning games for a given champion, rank them by win rate, and present you with the result.
This works reasonably well when everything is average. The problem is that your games are never average. They are specific.
What static guides do not know when you open the page:
- How much gold you currently have
- Whether you are 3/0 or 0/3
- Whether the enemy team has three AD champions or three AP champions
- Whether your jungler has been camping your lane or ignoring it entirely
- What minute it is and whether you are transitioning to mid-game or already in a 4v5 teamfight
Static guides have exactly one input: champion name, sometimes role. Their output is always the same regardless of what is happening in your actual game. That is not a limitation of effort — it is a fundamental architectural limitation. They have no connection to your live match.
For a deeper look at why this matters in practice and what the outcome difference looks like in actual ranked games, the full breakdown of why static build guides fail in LoL 2026 walks through the specific scenarios where average advice goes wrong.
If you want to understand how the AI side works in more detail — the training data, the inference loop, and the Patch 26.11 data sources — how AI recommends LoL builds in real time covers the full mechanism from input to recommendation.
The short version: static guides give you the right answer for the average game. Real-time AI tools give you the right answer for this game at this moment.
Common Misconceptions About LoL AI Overlays
These four questions come up constantly, and the answers matter if you are deciding whether to use an AI build tool.
“Does the AI read my Riot account data, match history, or personal information?”
No. The Live Client Data API at port 2999 only exposes in-game variables for the current active match. It has no access to your Riot account credentials, your ranked history, your MMR, or any data from previous games. When the game ends and port 2999 closes, the data stream stops completely.
“Does the tool modify the game client in any way?”
No. The Live Client Data API is strictly read-only. Overlay tools query it — they do not write back to it, inject code into the game process, or modify any game files. The game runs exactly as if no overlay were installed. This is a hard technical boundary: the API exposes a read endpoint only, with no write capability.
“Could this get my account banned?”
Riot Games explicitly permits tools that use the Live Client Data API, provided they do not modify gameplay, automate inputs, or inject code. This is documented in Riot’s third-party app policy. Scripting tools — which simulate mouse clicks or automate skill casts — are what triggers bans. An overlay that reads data and displays a recommendation is categorically different: it is advisory software, not an automation tool.
“Does it play for me?”
No. An AI build tool surfaces a recommendation on your screen. You still execute every last-hit, every ability cast, every positioning decision. The AI provides information — the same kind of information a knowledgeable coach standing next to you would provide, except delivered at the exact moment it is relevant.
Understanding these boundaries is what separates legitimate build tools from scripting software — and why Riot permits one and bans the other.
Frequently Asked Questions About LoL Game State Data
What is the LoL Live Client Data API?
It is an official interface provided by Riot Games that opens a local web server on port 2999 when a League of Legends game is active. Third-party tools can query it to receive JSON data about the current match — player stats, items, events, objectives, and game time. It is documented on the Riot Developer Portal and officially permitted for use in overlay applications.
How frequently does game state data update?
The API can be polled at roughly 500ms to 1,000ms intervals without impacting game performance. At a 500ms polling rate, an AI tool receives a fresh snapshot of your game state approximately every half-second. Gold earned from a last-hit, a kill event, or an objective secured all appear in the next polling cycle.
What data is NOT accessible to AI overlay tools via this API?
The Live Client Data API does not expose your enemy champions’ private stats (the exact items in their backpack before they have been purchased and equipped, or their exact gold count). It also does not provide warded locations, enemy jungle camp timers not visible on the minimap, or any data from previous games. The API reflects only what the game client already knows about the current match.
Can AI build tools see my enemy’s private build choices?
Only what is publicly visible in the game — equipped items, current ability levels, and the event log. If an enemy has gold sitting in reserve but has not bought anything yet, the AI cannot see that number. This is the same information limitation a human player faces: you can see what your opponent has built, not what they are planning to buy.
Does reading game state data require an Overwolf installation?
No. Riot’s Live Client Data API is available to any application running locally, regardless of whether it uses the Overwolf platform. Some tools bundle with Overwolf for distribution convenience; others — including standalone overlays — query the same port 2999 endpoint directly. The data source is identical either way.
Every build decision in League of Legends is context-dependent — and context is exactly what game state data provides. The six data categories available via Riot’s Live Client Data API (player stats, item state, runes, map state, event stream, and timing) together form a complete picture of your game at any moment.
Static guides can tell you what won across millions of games. Real-time AI tools can tell you what gives you the best chance of winning this game, with the enemy composition in front of you, at the gold total you have right now. That is not a marginal improvement — it is a fundamentally different category of advice.
If you want to try real-time adaptive build recommendations in your next game, the LoL itemization guide for 2026 covers the broader decision framework — and buildzcrank applies it live, reading your game state and surfacing the right item at the right moment.