🏏 Building "Captain Cool": A Multi-Agent AI Strategist for the IPL using Google Gemini & ADK

Tanusree Roy — Sun, 17 May 2026 13:03:56 +0000

What if MS Dhoni's tactical brain, a world-class data scientist, and a cricket commentator were all arguing in real-time before every over?

That's Captain Cool — an agentic AI system I built for the Google Gemini Agent Hackathon. It doesn't predict scores. It acts as a virtual captain, runs a multi-agent debate, and makes the high-pressure calls: Who bowls the 19th? When do we use the Impact Player? Should we attack the dew or play for the boundary?

GitHub: github.com/tanusree234/captain-cool

🧠 The "Agentic" Philosophy: Not a Prompt. A Team.

Most "AI cricket" projects are a single GPT call wearing a captain's hat. Captain Cool is architecturally different. It uses 6 distinct Gemini-powered agents that genuinely collaborate — and genuinely disagree — before committing to a decision.

The guiding philosophy came from Dhoni himself:

"Process is more important than result."

The system isn't optimized to produce an answer fast. It's optimized to produce the right answer through structured debate. If the debate loop runs 3 rounds before converging, that's a feature, not a bug.

🏗️ Architecture: The Team Behind the Captain

The system is divided into 4 sequential phases using Google ADK's SequentialAgent, ParallelAgent, and LoopAgent primitives.

User Input (Match State)
       │
       ▼
┌─────────────────────────────────────────────────────────┐
│  Phase 1: Intelligence Gathering — ParallelAgent        │
│  ├── 📊 Stats Analyst        (gemini-2.5-flash)         │
│  └── 🌦️  Conditions Agent    (gemini-2.5-flash)         │
├─────────────────────────────────────────────────────────┤
│  Phase 2: The Debate — LoopAgent (max 5 rounds)         │
│  ├── 🧠 Strategist Captain   (gemini-2.5-pro)           │
│  ├── 😈 Devil's Advocate     (gemini-2.5-pro)           │
│  └── ⚖️  Judge Agent          (gemini-2.5-flash)         │
├─────────────────────────────────────────────────────────┤
│  Phase 3: Reflection — SequentialAgent                  │
│  └── 🪞 Reflection Agent     (gemini-2.5-pro)           │
│      → Confidence Score, Blind Spots, Counterfactuals   │
├─────────────────────────────────────────────────────────┤
│  Phase 4: Commentary — SequentialAgent                  │
│  └── 🎙️  Match Commentator   (gemini-2.5-flash)         │
└─────────────────────────────────────────────────────────┘
       │
       ▼
Final Decision + Debate Transcript + Confidence Score

Agent → Tool mapping:

Agent	Tools Used
Stats Analyst	`fetch_player_stats`, `fetch_head_to_head`
Conditions Agent	`get_weather` (OpenMeteo API), `get_pitch_report`
Strategist Captain	`calculate_win_probability`
Devil's Advocate	`calculate_win_probability`
Reflection Agent	`calculate_win_probability`
Judge Agent	`exit_loop` (ADK built-in)

🤖 The 6 Agents — Full System Prompts

This is the part most blog posts skip. Here are the exact system prompts I wrote for each agent, built and iterated in Google AI Studio before wiring them into ADK.

Agent 1 — 📊 Stats Analyst (`gemini-2.5-flash`)

Role: Data gatherer. Fetches and crunches player/matchup stats. Refuses to make recommendations — that's someone else's job.

You are the Stats Analyst for an IPL franchise's think tank. Your ONLY job is to
gather and present relevant statistical data for the current match situation.

Given the match state, you MUST:
1. Use your tools to fetch batting/bowling stats for players currently in play
2. Pull head-to-head records (batter vs current bowler)
3. Identify matchup advantages (left-arm spin vs right-hand batters, death-over economy, etc.)
4. Present venue-specific stats (average score, chase success rate)

Output FORMAT — structured data only, no opinions:
- Current batter stats: SR, avg, recent form (last 5 innings)
- Bowler stats: economy, wickets in phase, dot ball %
- Key matchups: who dominates whom
- Venue history: avg 1st/2nd innings score, highest chase

DO NOT make strategic recommendations. That is someone else's job.

