JetCloud

Your Opponent Has Data. You Have JetCloud. "Multi-Agent Intelligence That Predicts the Match Before It Starts"

Comment

JetCloud: Autonomous Multi-Perspective Intelligence for Esports

"A JARVIS for Esports - Replacing Spreadsheets with a Synthetic Team of Expert Agents."

Problem Statement: The Data-Insight Gap in Professional Esports

In high-stakes Valorant competition, information is the primary currency. Matches are often decided before they begin-by the team that best understands their opponent’s tendencies. However, the current analytical workflow is fundamentally broken.

  • The Problem of Volume: Services like GRID provide terabytes of match events, but raw data is not insight. A single series generates thousands of data points (kills, positioning, varying economies) that are humanly impossible to parse in real-time.
  • The Latency of Insight: Analysts spend 6-10 hours manually compiling spreadsheets and watching VODs to extract a single strategic pattern (e.g., "Opponent collapses after losing pistol rounds"). By the time this insight is ready, the match might be over.
  • Dimensional Flattening: Traditional dashboards show what happened (K/D ratios), but fail to explain why or predict what's next. They lack the context to simulate how an aggressive duelist's volatility impacts the team's overall economy.

This is a universal problem in modern esports: teams are drowning in data but starving for wisdom.

Solution Statement: Autonomous Multi-Perspective Intelligence

JetCloud is not just a dashboard; it is an Autonomous Multi-Agent System that simulates a full room of human experts working in unison.

Instead of presenting the user with raw charts, JetCloud employs a "Synthetic Team" architecture. It treats the analytical process as a collaborative workflow between specialized AI agents—a Scout, an Analyst, a Coach, a Manager, and even a simulated Opponent. This approach allows for Autonomous Multi-Perspective Intelligence Synthesis: the system doesn't just calculate stats, it "debates" them from different viewpoints (tactical, psychological, statistical) to produce high-confidence strategic scenarios.

We have moved from "Data Visualization" to "Outcome Simulation."

Key Innovations

1. Parallel Stakeholder Simulation (The "Synthetic War Room")

Unlike linear pipelines that lose context, JetCloud utilizes a ParallelAgent architecture to run four distinct LLM personas concurrently:

  • The Coach: Analyzes tactical setups and counters.
  • The Analyst: Validates statistical significance and reliability.
  • The Manager: Evaluates stability, preparation costs, and roster risks.
  • The Opponent: Simulates the enemy’s psychological state and pressure points. This mimics a real diverse human strategy meeting, ensuring insights are well-rounded rather than one-dimensional.

2. Hybrid Neuro-Symbolic Analysis

Pure LLMs hallucinate; pure stats are dry. JetCloud fuses them.

  • Symbolic Layer: We use pandas to calculate immutable, hard-fact metrics like "True KDA," "First Kill Rate," and "Volatility Index."
  • Neural Layer: Google Gemini agents interpret these hard metrics. The agents are grounded: they cannot hallucinate a player's performance because they are forced to synthesize pre-calculated statistical facts.

3. Systematic Hallucination Control via Pydantic

To ensure the dashboard never crashes or displays nonsense, every critical agent output is strictly typed using Pydantic models. The Simulation Agent, for example, must adhere to a SimulationScenario schema, requiring a probability float (0.0-1.0), a quantitative basis key, and a specific "winning lever." If the reasoning doesn't fit the schema, it's rejected.

4. Real-Time "Glass Box" Reasoning

Esports teams don't trust black boxes. JetCloud streams the entire "thought process" of the agent swarm via Server-Sent Events (SSE). Users watch the Scout finding data, the Analyst calculating correlations, and the Coach formulating strategies live. This transparency builds trust in the AI's conclusions.

Architecture

The system follows a strict Ingest-Refine-Synthesize-Predict flow, implemented using the Google Agent Development Kit (ADK) and Google Gemini 2.5.

1. Data Ingestion Layer ("The Scout")

  • Component: ScoutingAgent (Python-native).
  • Function: Interacts with the GRID Esports API via GraphQL to fetch deep match history (6-month window).
  • Design Choice: We purposely decoupled ingestion from analysis. The Scout's job is purely IO-bound—fetching, cleaning, and normalizing data into a standardized CSV Lake (series_overview.csv, team_segments.csv). This separation of concerns ensures that network flakes don't crash reasoning threads.

