DraftGap AI: The Agentic Draft Strategist

A multi-agent AI Co-Pilot that thinks like a coach. It optimizes for Decision Quality, using hybrid intelligence to master synergy, tempo, and player identity in real-time.

Comment

Inspiration

In professional League of Legends, a game is often won or lost before the players even enter the Rift. The draft phase is a high-pressure, 8-minute chess match where coaches must balance statistical win rates against complex, abstract concepts like "team tempo," "win conditions," and "player comfort."

We analyzed existing draft tools and realized they all suffer from the same fatal flaw: They are calculators, not coaches. They can tell you that Rumble has a 52% win rate, but they can't tell you why he’s a bad pick for a scaling composition, or why a lower-win-rate champion might be better for a specific player's playstyle.

We built DraftGap AI to bridge the gap between raw data and human intuition. We wanted to build an AI that doesn't just predict the next pick, but reasons about the game like a world-class strategist.

What it does

DraftGap AI is a real-time Decision Support System for Cloud9 coaches. Unlike traditional tools that optimize for "Prediction Accuracy" (guessing what will happen), DraftGap optimizes for Decision Quality (recommending what should happen).

It functions as a Multi-Agent Co-Pilot that:

  • Predicts the Meta: Uses deep learning to understand drafting patterns and standard responses.
  • Reasons Strategically: Identifies high-level concepts like "Hyper-Scaling" or "Protect the ADC" compositions.
  • Personalizes Recommendations: Adapts suggestions based on the specific player (e.g., boosting Lee Sin when Blaber is the active player).
  • Explains Its Work: Provides a real-time "Reasoning Trace" and a Decision Quality Score (DQS), showing exactly why a recommendation was made (Synergy, Counter, Role Fit, or Tempo).

How we built it

We moved beyond a simple "input-output" model and architected a Hybrid Multi-Agent System using Python and LangGraph, developed entirely within JetBrains PyCharm, utilizing the Junie AI Assistant for code refactoring and performance optimization of our reasoning loops..

The "Brain" consists of four distinct agents working in a loop:

  1. The LSTM Agent (The Historian): A PyTorch BiLSTM trained on 2,054 professional matches from the GRID API. It captures sequential patterns and implicit meta knowledge.
  2. The Strategist Agent (The Head Coach): Rules-based logic that analyzes team compositions to detect identities (e.g., "Dive Comp") and opponent signatures (e.g., "T1 Front-to-Back").
  3. The Reasoning Agent (The Analyst): Synthesizes data from our Synergy/Counter Matrices and applies dynamic bonuses for Player Comfort and Tempo Fit. It calculates the final Decision Quality Score: $$DQS = \alpha(LSTM) + \beta(Synergy) + \gamma(Counter) + \delta(Player) + \epsilon(Tempo)$$
  4. The Critic Agent (The Assistant): Validates the draft for role conflicts (e.g., preventing 3 ADCs) and enforces compositional sanity.

The frontend is a high-performance Streamlit dashboard designed as a "Mission Control" center, featuring live confidence bands visualized with Plotly.

Challenges we faced

  • The "Parrot" Problem: Initially, our LSTM model was too good at predicting standard meta picks. It would recommend generic champions even when a niche counter-pick was strategically superior. We solved this by implementing a Hybrid Scoring Engine, allowing our "Reasoning Agent" to override the neural network when it found a high-value strategic opportunity (like a 100% counter match-up).
  • Data vs. Reality: Professional play has "Flex Picks" (champions played in multiple roles) that confused our role validator. We had to build a robust fallback system that understands role fluidity.
  • Latency: Real-time drafting requires speed. Using external LLM APIs introduced too much latency. By building a local, specialized architecture optimized with JetBrains AI Assistant (Junie), we achieved an inference time of ~300ms, making it viable for live stage usage.

Accomplishments that we're proud of

  • Abstract Reasoning: Our agent successfully passed the "Tempo Test"—recognizing a scaling team composition and autonomously recommending an early-game jungler to provide "insurance," without being explicitly told to do so.
  • Player-Centric AI: Implementing the logic that allows the AI to shift its strategy based on who is sitting in the chair (e.g., the "Blaber Factor").
  • Transparency: Creating a UI that doesn't just dump numbers, but communicates with the coach via the "Reasoning Trace" log.

What's next for DraftGap AI

  • Voice Integration: Allowing coaches to query the agent verbally ("Hey DraftGap, what's the counter to T1's bot lane?").
  • Live OCR: Integrating screen reading to automatically update the draft state from the tournament client without manual input.
  • Scrim Integration: Feeding private Cloud9 scrim data into the model to create a proprietary "Secret Weapon" version of the AI.

Built With

Share this project:

Updates