🏏 Captain Cool — AI That Thinks Like an IPL Captain

What happens when you combine cricket strategy, multi-agent reasoning, and the Google Gemini ecosystem in a 3-hour hackathon sprint?

You get Captain Cool — an AI-powered IPL match strategist where multiple Gemini agents debate tactical cricket decisions like a real dressing room before making the final captain’s call.

Instead of building a generic chatbot with cricket terminology sprinkled on top, we wanted to simulate something much closer to a real IPL strategy room:

• analysts studying matchups,


• captains balancing risk,


• assistant coaches challenging decisions,


• and commentators explaining the logic to fans.

Built entirely on the Google AI ecosystem, Captain Cool became our attempt at turning agentic AI into a tactical cricket brain.

⚡ The Core Idea

During an IPL match, captains constantly make micro-decisions:

• Who bowls the next over?


• Should the spinner continue despite dew?


• Is it the right moment for the Impact Player?


• Do we attack or delay Bumrah’s final over?


• Which field setup reduces boundary probability?

Captain Cool processes the live match state and lets multiple AI agents argue over the best tactical decision before producing a final recommendation.

The result feels surprisingly close to a real cricket strategy meeting.

🧠 Multi-Agent Architecture

Instead of relying on a single prompt, we decomposed the system into specialized Gemini-powered agents.

🕵️ Match Analyst Agent

Responsible for:

• venue conditions


• batter vs bowler matchups


• dew impact


• phase analysis


• tactical statistics

This agent also performs tool execution to fetch structured cricket insights.

💡 Strategist Agent

The “captain brain” of the system.

Inspired by tactical IPL leadership styles, this agent:

• proposes bowling changes,


• plans death overs,


• controls field aggression,


• and balances risk vs reward.

🔥 Devil’s Advocate Agent

This became the most interesting part of the project.

Its sole responsibility:

challenge the strategist.

Example:

“If we use Bumrah now, who controls the 19th over against Tim David?”

This created genuine multi-agent reasoning instead of fake roleplay.

🎙️ Commentator Agent

The final layer converts raw AI logic into human cricket language.

Instead of:

“Probability optimization suggests pace utilization.”

The system explains:

“The pitch is gripping slightly, so bowling pace-off cutters into the surface makes more tactical sense than feeding spin into the arc.”

This dramatically improved explainability.

🔄 The Agentic Debate Loop

Our orchestration flow:

Match State

    ↓

Analyst Agent

    ↓

Strategist Proposal

    ↓

Devil’s Advocate Critique

    ↓

Strategist Revision

    ↓

Commentator Explanation

    ↓

Final Captain's Call

The important part:

the disagreement is visible.

We intentionally expose the internal tactical debate instead of hiding the reasoning.

🧩 Full Runtime Architecture

[ User Inputs Live Match State via Streamlit UI ]

                              │

                              ▼

               [ app.py parses to Pydantic Schema ]

                              │

                              ▼

              ┌──────────────────────────────┐

              │      agents.py Orchestrator  │

              └───────────────┬──────────────┘

                              │

         ┌────────────────────┼────────────────────┐

         ▼                    ▼                    ▼

┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐

│  Match Analyst   │  │    Strategist    │  │ Devil's Advocate │

│  (Gemini Flash)  │  │  (Gemini Flash)  │  │  (Gemini Flash)  │

└────────┬─────────┘  └────────┬─────────┘  └────────┬─────────┘

         │                     │                     │

         ▼                     │                     │

[ NATIVE TOOL CALL ]           │                     │

 (get_matchup_stats)           │                     │

         │                     │                     │

         └──────────────► Multi-Turn Loop ───────────┘

                               │

                               ▼

                    [ Ultimate Captain Decree ]

                               │

                               ▼

                 [ Rendered via Streamlit Chat ]

This architecture became the backbone of the project.

Instead of a single LLM generating tactical responses, the orchestrator coordinates multiple Gemini-powered specialist agents that challenge, refine, and evolve the decision before presenting the final tactical recommendation.

The visible disagreement between agents transformed the experience from “AI answering questions” into a realistic cricket strategy war-room.

🛠️ Tech Stack

AI & Agent Layer

• Google Gemini API


• 
  google-genai SDK


• Multi-agent orchestration inspired by Google ADK


• Gemini function/tool calling

Backend

• Python


• FastAPI


• Pydantic

Frontend

• Streamlit dashboard


• Custom dark-mode tactical UI

Development Workflow

• Built using Google Antigravity


• AI-assisted vibe coding


• Autonomous file scaffolding and iteration

🏏 Example Match Scenario

We tested Captain Cool using a pressure scenario:

Match Situation

• RCB vs PBKS


• 150/2 after 14.2 overs


• Virat Kohli on strike


• Yuzvendra Chahal bowling


• Heavy dew expected later

📊 Analyst Insight

The Match Analyst agent triggered native tool execution and identified:

• Kohli performs strongly against traditional spin,


• but his scoring rate drops against googly-heavy leg-spin variations on slower surfaces.

🧠 Internal Debate

Strategist

“Attack with leg-spin now before the dew settles in.”

Devil’s Advocate

“Risky. If Kohli survives the first six balls, the short boundary becomes a major issue.”

Strategist Revision

“Fair. We hold the spinner back for one over and use hard-length pace into the surface first.”

🏆 Final Captain’s Call

“Bring back the pace bowler from the Pavilion End. Use cross-seam hard lengths into the pitch and protect square boundaries. Delay spin until the new batter arrives.”

⚡ Biggest Learnings

The most interesting realization from this build:

Multi-agent systems feel dramatically more intelligent when disagreement is visible.

The Devil’s Advocate agent consistently improved decisions by forcing counterfactual thinking.

Instead of:

“one smart AI”

the project started feeling like:

“a real strategy room.”

📸 Screenshots

Streamlit Tactical Dashboard

(Add your UI screenshot here)

Antigravity Development Workflow

(Add your Antigravity + code screenshot here)

Multi-Agent Debate Output

(Add your debate screenshot here)

🚀 Future Improvements

If we continue developing Captain Cool, the next additions would be:

• Live Cricbuzz/ESPN integration


• Real-time win probability engine


• Voice commentary using Gemini Live API


• Memory across overs


• Multimodal pitch image analysis


• Full Google ADK orchestration

📂 GitHub Repository

👉 https://github.com/So-rush/captain-cool

🏏 Final Thoughts

Cricket is ultimately a captain’s game.

Captain Cool was our attempt to explore what happens when tactical sports intelligence meets agentic AI reasoning inside the Google Gemini ecosystem.

And honestly…

watching AI agents argue about death-over bowling plans was way more fun than expected. 🏆