2. Analytical Layer ("The Analyst")

  • Component: AnalyzerAgent powered by TeamStatsAnalyzerAgent.
  • Function: Bridges the gap between raw data and LLM reasoning.
  • Engineering: It performs heavy-duty processing using Pandas to derive complex second-order metrics:
    • Exploitable Weakness Detection: Algorithms that scan for specific patterns, like "Post-Pistol Collapse" (win pistol -> lose bonus round) or "Carry Dependency" (Top fragger KDA gap > 5.0).
    • Threat Assessment: A deterministic scoring algorithm (0-100) combining win rate, current form, and streak momentum.
  • Handoff: These derived insights are injected into the InvocationContext, providing the LLMs with a "fact sheet" they must adhere to.

3. Stakeholder Simulation Layer (Parallel)

  • Component: ParallelAgent orchestrating CoachAgent, ManagerAgent, PlayerAgent, and AnalystAgent.
  • Function: Each agent receives the same "fact sheet" but processes it through a different system instruction (persona).
  • Innovation: Running these in parallel drastically reduces latency compared to a sequential chain, allowing for rich, multi-perspective analysis in the time it takes to run a single query.

4. Predictive Synthesis Layer ("The Simulator")

  • Component: SimulationAgent (Gemini 2.5 Flash-Lite).
  • Function: It does not look at raw data. It looks at the opinions of the Stakeholder agents.
  • Innovation: It acts as a meta-reasoner. It synthesizes the Coach's tactical warnings and the Manager's risk assessment to generate 5 Probabilistic Match Scenarios, each with a "Winning Lever" (a specific condition our team must satisfy to win).

5. State Flow & Orchestration

State management is handled by ADK's InMemorySessionService. The InvocationContext serves as the nervous system, passing immutable references to the CSV artifacts and the derived statistical dictionaries down the chain. This prevents "Telephone Game" distortion-the Simulation Agent references the exact same "True KDA" value as the Analyst Agent, ensuring consistency.

Technical Challenges & Solutions

1. Rate-Limited Data Ingestion

Challenge: The GRID API enforces a strict 40 requests/minute limit. A naive linear fetch for 6 months of data would trigger immediate bans. Solution: We implemented an intelligent throttling mechanism within ScoutingAgent using asyncio.sleep strategies synchronized with batch processing. The agent creates an internal queue, processing fetches in optimized bursts to maximize throughput without hitting the ceiling.

2. Preventing "Hallucinated Strategy"

Challenge: Early iterations saw agents inventing plays that didn't exist or misinterpreting game economy. Solution: We moved all calculation logic out of the LLM. The LLM is never asked to "calculate the average KDA" (which it is bad at); it is given the team_kda as a float and asked to "interpret the strategic implication of a 2.4 KDA." This separation of Calculation (Code) vs. Reasoning (LLM) solved the hallucination problem.

3. Dashboard-Ready Structured Output

Challenge: Visualizing complex AI reasoning on a frontend requires rigid data structures, but LLMs love to chat. Solution: We utilized rigid Pydantic models for the final output layers. The SimulationOutput model enforces that every scenario has a numeric likelihood and a specific "primary_driver" string. If the LLM output fails validation, the ADK pipeline catches it, ensuring the frontend only ever receives valid, renderable JSON.

Evaluation & Results

  • Speed: A typical 6-month historical analysis that takes a human analyst ~8 hours is completed by JetCloud in under 2 minutes.
  • Throughput: The system successfully digests and cross-references over 50+ matches and hundreds of individual player performance metrics per run.
  • Depth: The system identifies subtle patterns like "Agent Pool Concentration" (Herfindahl Index > 0.5) that are invisible to human introspection without manual calculation.
  • User Experience: "One-Click to Insight." The latency between query and actionable strategy is reduced by orders of magnitude, enabling true "timeout-level" decision making.

Future Vision

  • Real-Time "Timeout" Coach: upgrading the pipeline to run on live state deltas. A coach could ask via voice during a 60-second timeout: "They are rushing B site, what's the counter?" and get an immediate, data-backed answer.
  • Live Game Overlay: Moving from a web dashboard to an in-game DirectX overlay that warns players of opponents' "Clutch Tendencies" in real-time.
  • League-Wide Meta Analysis: Scaling the Scout to ingest every match in the league continuously, building a proprietary "Meta-Game Knowledge Graph" that predicts trends before they become popular.

Conclusion: Why This Matters

JetCloud represents a paradigm shift from Descriptive Analytics ("You died here") to Prescriptive Simulation ("If you hold this angle, you have a 70% chance of winning based on their current tilt factor").

By democratizing access to this level of analysis, we are leveling the playing field. High-tier analytics was previously the luxury of well-funded organizations with armies of analysts. JetCloud puts the power of a synthetic analyst team into the hands of every coach and player, potentially changing how the game is prepared for, played, and won.

Assets

Uploaded images were generated using Gemini (Nano Banana). The demo video was created using Google AI Studio TTS, Google Veo and DaVinci Resolve.

Built With

Share this project:

Updates