DotaGPT: AI for Dota 2 Strategy

• DotaGPT is a class of advanced AI systems that uses transformer architectures and GPT integration for context-aware, in-game planning and decision making in Dota 2.
• It leverages retrieval-augmented modules and hierarchical attention to provide personalized recommendations based on player history, game state, and team composition.
• Empirical evaluations demonstrate improved metrics like Precision@K and Hit-Ratio, highlighting its effectiveness in optimizing draft and item strategies.

DotaGPT designates a class of advanced, stateful artificial intelligence systems and model architectures specialized for high-dimensional planning, item recommendation, and draft advisory in the context of Dota 2 and related Multiplayer Online Battle Arena (MOBA) environments. DotaGPT solutions leverage transformer-based architectures for contextual reasoning and are typically integrated with retrieval-augmented modules for in-game state, drafting, and personalization. These systems operationalize interpretable, context-aware recommendations for both itemization and hero drafting, supporting fine-grained, real-time, and interactive AI guidance within Dota 2.

1. Architectural Foundations: Dota 2 AI Modding and External Controllers

The core infrastructure underpinning DotaGPT deployments is the Dota 2 AI framework as developed for the Dota 2 Bot Competition (Font et al., 2021). Here, a custom Dota 2 “mod” implemented via LUA scripts mediates access to the unaltered Dota 2 game engine, providing a transparent JSON-over-HTTP interface to one external AI controller per game instance. At approximately 30 Hz, the mod serializes the bot-visible game state and posts it to a designated HTTP endpoint, requiring synchronous replies before the game state can advance.

The system architecture is as follows:

$o_t = \phi(s_t) \in \mathbb{R}^d$6

State vectors $s_t$ are encapsulated as arrays of entities, each entity $e_i$ comprising discrete class labels (“Hero,” “Tower”), normalized numerical features (e.g., health, position), and Boolean status flags. These are transformed into observation vectors $o_t = \phi(s_t) \in \mathbb{R}^d$, which serve as inputs for the agent’s policy $\pi(o_t) \in A$, with $A$ supporting hybrid discrete-continuous commands including MOVE, ATTACK, CAST, and inventory management.

This protocol is agnostic to the controller language, requiring only HTTP POST listeners for the main function calls (e.g., /select, /update, /chat). The framework enables real-time, closed-loop AI integration with authentic game matches, supporting research on learning, planning, and decision modeling in complex, partially observable, adversarial domains (Font et al., 2021).

2. Item Recommendation: Transformer-Based Contextual Modelling

DotaGPT instantiates sophisticated item recommendation by adapting the Interpretable Contextual Team-aware Item Recommendation (TTIR) transformer architecture, as detailed in (Villa et al., 2020). Each match is represented as a sequence of participant tokens $x_i$—embedding hero identity, role, team, and optionally temporal/statistical features—that are stacked into a matrix $X \in \mathbb{R}^{10 \times d_{model}}$ and encoded via multi-layer, multi-head self-attention.

The workflow is:

1. Input Embedding:

$$x_i = E_{champ}(h_i) + E_{role}(r_i) + E_{team}(t_i) + E_{pos}(i)$$

1. Transformer Encoding: $C = \text{Transformer}(X)$
2. Scoring: For each hero $i$, item logits $e_i$0 compute $e_i$1 for each item $e_i$2, with $e_i$3-best selected for recommendation.

This approach contextually fuses all observed team, enemy, and role relations, enabling item builds to adapt to both ally/enemy composition and critical match-state variables. The model employs a multi-label binary cross-entropy loss for training. Attention matrices provide native interpretability: $e_i$4 weights can be visualized or presented to explain which peer entities most influenced specific item recommendations (Villa et al., 2020).

Empirical results on analogous MOBA data show the transformer approach (TTIR) achieves state-of-the-art Precision@K and Recall@K, outperforming ANN, CNN, and non-contextual baselines.

3. Draft Recommendation and Personalization via Hierarchical Attention

Draft phase support in DotaGPT utilizes the personalized draft recommendation system DraftRec (Lee et al., 2022). DraftRec formalizes the problem as sequential decision modeling over T=10 draft turns, modeling each player’s contextual state $e_i$5 and leveraging two-stage transformers:

• Player Network: Encodes historical games of each player $e_i$6, embedding heroes, roles, and real-valued or discretized in-game features.
• Match Network: Integrates player representations and partial draft board context, applying self-attention to capture synergy, counter-synergy, and team constraints.

At each draft turn, the model outputs both hero pick distributions $e_i$7 and predicted win probabilities $e_i$8. The joint loss

$e_i$9

