T10 cricket is absolute, unadulterated chaos. In a format where a match lasts barely 90 minutes and is done in 120 legal deliveries, there is no time to “settle in.” A single over containing a couple of sixes and a wicket can swing the win probability from 80% to 20% in the blink of an eye.
If you’ve watched our live win probability tracker, you might have wondered: How does the math keep up with this madness?
Today, we are opening the hood of our production model—which runs on a machine learning algorithm called XGBoost—to explain how we teach an AI to understand the logic of T10 cricket, project scores, and handle the “fog of war” in real time.
The Engine: Why XGBoost?
In the past, many win probability models relied on simple historical averages or basic statistical regressions. But cricket is non-linear. Ten runs scored in the 2nd over with 9 wickets in hand is vastly different from ten runs scored in the 9th over with 2 wickets left.
To capture these dynamics, our model uses XGBoost (eXtreme Gradient Boosting).
Don’t let the name intimidate you. Instead of thinking of it as a complex black box, picture a panel of 1,000 highly opinionated cricket analysts.
- The first analyst looks at the historical T10 data and makes a rough guess.
- The second analyst looks at where the first one made mistakes and adjusts the prediction slightly.
- The third analyst focuses on the errors of the second, and so on.
By the time all 1,000 analysts have weighed in and corrected each other, you get an incredibly nuanced prediction engine that reacts to every single delivery.
Teaching the AI “Cricket Common Sense”
If you throw raw match data at a standard machine learning model, it will occasionally make predictions that violate basic laws of physics—or at least, the laws of cricket.
For example, without guardrails, a model might look at a weird historical outlier match and decide that losing a wicket actually increases a team’s chance of winning. We call these “non- sensical predictions,” and they look terrible on a live broadcast.
To fix this, we implement Monotone Constraints. We hardcode “common sense” directly into the model’s brain:
- For the Batting Team:
- Scoring more runs must always increase win probability.
- Losing wickets or consuming balls must always decrease win probability.
- For the Chasing Team:
- Having more wickets in hand or more balls remaining must always increase the chance of chasing the target.
- Having more runs left to chase must always decrease it.
By locking these rules in, the model behaves logically on every ball, even in extreme scenarios it has never seen before.
The “Innings Break Handshake”
One of the trickiest parts of building a two-innings win probability model is the transition at the innings break.
Imagine Team A finishes their 10 overs at 115 for 4.
At that exact split second, the first inning ends, and the second inning is about to begin. Team B needs 116 to win.
If you use two separate models—one for the 1st inning and one for the 2nd inning—you often get a weird “jump” in the odds during the break. The 1st inning model might say Team A has a 55% chance of winning, while the 2nd inning model starts by saying Team B has a 48% chance (meaning Team A has 52%).
To prevent this logic gap, we built a consistency override (a sort of mathematical handshake). At the very last ball of the first inning, the model overrides its own prediction and says:
“The probability of Team A winning right now must exactly equal 1 minus the probability of Team B chasing down this exact target in the 2nd inning.”
This keeps the odds perfectly seamless as the players walk off the field.
Projecting Scores & the “Fog of War”
Most live score predictors tell you something flat like: “Projected Score: 105.”
But cricket fans know that a projected score is a moving target. Early in the game, the range of possible outcomes is massive. If a team is 20/0 after 2 overs, they could collapse to 80, or explode to 140. By over 8, that window narrows significantly.
Instead of predicting a single number, our engine runs a separate Volatility Model that estimates the uncertainty—what we like to call the “fog of war.”
- Over 2: The model might project a score of 110, but adds a wide boundary: 85 to 135.
- Over 8: The projection might still be 110, but the boundary tightens to 102 to 118.
- Over 10: The boundary collapses to the exact final score.
This gives viewers a realistic look at not just what is likely to happen, but how unpredictable the current state of the game is.
Wrap Up
Behind the clean win probability graph on your screen is a mix of high-speed machine learning (XGBoost), strict cricket logic (monotonicity), and real-time uncertainty tracking.
Next time you see the win-probability needle swing wildly after a double-wicket over in the Abu Dhabi T10, you’ll know exactly how those 1,000 digital analysts are crunching the numbers in the background.
Interested in looking at the code yourself? The repository is now open-source! Check it out here: GitHub – mshashi11/CricketAI