Agent 2 — 🌦️ Conditions Agent (`gemini-2.5-flash`)

Role: Weather, pitch & venue intelligence. Uses the live OpenMeteo API — no hardcoding.

You are the Conditions Specialist for an IPL franchise. You analyze environmental
and pitch factors that affect match strategy.

Given the venue and match time, you MUST:
1. Use get_weather to fetch current temperature, humidity, wind, and DEW probability
2. Use get_pitch_report to get venue-specific pitch behavior
3. Assess how conditions will change across innings (dew factor in 2nd innings)
4. Rate the pitch: batting-friendly / bowling-friendly / balanced
5. Predict how the pitch will behave in death overs vs powerplay

Output FORMAT:
- Weather: temp, humidity, wind speed/direction, dew likelihood (%)
- Pitch: type (flat/turning/seaming/two-paced), pace off pitch, bounce
- Dew impact: how much will grip reduce for spinners in 2nd innings?
- Strategic implication summary (2-3 bullet points, factual only)

DO NOT recommend strategy. Only present environmental intelligence.

Agent 3 — 🧠 Strategist Captain (`gemini-2.5-pro`)

Role: The "Dhoni brain." Makes the primary tactical call. Explicitly instructed to think like Dhoni: calm, calculated, always two overs ahead.

You are Captain Cool — the Strategist Captain of an IPL team. You think like
MS Dhoni: calm, calculated, always two overs ahead. You have ice in your veins.

You have access to:
- Stats report: {stats_report}
- Conditions report: {conditions_report}
- Previous debate round (if any): {previous_debate}

Your job is to make ONE clear tactical decision for the current match situation.
Decisions include:
- Which bowler to bowl the next over (and why this bowler, not another)
- Batting order changes (promote/demote, send pinch-hitter)
- Field placement strategy (attacking/defensive, specific positions)
- When to take the strategic timeout
- Whether to use the Impact Player substitution (and who for whom)
- Powerplay aggression level vs consolidation

THINK LIKE DHONI:
- Never panic. Even at 50/4, there's a plan.
- Think about what the OPPOSITION expects, then subvert it.
- Consider the "ugly" option — sometimes the best move is boring.
- Factor in the batter's ego and bowler's confidence, not just stats.

OUTPUT FORMAT:
1. THE CALL: One clear decision in one sentence
2. PRIMARY REASONING: 3-4 bullet points in cricket language
3. WIN PROBABILITY IMPACT: Use your tool to calculate before vs after
4. WHAT I EXPECT TO HAPPEN: Your prediction for the next 2-3 overs
5. FALLBACK PLAN: If this doesn't work, then what?

You WILL be challenged by a Devil's Advocate. Prepare your defense.

Agent 4 — 😈 Devil's Advocate (`gemini-2.5-pro`)

Role: Challenges the Strategist's proposal. Instructed to think like Kohli crossed with Ganguly — aggressive, confrontational, never satisfied with the safe option.

You are the Devil's Advocate in the IPL strategy room. Think like Virat Kohli
crossed with Sourav Ganguly — aggressive, confrontational, never satisfied with
the safe option.

The Strategist Captain just proposed: {strategy_proposal}

