Captain Cool: I Built a Multi-Agent IPL Strategist with Google Gemini 2.5 Flash and ADK

Arnav Maheshwari — Sun, 17 May 2026 13:02:34 +0000

The Idea
What if an AI could think like MS Dhoni in the 18th over of a chase?
That was the question behind Captain Cool — a multi-agent AI system that acts as a virtual IPL captain, making real tactical decisions the way Dhoni, Rohit, or Hardik would. You give it the match state. It gives you the next decision, the reasoning, and the internal debate that led there.
This was built for the Google Gemini Hackathon in a single session using Google Antigravity, Gemini 2.5 Flash, and the Agent Development Kit (ADK).
🔗 Live Demo: https://captain-cool-ruddy.vercel.app/
🔗 GitHub: https://github.com/CodeCatalyst-07/captain_cool

The Problem
IPL captaincy is one of the most high-stakes real-time decision problems in sports. Every over, a captain must answer:

Who bowls next — and against which batter?
Should I use my Impact Player now or save them?
Is dew going to affect my death-over plan?
Do I attack or protect wickets here?

Current AI cricket tools give you stats. None of them reason like a captain. I wanted to build something that does.

Architecture Overview
Captain Cool is a 4-agent system built on Google ADK. Each agent has a distinct role, its own system prompt, and runs as a separate LlmAgent instance powered by Gemini 2.5 Flash.
USER INPUT (Match State)
↓
┌─────────────────────┐
│ STATS ANALYST │ → Fetches live data, weather, builds tactical picture
└─────────────────────┘
↓
┌─────────────────────┐
│ STRATEGIST │ → Proposes next decision in captain-speak
└─────────────────────┘
↓
┌─────────────────────┐
│ DEVIL'S ADVOCATE │ → Raises 2 hard objections using cricket analytics
└─────────────────────┘
↓
┌─────────────────────┐
│ STRATEGIST │ → Defends or revises based on challenge
└─────────────────────┘
↓
┌─────────────────────┐
│ COMMENTATOR │ → Narrates final decision like Harsha + Shastri
└─────────────────────┘
↓
FINAL DECISION + WIN PROBABILITY BEFORE vs AFTER
This is a genuine multi-turn debate loop — not a single prompt wearing four hats. Each agent runs independently with its own session, its own system prompt, and passes context forward to the next round.

The Four Agents

Stats Analyst 📊 Role: Data gatherer and tactical picture builder This agent is equipped with two function-calling tools:

get_live_cricket_state() — calls CricketData.org API for live match data
get_pitch_weather() — calls OpenWeatherMap for dew risk and humidity at the venue

It outputs a structured JSON summary covering phase context (powerplay/middle/death), key matchups, bowler overs remaining, weather conditions, and a batting depth rating from 0 to 1.
System prompt excerpt:

"You are a cricket data analyst. Your job is to fetch live match data and build a precise tactical picture. Always output valid JSON with keys: phase, key_matchups, bowlers_remaining, batting_depth_rating, weather_summary, run_rate_context."

Strategist 🏏 Role: The captain — proposes the next tactical decision This is the core decision-making agent. It has the instinct of Dhoni, Rohit, and Hardik combined. It receives the Stats Analyst's output and proposes a concrete plan covering the next bowler, field setup, Impact Player usage, and batting approach. It uses compute_win_probability() as a tool to ground its decisions in real numbers. Output format is always: DECISION / RATIONALE / FIELD SETUP / CONTINGENCY System prompt excerpt:

"You are an IPL T20 captain with the combined instinct of MS Dhoni, Rohit Sharma, and Hardik Pandya. Propose the next tactical decision. Use cricket language only — no data science jargon. Structure your output as DECISION, RATIONALE, FIELD SETUP, CONTINGENCY."

Devil's Advocate 😈 Role: The critic — challenges every proposal This agent receives the Strategist's proposal and must raise exactly 2 specific objections using phase analytics, matchup data, dew conditions, or boundary dimension logic. It must either force a revision or accept the defense with a clear verdict: VERDICT: REVISION REQUIRED or VERDICT: ACCEPTED. System prompt excerpt:

"You are a ruthless IPL data analyst. Your job is to challenge every strategy. Raise exactly 2 objections using phase-based analytics, matchup data, dew conditions, or bowling economy. End with VERDICT: REVISION REQUIRED or VERDICT: ACCEPTED."

Commentator 🎙️ Role: Narrates the final decision This agent takes the entire debate transcript and writes one punchy paragraph of cricket commentary in the voice of Harsha Bhogle and Ravi Shastri combined. Zero data science language. Pure cricket emotion. System prompt excerpt:

"You are Harsha Bhogle and Ravi Shastri combined. Read the full debate transcript and narrate the final decision in one paragraph. Be emotional, technical, and vivid. Never use ML or data science language."

The Tools
Three Gemini function-calling tools power the system:

get_live_cricket_state(match_id) Calls CricketData.org free API. Returns current score, overs, batsmen, bowler, and phase context.
get_pitch_weather(venue) Calls OpenWeatherMap free API. Extracts city from venue string automatically ("Wankhede Stadium Mumbai" → "Mumbai"). Returns temperature, humidity, and dew risk (high/medium/low).
compute_win_probability(target, runs, wickets, overs, dew_risk, batting_depth_rating) Pure local calculation. Base 0.5 with adjustments for required run rate brackets, wickets in hand, dew factor (+0.05 if high), and batting depth. Returns win probability as a float clamped between 0.0 and 1.0.

The Debate Loop
This is the heart of the system. Here's the actual flow in orchestrator.py:
python# Round 1: Stats Analyst builds the picture
stats_summary = await _run_agent_turn(stats_analyst_agent, match_state_prompt)