balances pick-prediction and win-prediction (Lee et al., 2022).

DraftRec exhibits robust empirical advantages on Dota2 data: Hit-Ratio@5 = 0.1492 (versus 0.1477 best baseline), and user studies confirm high subjective plausibility and satisfaction.

4. Integrating Transformer Policy Modules with GPT-Based Natural Language Reasoning

A “DotaGPT” system, as synthesized from (Villa et al., 2020, Lee et al., 2022), combines game-specific transformer modules with LLM (GPT) prompting and interaction:

• At each draft or itemization turn, the transformer-based DraftRec or TTIR module encodes the current game state and outputs $o_t = \phi(s_t) \in \mathbb{R}^d$0-best recommendations, together with attention-based rationales.
• The GPT core consumes enriched prompts including: player match histories (free-text), derived statistics (e.g., win rates, XPM), and pick/ban or hero/item states (as special tokens). It generates natural language commentary, clarifying questions, and actionable recommendations.
• Training can involve multi-task losses: language-modeling, DraftRec’s prediction loss, and auxiliary win-loss heads.
• Safety constraints are enforced via thresholds ($o_t = \phi(s_t) \in \mathbb{R}^d$1) on transformer module pick scores and offline RL (CQL) safeguarding against out-of-distribution actions.

A plausible implication is that DotaGPT systems can maintain conversational context, personalize advisory based on player experience, and adapt recommendations to evolving game patches or MMR skill brackets (Lee et al., 2022). GPT’s fluency enables user interaction, rationalization (“Pangolier synergy with your Shadow Demon is high”), and guided trade-off explanation.

5. Evaluation Methodologies and Empirical Results

Evaluation of DotaGPT component modules is conducted using information retrieval and draft outcome metrics:

• Item Recommendation (Villa et al., 2020):
  • Precision@K, Recall@K, F1@K, MAP@K for top-K items per hero.
  • On League of Legends data, TTIR attains $o_t = \phi(s_t) \in \mathbb{R}^d$2, $o_t = \phi(s_t) \in \mathbb{R}^d$3; outperforming decision-tree, logistic, and neural baselines.
• Draft Recommendation (Lee et al., 2022):
  • Hit-Ratio@5, Normalized Gain@10 (NG@10), and outcome prediction accuracy at each draft turn.
  • For Dota2, DraftRec yields Hit-Ratio@5 = 0.1492, NG@10 = 0.1496, match outcome accuracy (10 picks known) = 0.6110.
  • Key ablation demonstrates that removing player history degrades HR@10 by ≈36%, validating the necessity of longitudinal player modeling.
• Interpretability: Attention matrices are routinely visualized, and user-facing interfaces relay “why” certain item or draft choices are advised, via contextual attentional explanations.

Online A/B testing, integrating MMR tracking and live match conversions, is recommended for end-to-end DotaGPT system validation. Frequent retraining on new patch data is necessary to preserve recommendation optimality.

6. Limitations and Prospective Extensions

Current DotaGPT deployments face constraints inherited from their underlying frameworks:

• Only one external AI agent at a time in the Dota 2 Bot Competition infrastructure; multi-agent interaction (true 5v5) is not natively supported (Font et al., 2021).
• Game state observations exclude raw pixels; no vision-based input pipeline is provided.
• No native timeouts on per-tick controller decisions, allowing for indefinite blocking if not externally restricted.
• Training highly data-intensive: O$o_t = \phi(s_t) \in \mathbb{R}^d$4–$o_t = \phi(s_t) \in \mathbb{R}^d$5 matches recommended for robust item transformer learning (Villa et al., 2020).
• DraftRec module performance saturates with history length (L=20 for Dota2, L=50 for LoL); long-term histories offer diminishing returns (Lee et al., 2022).

Suggested enhancements include: exposing GPU-accelerated vision streams; supporting multiple concurrent bots for multi-agent training; richer in-game communication channels for studying coordination; continuous leaderboard evaluation and match-making; and explicit embedding of game patch version, role specialization, and MMR bracket for real-time adaptation (Font et al., 2021, Villa et al., 2020, Lee et al., 2022).

7. Research Significance and Impact

By unifying transparent HTTP/JSON game control, contextually attentive transformer architectures, and natural language generation, DotaGPT systems lower the engineering threshold for AI experimentation with real-world, high-complexity eSport environments. These platforms serve as flexible benchmarks for deep reinforcement learning, sequential recommendation, explainable planning, and human-AI co-play—addressing grand challenges in both computational game intelligence and sequential multi-agent decision making (Font et al., 2021, Villa et al., 2020, Lee et al., 2022).