Your job is to CHALLENGE this decision. You MUST:
1. Identify the BIGGEST RISK in the proposed strategy
2. Propose an ALTERNATIVE decision and explain why it's better
3. Use calculate_win_probability to compare your alternative vs the proposal
4. Point out what the Strategist is IGNORING or underweighting
5. Challenge any assumptions ("you're assuming Bumrah will bowl 2 dot balls,
   but his economy in death overs at THIS venue is 9.2")

RULES:
- You are NOT a yes-man. If the strategy is genuinely excellent, still find
  the strongest possible counter-argument (even if you'd ultimately agree).
- Use cricket language. "The leggie is wasted against a left-handed
  pinch-hitter on a turning pitch in dew" — that's the level of specificity.
- Be specific with numbers. Don't say "he's expensive," say "his economy
  in overs 16-20 this season is 11.3."
- If you genuinely can't find a flaw, say "I'd back this call 9 times
  out of 10, but here's the 1 scenario where it backfires..."

OUTPUT FORMAT:
1. THE CHALLENGE: What's wrong with this call?
2. MY ALTERNATIVE: What I'd do instead
3. THE DATA: Numbers supporting my position
4. RISK ASSESSMENT: What happens if the Strategist is wrong?
5. VERDICT: "STRONGLY DISAGREE" / "DISAGREE" / "RELUCTANTLY AGREE" / "AGREE"

Agent 5 — ⚖️ Judge Agent (`gemini-2.5-flash`) + `exit_loop`

Role: The loop controller. Decides whether the debate has converged enough — or sends it back for another round. Uses ADK's built-in exit_loop tool.

from google.adk.agents import LlmAgent
from google.adk.tools import exit_loop

judge_agent = LlmAgent(
    name="JudgeAgent",
    model="gemini-2.5-flash",
    instruction="""
    You are the neutral Judge in the IPL strategy room.

    The Strategist proposed: {strategy_proposal}
    The Devil's Advocate challenged: {dissent}
    Debate round: {current_round}

    Evaluate:
    1. Did the Strategist address the Devil's Advocate's concerns?
    2. Is there a clear winner in this round?
    3. Has the debate converged on a decision?

    If RESOLVED: Call the exit_loop tool and provide your verdict.
    If NOT RESOLVED: Summarize what remains unresolved and let them debate again.

    Output your verdict to state as judge_verdict.
    """,
    tools=[exit_loop],
    output_key="judge_verdict"
)

Agent 6 — 🪞 Reflection Agent (`gemini-2.5-pro`)

Role: The "third umpire" of the strategy room. Assigns a confidence score, finds blind spots both agents missed, and generates a counterfactual.

You are the Reflection Agent — the final quality gate before any decision leaves
the strategy room. You are the "third umpire" of cricket strategy.

You have the full debate transcript:
- Stats report: {stats_report}
- Conditions report: {conditions_report}
- Strategist's final proposal: {strategy_proposal}
- Devil's Advocate's challenges: {dissent}
- Judge's verdict: {judge_verdict}

Your job is to perform a META-ANALYSIS of the entire decision process:

1. CONFIDENCE SCORE (1-10):
   - 9-10: "No-brainer. Even a club captain gets this right."
   - 7-8: "Strong call. The data and instinct align."
   - 5-6: "Coin-flip territory. Could go either way."
   - 3-4: "Risky. The Devil's Advocate had strong points."
   - 1-2: "Desperate gamble. Pray it works."

2. BLIND SPOT CHECK: What did BOTH the Strategist and Devil's Advocate miss?
   (e.g., "Neither considered that Jadeja hasn't faced left-arm pace in 3
   matches" or "The dew factor was underweighted")

3. COUNTERFACTUAL: "If you'd done [alternative] instead, win probability
   would shift by approximately X%"

4. HISTORICAL PARALLEL: Find one real IPL moment where a similar decision
   was made and what happened.

5. FINAL RECOMMENDATION: Confirm or override the Judge's verdict.
   You can ONLY override if confidence is 3 or below.

OUTPUT FORMAT:
- Confidence: X/10 — "[one-line cricket metaphor]"
- Blind Spots: [bullets]
- Counterfactual: [structured comparison]
- IPL Parallel: [real moment reference]
- Verdict: CONFIRMED / OVERRIDDEN (with reason)

Agent 7 — 🎙️ Match Commentator (`gemini-2.5-flash`)

Role: Translates the internal debate into fan-friendly cricket commentary. Part Harsha Bhogle, part Ravi Shastri.

You are a legendary IPL commentator — part Harsha Bhogle, part Ravi Shastri.
Your audience is cricket fans, NOT data scientists.

You've just witnessed an intense strategy debate:
- The Strategist proposed: {strategy_proposal}
- The Devil's Advocate challenged: {dissent}
- The Judge ruled: {judge_verdict}
- Reflection report: {reflection_report}

Your job is to present the FINAL DECISION as exciting cricket commentary.

FORMAT:
🏏 THE CAPTAIN'S CALL
[One powerful sentence announcing the decision]

📊 WHY THIS MOVE?
[2-3 paragraphs explaining the reasoning in cricket language that a fan
watching at a bar would understand. Use analogies to famous IPL moments.]

😈 THE DISSENTING VOICE
[What the Devil's Advocate argued, presented fairly.]

🎯 CONFIDENCE METER: [X/10]
[How confident is the think tank in this call?]

💡 THE "WHY NOT" EXPLANATION
[Why the alternative was rejected — this is the "why-this-not-that" requirement]

🔮 WHAT TO WATCH
[What should fans look for in the next 2-3 overs to know if this worked]

STYLE RULES:
- Write like you're on-air at the Chinnaswamy at 10 PM with the crowd roaring
- Use cricket metaphors, not ML jargon
- Reference real IPL moments when relevant
- Keep it EXCITING. This is entertainment + strategy.

🔧 Real Tool Integration: Gemini Function Calling

The system uses 5 real tools wired via Gemini function calling inside ADK.

Tool 1 — Win Probability (`tools/win_probability.py`)

A DLS-inspired model that runs inside the Strategist and Devil's Advocate so they can compare their proposals with actual numbers.

def calculate_win_probability(
    current_score: int,
    wickets_lost: int,
    overs_completed: float,
    target: int,
    innings: int
) -> dict:
    """
    Calculates estimated win probability using a simplified DLS-inspired model.
    Called by Strategist + Devil's Advocate to compare tactical options.
    """
    balls_remaining = int((20 - overs_completed) * 6)
    runs_needed = target - current_score

    if innings == 1:
        run_rate = current_score / max(overs_completed, 0.1)
        projected = int(run_rate * 20)
        wicket_factor = max(0.4, 1 - (wickets_lost * 0.08))
        projected = int(projected * wicket_factor)
        return {
            "projected_total": projected,
            "current_run_rate": round(run_rate, 2),
            "assessment": f"Projected total: {projected} at current pace"
        }

    rrr = (runs_needed / balls_remaining) * 6 if balls_remaining > 0 else 99
    wicket_resource = max(0, 1 - (wickets_lost * 0.12))
    over_resource = balls_remaining / 120
    win_prob = min(95, max(5, int(
        (wicket_resource * 50) + (over_resource * 30) +
        ((1 / max(rrr, 0.1)) * 20 * 6)
    )))

    return {
        "win_probability": f"{win_prob}%",
        "runs_needed": runs_needed,
        "balls_remaining": balls_remaining,
        "required_run_rate": round(rrr, 2),
        "assessment": "Above par" if win_prob > 55 else
                      "Tight chase" if win_prob > 40 else "Behind the game"
    }

Tool 2 — Live Weather (`tools/weather.py`)

Live fetch from the OpenMeteo free API — no key required. The Conditions Agent calls this every time to get real-time dew factor.

def get_weather(venue: str) -> dict:
    """Fetches real-time humidity, dew point, and temperature for IPL venues."""
    venue_coords = {
        "Wankhede": (18.9388, 72.8258),
        "Chepauk": (13.0633, 80.2793),
        "Chinnaswamy": (12.9793, 77.5996),
        "Eden Gardens": (22.5645, 88.3433),
    }
    lat, lon = venue_coords.get(venue, (19.076, 72.877))
    url = (
        f"https://api.open-meteo.com/v1/forecast?"
        f"latitude={lat}&longitude={lon}"
        f"&current=temperature_2m,relative_humidity_2m,dew_point_2m,wind_speed_10m"
    )
    response = requests.get(url, timeout=10)
    data = response.json()["current"]

    humidity = data["relative_humidity_2m"]
    dew_likelihood = "HIGH" if humidity > 75 else "MEDIUM" if humidity > 60 else "LOW"

    return {
        "temperature": f"{data['temperature_2m']}°C",
        "humidity": f"{humidity}%",
        "dew_point": f"{data['dew_point_2m']}°C",
        "wind_speed": f"{data['wind_speed_10m']} km/h",
        "dew_likelihood": dew_likelihood,
        "spinner_viability": "POOR" if dew_likelihood == "HIGH" else "GOOD"
    }

⚙️ ADK Orchestration Code (`agent.py`)

This is the full root orchestrator — showing all 3 ADK workflow agent types in use.

from google.adk.agents import SequentialAgent, ParallelAgent, LoopAgent
from .agents.stats_analyst import stats_analyst
from .agents.conditions_agent import conditions_agent
from .agents.strategist_captain import strategist_captain
from .agents.devils_advocate import devils_advocate
from .agents.judge import judge_agent
from .agents.reflection_agent import reflection_agent
from .agents.match_commentator import match_commentator

# Phase 1: Gather intelligence IN PARALLEL (saves time, agents don't block each other)
intelligence_phase = ParallelAgent(
    name="IntelligenceGathering",
    sub_agents=[stats_analyst, conditions_agent]
)

# One round of the debate: Strategist → Devil's Advocate → Judge
debate_round = SequentialAgent(
    name="DebateRound",
    sub_agents=[strategist_captain, devils_advocate, judge_agent]
)

# Wrap debate in a loop — keeps arguing until Judge calls exit_loop
debate_loop = LoopAgent(
    name="StrategyDebate",
    sub_agents=[debate_round],
    max_iterations=5  # Never more than 5 rounds
)

# Phase 3: Reflection — confidence score, blind spots, counterfactuals
reflection_phase = SequentialAgent(
    name="Reflection",
    sub_agents=[reflection_agent]
)

# Phase 4: Fan-friendly output
output_phase = SequentialAgent(
    name="FinalOutput",
    sub_agents=[match_commentator]
)

# The complete orchestrator — all 4 phases in sequence
root_agent = SequentialAgent(
    name="CaptainCool",
    description="IPL Match Strategist — thinks like Dhoni, debates like Kohli",
    sub_agents=[intelligence_phase, debate_loop, reflection_phase, output_phase]
)

Key ADK design choices:

ParallelAgent for Phase 1 — Stats Analyst and Conditions Agent run simultaneously. No reason to wait for weather while stats load.
LoopAgent for the debate — the loop only exits when the Judge calls exit_loop, which it does when the debate genuinely converges. Not on a timer.
output_key on every agent — agents write to named state keys (stats_report, conditions_report, strategy_proposal, dissent) so downstream agents can reference them via {variable} templating.

📊 End-to-End Walkthrough: CSK Chasing 186, Over 15

Scenario Input:

{
  "innings": 2,
  "over": 14,
  "ball": 3,
  "score": "127/4",
  "target": 186,
  "batting_team": "CSK",
  "bowling_team": "MI",
  "striker": "Ravindra Jadeja",
  "non_striker": "MS Dhoni",
  "bowlers_used": {
    "Jasprit Bumrah": 3,
    "Trent Boult": 4,
    "Hardik Pandya": 2
  },
  "pitch": "flat",
  "dew": "heavy",
  "venue": "Wankhede",
  "impact_player_available": true,
  "powerplay_status": "death_overs"
}

Required: 59 off 34 balls. RRR: 10.41.

Phase 1: Intelligence Gathering (Parallel)

Stats Analyst output:

Jadeja vs pace (death overs): SR 148, avg 22 — dangerous on the leg side
Dhoni vs pace (overs 16-20): SR 196, avg 31 — best death batter in history
Bumrah overs 16-20 at Wankhede: economy 6.8, 4 wickets in 12 death overs
Hardik economy in death overs this season: 11.3 — expensive
Boult used all 4 overs, exhausted
Key matchup: Bumrah has dismissed Jadeja 3 times in last 6 meetings

Conditions Agent output (live OpenMeteo data):

Wankhede, 9:45 PM: Temp 29°C, Humidity 83%, Dew Point 26°C
Dew likelihood: HIGH — ball slipping from 15th over onward
Wind: 14 km/h from the sea (towards cow corner)
Spinner viability: POOR — grip heavily compromised
Pitch: Flat, pace on the ball, short boundaries cow corner side

Phase 2: The Debate — Round 1

🧠 Strategist (Round 1):

THE CALL: Use the Impact Player substitution — bring in left-arm seamer Arshdeep Singh in place of Anukul Roy (unused spinner).

REASONING:

Dew at 83% humidity makes spin impossible. Anukul Roy is a liability with a slippery ball.

Jadeja has a weakness against left-arm pace angling across him. Arshdeep exploits this.

Dhoni will anchor — our job is to get Jadeja's wicket cheaply before Dhoni takes over the final 2 overs.

Win prob with current lineup: 38% → with Arshdeep Impact sub: 47%

FALLBACK: If Arshdeep goes for runs, trust Bumrah's last over to defend.

😈 Devil's Advocate (Round 1):

THE CHALLENGE: DISAGREE. You're using your Impact sub in over 15, not the final 4 overs where it matters most.

MY ALTERNATIVE: Bowl Bumrah now (over 15). Save the Impact sub for over 19 — bring in a batting Impact Player (Suryakumar Yadav) if you need a finisher.

THE DATA: Bumrah's economy in overs 16-20 at Wankhede is 6.8. His economy in overs 14-16 is 9.1 — he's actually cheaper in the final stretch. You're burning him early.

VERDICT: STRONGLY DISAGREE

⚖️ Judge (Round 1): NOT RESOLVED — the Devil's Advocate raised a valid point about the Impact sub timing. Strategist must address: is over 15 the right time for the Impact sub, or is over 19 more valuable?

Phase 2: Round 2 — Strategist Revises

🧠 Strategist (Round 2 — revised):

THE CALL: Revised. Bowl Bumrah in over 15. Hold the Impact Player sub until over 18.

CONCESSION: The Devil's Advocate is right about Bumrah's phasing. His best death-over numbers come in overs 17-20. I was misusing him.

REVISED PLAN:

Over 15: Bumrah (targets Jadeja's outside edge)

Over 16: Hardik (take the expensive hit, Dhoni's turn will come)

Over 17: Bumrah

Over 18: Impact sub — Arshdeep IN, Anukul OUT (fresh seamer, left-arm angle)

Win prob revised projection: 52%

😈 Devil's Advocate (Round 2):

VERDICT: RELUCTANTLY AGREE — The revised plan is defensible. I'd have bowled Hardik in 15 and saved Bumrah entirely for 17-18-20, but the difference is marginal (2-3% win prob). The Arshdeep timing is now correct.

⚖️ Judge (Round 2): RESOLVED — Debate converged. Strategist accepted the sub timing correction. Calling exit_loop.

Phase 3: Reflection Agent Output

Confidence: 7/10 — "Bumrah to Jadeja is a known quantity, like Malinga vs Gayle at the 2012 final — you back it, but you're not sleeping easy."

Blind Spots:
- Neither agent discussed the wind direction (towards cow corner). Arshdeep's
  natural swing will go INTO the wind — he may need to adjust his line.
- Dhoni's historic SR vs left-arm pace is 178 — not 196. The Strategist's 
  "Dhoni will anchor" assumption may be too conservative.

Counterfactual: If CSK had saved all of Bumrah's overs for 17-18-19-20,
win probability would have been approximately 55% — 3 points higher. The
early deployment in over 13 cost them some optionality.

IPL Parallel: 2019 IPL Final — CSK chasing, Dhoni promoted himself to
strike in the 18th. Similar situation. He scored 58* off 35 and nearly
won it. The lesson: if Dhoni is on strike in overs 17-20, team wins 70%
of the time regardless of the bowling attack.

Verdict: CONFIRMED

Phase 4: Commentator Final Output

🏏 THE CAPTAIN'S CALL: Bumrah gets the ball for over 15, and the Impact Player card stays in the pocket until Arshdeep walks in at over 18.

📊 WHY THIS MOVE? With the humidity touching 83% at Wankhede tonight, that spinner's finger can't grip the wet cherry — he'd be leaking runs at a rate that would make even the most optimistic CSK fan cover their eyes. Jadeja is dangerous on the on-side but has been dismissed by Bumrah's away-swing three times in their last six meetings. You bring your assassin when the target is in range, and right now, Jadeja is in range.

😈 THE DISSENTING VOICE: The strategy room wasn't unanimous. The Devil's Advocate made a compelling case for holding Bumrah back entirely — his numbers in overs 14-16 are actually worse than his final-over numbers. That argument got heard, and it changed the plan. The original call was to burn the Impact sub in over 15. The revised call — Arshdeep at over 18 — is more surgically timed.

🎯 CONFIDENCE METER: 7/10 — "Bumrah to Jadeja is a known quantity. You back it, but you're not sleeping easy."

💡 THE "WHY NOT" EXPLANATION: Why not use the Impact sub now? Because bringing Arshdeep in at over 18 means you get 3 fresh overs of left-arm swing precisely when the dew peaks — not before. Early subs are wasted subs.

🔮 WHAT TO WATCH: If Jadeja falls in the next 2 overs, game over — Bumrah vs a new batter plus Arshdeep is 90%+ in MI's favour. If Jadeja survives and goes past over 17 without dismissal, we're in a thriller. Watch Dhoni's positioning — if he's backing singles and not attacking, he's setting up a 20th-over assault.

🛠️ Tech Stack (100% Google)

Component	Technology
Core LLM	Gemini 2.5 Pro (Strategist, Devil's Advocate, Reflection)
Fast Agents	Gemini 2.5 Flash (Stats, Conditions, Judge, Commentator)
Agent Framework	Google ADK (`SequentialAgent`, `ParallelAgent`, `LoopAgent`)
Prototyping	Google AI Studio (all 6 prompts iterated here first)
Function Calling	Gemini built-in tool use via ADK
IDE	Google Antigravity
Backend	FastAPI with SSE streaming
Weather	OpenMeteo free API
Frontend	Vanilla HTML/CSS/JS (dark IPL theme)

🏆 What "Dhoni-Level Calm" Means in Code

Dhoni Trait	Architectural Mapping
Never rushes	`LoopAgent` — takes 2-3 rounds before committing
Always two overs ahead	Strategist's "WHAT I EXPECT" + "FALLBACK PLAN"
Trusts data, follows instinct	Stats Analyst feeds data; Strategist can override
Changes plan mid-over	ADK session state allows mid-flow revision
Calm at 50/4	Every scenario gets the same 4-phase structured analysis
The last-ball helicopter shot	Counterfactual: "here's what happens if you DON'T do this"

🔑 Key Lessons from Building This

1. Don't prompt-stuff a single agent. I tried this first — one Gemini call with a long system prompt playing all roles. The output was shallow. When I split it into genuinely separate agents with dedicated roles and competing incentives, the reasoning depth went up dramatically.

2. The Devil's Advocate is the most important agent. Without adversarial pressure, the Strategist just produces the "obvious" answer. The DA is what forces the system to examine its assumptions.

3. ADK's exit_loop + LoopAgent is underrated. Most agents will just run forever or stop arbitrarily. Having the Judge call exit_loop only when the debate genuinely converges means you get variable-length reasoning — quick for easy calls, multi-round for genuinely ambiguous ones.

4. OpenMeteo is a hidden gem. Free, no API key, real-time weather anywhere. The dew factor is genuinely important in IPL — and having it be live data rather than a hardcoded number changes the feel of the entire system.

📁 Project Structure

captain-cool/
├── captain_cool/
│   ├── agent.py                     # Root orchestrator (SequentialAgent)
│   ├── agents/
│   │   ├── stats_analyst.py
│   │   ├── conditions_agent.py
│   │   ├── strategist_captain.py
│   │   ├── devils_advocate.py
│   │   ├── judge.py                 # Controls loop exit
│   │   ├── reflection_agent.py
│   │   └── match_commentator.py
│   ├── tools/
│   │   ├── cricket_stats.py         # fetch_player_stats, fetch_head_to_head
│   │   ├── weather.py               # get_weather (OpenMeteo API — live)
│   │   ├── pitch_report.py          # get_pitch_report (venue database)
│   │   └── win_probability.py       # calculate_win_probability (DLS model)
│   └── data/
│       ├── venues.json
│       └── ipl_players.json
├── frontend/
│   ├── index.html
│   ├── styles.css
│   └── app.js
├── server.py                        # FastAPI + SSE streaming
├── requirements.txt
└── .env                             # GOOGLE_API_KEY (not committed)

🚀 Run It Yourself

git clone https://github.com/tanusree234/captain-cool
cd captain-cool
pip install -r requirements.txt

# Add your Google AI Studio key to .env
echo "GOOGLE_API_KEY=your_key_here" > .env

# Option 1: ADK web interface (shows agent traces)
adk web captain_cool

# Option 2: FastAPI server + frontend
python server.py
# → open http://localhost:8000

Built during the Google Gemini Agent Hackathon. Vibe-coded with Google Antigravity.
GitHub: github.com/tanusree234/captain-cool

DEV Community: Tanusree Roy