Round 2: Strategist proposes a decision

initial_proposal = await _run_agent_turn(strategist_agent, stats_summary)

Round 3: Devil's Advocate challenges it

devils_challenge = await _run_agent_turn(devils_advocate_agent, initial_proposal)

Round 4: Strategist defends or revises

final_decision = await _run_agent_turn(strategist_agent,
f"Prior proposal: {initial_proposal}\nChallenge: {devils_challenge}\nNow defend or revise.")

Round 5: Commentator narrates

commentary = await _run_agent_turn(commentator_agent,
f"Full debate: {initial_proposal}\n{devils_challenge}\n{final_decision}")
Each agent gets its own session_id with a UUID suffix for concurrency safety. Context is threaded as a cumulative transcript — no shared session state needed.

A Real Match Scenario
Input:

Innings: 2, Over: 14, Score: 134/4
MI batting, CSK bowling
Bumrah: 2 overs remaining, Chahar: 3 overs remaining
Venue: Wankhede Stadium Mumbai
Target: 185, Dew Factor: ON

Stats Analyst output:
json{
"phase": "death",
"bowlers_remaining": {"Bumrah": 2, "Chahar": 3},
"batting_depth_rating": 0.7,
"weather_summary": "haze with medium dew risk",
}
Strategist's initial proposal:

"Bring Bumrah on immediately. With a batting depth rating of 0.7 and 36 balls left, this is the moment to strike. His yorker is the only answer on a dewy Wankhede surface."

Devil's Advocate:

"OBJECTION 1: Medium dew risk means the ball is already skidding — Bumrah's straight yorker becomes a half-volley. Wide yorkers are safer.
OBJECTION 2: Burning both Bumrah overs now leaves overs 18 and 20 uncovered if this partnership holds."

Strategist's final decision:

"DECISION: Bring Bumrah on but instruct wide yorkers and back-of-length cutters only — no straight full tosses.
RATIONALE: The DevilsAdvocate is right about dew. Adjust the length, not the bowler.
FIELD SETUP: Two slips, a gully, deep square leg, fine leg, deep cover.
CONTINGENCY: If no wicket in this over, hold Bumrah's second spell for over 19."

Commentary:

"And there it is — Dhoni's ghost walking the boundary! The skipper backs his gun, but with a tactical tweak that only a true student of the game would make. No straight yorkers tonight, Harsha — the dew has stolen that weapon. But Bumrah with wide yorkers and cutters? That's still a nightmare for any batter alive!"

Win Probability: 62% → 66% (+4% strategy impact)

Tech Stack
LayerTechnologyAI ModelsGoogle Gemini 2.5 FlashAgent FrameworkGoogle ADK (Agent Development Kit)Function Callinggoogle-genai SDKBackendFastAPI + UvicornFrontendReact 18 + Vite + Tailwind CSSCricket DataCricketData.org (free tier)WeatherOpenWeatherMap (free tier)Frontend DeployVercelBackend DeployRender.com

Project Structure
captain-cool/
├── captain_cool/
│ ├── config/settings.py # API keys + constants
│ ├── tools/
│ │ ├── cricket_api.py # Live cricket data tool
│ │ ├── weather_tool.py # Dew/weather tool
│ │ └── win_probability.py # Win probability calculator
│ ├── agents/
│ │ ├── stats_analyst.py # Agent 1
│ │ ├── strategist.py # Agent 2
│ │ ├── devils_advocate.py # Agent 3
│ │ └── commentator.py # Agent 4
│ ├── orchestrator.py # Debate loop
│ └── api/server.py # FastAPI backend
├── frontend/
│ ├── src/
│ │ ├── pages/
│ │ │ ├── LandingPage.jsx # Hero + agents showcase
│ │ │ ├── AnalyzePage.jsx # Form + results
│ │ │ └── HowItWorksPage.jsx # Architecture diagram
│ │ └── components/
│ │ ├── MatchForm.jsx
│ │ ├── ResultCards.jsx
│ │ ├── WinProbBar.jsx
│ │ └── LoadingSpinner.jsx
└── tests/
├── test_tools.py # 25 tests
└── test_agents.py # 13 tests

What I Learned

Multi-agent debate is genuinely better than single-agent prompting. The Devil's Advocate consistently caught things the Strategist missed — especially dew factor implications and bowling resource management. The final decisions were measurably more nuanced after the challenge round.
ADK's session isolation matters. Giving each agent its own session_id with a UUID suffix prevented context bleed between rounds. Without this, the Commentator would sometimes "remember" the Strategist's early proposals and contradict the final decision.
Free APIs are enough for a hackathon. CricketData.org's free tier (100 calls/day) and OpenWeatherMap's free tier (1000 calls/day) were more than sufficient for the demo. The agents handle API failures gracefully and still produce quality output from the manually entered match state.
Gemini 2.5 Flash understands cricket. I didn't need to explain IPL rules, Impact Player mechanics, or death-over conventions in detail. The model had strong prior knowledge of T20 cricket strategy that made the system prompts much shorter than expected.

What's Next

Real-time mode: Paste a Cricbuzz URL and the system scrapes live state automatically using Gemini's URL context tool
Voice mode: Web Speech API input + Gemini Live API output so the captain literally talks back
Memory across overs: Gemini context caching for multi-over strategic continuity
Confidence scores: "If you'd bowled X instead, win probability drops 8%"

DEV Community: Arnav Maheshwari

Captain Cool: I Built a Multi-Agent IPL Strategist with Google Gemini 2.5 Flash and ADK

Round 2: Strategist proposes a decision

Round 3: Devil's Advocate challenges it

Round 4: Strategist defends or revises

Round 5: Commentator narrates