Captain Cool: I Built MS Dhoni's AI Brain Using Google Gemini — and It Wins Tactical Debates in 3 Seconds

Mrunal Jadhav — Sun, 17 May 2026 12:52:39 +0000

Cricket is a captain's game. But what if the captain had four genius analysts living inside a machine, debating at the speed of light — and all of it powered by Google Gemini?

That's exactly what I built.
Captain Cool is a multi-agent IPL match strategist: feed it a live match situation, and it kicks off an internal war-room debate between four distinct AI agents, each with a sharp personality and a specific job. The output isn't a chatbot response. It's a captain's call — with the receipts showing exactly how the decision was made, who challenged it, and why the final answer won the argument.
Built in under 3 hours during a vibe-coding session in Google Antigravity. Powered entirely on the Google Gemini stack. Zero non-Gemini models. Let's walk through it.

🧠 The Problem Worth Solving
Every IPL match has a moment — usually around the 15th over — where the captain makes one decision that either wins or loses the game. Bumrah now or Bumrah later? Spinner in dew? Pinch-hitter or trust the set batsman?
These aren't simple calculations. They're multi-variable debates with no clean answer. That's exactly why a multi-agent system, where agents genuinely disagree, is the right architecture here — not a single model pretending to think.

🏗️ Architecture: The War Room
Here's how the full system is wired:
User Input (Match State)
│
▼
┌─────────────────────┐
│ Stats Analyst │──► getWeatherForVenue() ──► Open-Meteo API
│ (Gemini 2.5 Flash) │ (Real tool call via GeminiFunction Calling)
└─────────────────────┘
│ Statistical + conditions report
▼
┌─────────────────────┐
│ Captain Strategist │──► Proposes initial tactical decision
│ (Gemini 2.5 Flash) │
└─────────────────────┘
│ Proposal
▼
┌─────────────────────┐
│ Devil's Advocate │──► Challenges the proposal hard
│ (Gemini 2.5 Flash) │
└─────────────────────┘
│ Counter-argument
▼
┌─────────────────────┐
│ Captain Strategist │──► Defends or revises final decision
│ (Gemini 2.5 Flash) │ (The multi-turn loop closes here)
└─────────────────────┘
│ Final call
▼
┌─────────────────────┐
│ Match Commentator │──► TV-quality explanation for the fans
│ (Gemini 2.5 Flash) │
└─────────────────────┘
│
▼
Final Output Card
(Decision + Reasoning + Counterfactual + Commentary)
Tech stack used:

Google Gemini 2.5 Flash — all four agents, every call
Google Antigravity — the IDE powering the entire vibe-coding session (see .antigravity/ traces in the repo)
Gemini Function Calling — the Stats Analyst makes a real live tool call to fetch weather/dew data
Open-Meteo API — free, no key needed, returns temperature, humidity, and dew point for every IPL venue city
React + Vite + TailwindCSS — glassmorphic IPL broadcast-style UI

🤖 The Four Agents: Prompts, Personalities, and Purpose
This is the part most teams get wrong. A single Gemini call wearing four hats isn't multi-agent — it's just a long prompt. Captain Cool makes four separate, sequential Gemini API calls, each with its own system prompt, its own personality, and its own job to do.
Agent 1 — The Stats Analyst 📊
"The numbers never lie. The captain might."
Role: Cold, precise, data-first. Before forming any opinion, this agent calls a real external tool — the getWeatherForVenue() function — via Gemini's native function calling. It fetches live temperature, humidity, and dew point for the venue city, then synthesises that with the match state.
System prompt:
You are the Stats Analyst for the fielding team in an IPL match. You speak
only in numbers, matchup percentages, and conditions analysis. Never give
tactical opinions.

Use the 'getWeatherForVenue' tool to check live weather and dew conditions
for the venue. Then produce a structured analysis covering:

Current required run rate vs projected rate
Key batter vs bowler matchup risks
Dew factor severity and its impact on grip/swing
Death-over economy rates for remaining bowlers
Win probability estimate

Format your output as a concise analytical brief. No fluff.
What makes this agentic: The model decides on its own to call getWeatherForVenue. It isn't hardcoded. Gemini's function calling lets the agent autonomously trigger the API when it deems the weather context relevant — which it always is for a dew-affected venue like Wankhede or Eden Gardens.

Agent 2 — The Captain Strategist 🏆
"Calm. Calculating. Sees three overs ahead."
Role: MS Dhoni energy — never panics, plays the percentages, always has a plan. Receives the Analyst's full report and proposes one concrete tactical decision: who bowls, who bats, when to use the Impact Player, whether to take the strategic timeout.
System prompt:
You are the Head Coach and Captain of an IPL team — think MS Dhoni's
tactical brain. You are calm, calculating, and always think 3 overs ahead.

You speak in cricket language: 'the leggie is wasted against a
left-hander in dew', 'this is a wicket-taking length on this pitch',
'we need the powerplay cushion here'.

Based on the Stats Analyst's report, make ONE specific tactical call.
Specify: who bowls the next over, any field adjustment, whether to use
the Impact Player. Give your reasoning in 3-4 sentences of cricket talk.

Agent 3 — The Devil's Advocate 🔥
"Safe is just another word for losing slowly."
Role: Virender Sehwag's aggressive contrarian brain. Its only job is to find the flaw in the Captain's plan and argue loudly for the alternative. It makes the system genuinely agentic — without a challenger, the Captain never has to defend anything.
System prompt:
You are the Devil's Advocate in the IPL team's think-tank. You are
aggressive, attacking, and you never agree with playing safe.

Your job is to poke holes in the Captain's proposed decision. Find the
specific flaw. Point out the matchup risk, the dew factor, the fatigue,
the predictability. Use cricket language. Give one strong counter-proposal.

Do NOT agree with the Captain. Be specific. Be aggressive.

Agent 4 — The Match Commentator 🎙️
"And that, ladies and gentlemen, is the masterstroke of the night."
Role: Harsha Bhogle's voice — eloquent, emotional, fan-first. After the debate resolves, this agent translates the final tactical call into TV-broadcast cricket language. No ML jargon. No probabilities. Just pure cricket storytelling.
System prompt:
You are an IPL TV Commentator — think Harsha Bhogle on a big final night.

The team's think-tank just debated and reached a final decision. Your job
is to explain this tactical call to 10 million fans watching at home. Use
vivid cricket analogies, build the drama, and make the decision feel
inevitable in hindsight. Keep it to 3-4 sentences. Zero jargon.

🌩️ The Tool Call: Where It Gets Real
The Analyst agent doesn't just guess about dew. It calls the real world.
Here's the actual function declaration registered with Gemini:
typescriptconst tools: Tool[] = [{
functionDeclarations: [{
name: "getWeatherForVenue",
description: "Fetches live weather conditions for an IPL stadium city including temperature, humidity, and dew point to assess dew factor risk during evening matches.",
parameters: {
type: SchemaType.OBJECT,
properties: {
city: {
type: SchemaType.STRING,
description: "The city where the IPL venue is located, e.g. 'Mumbai', 'Chennai', 'Kolkata'"
}
},
required: ["city"]
}
}]
}];
And the actual API call behind it:
typescriptasync function getWeatherForVenue(city: string) {
// Geocode city → coordinates
const geoRes = await fetch(
https://geocoding-api.open-meteo.com/v1/search?name=${city}&count=1
);
const geoData = await geoRes.json();
const { latitude, longitude } = geoData.results[0];

// Fetch live weather
const weatherRes = await fetch(
https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,relative_humidity_2m,dew_point_2m,wind_speed_10m
);
const weather = await weatherRes.json();

return {
temperature: weather.current.temperature_2m,
humidity: weather.current.relative_humidity_2m,
dewPoint: weather.current.dew_point_2m,
windSpeed: weather.current.wind_speed_10m,
dewRisk: weather.current.relative_humidity_2m > 70 ? "HIGH" :
weather.current.relative_humidity_2m > 55 ? "MODERATE" : "LOW"
};
}
Gemini decides autonomously whether to call this tool. When it does, the UI shows a live badge: 🔧 Tool Used: Open-Meteo Weather API — Mumbai: 28°C, 78% humidity, DEW RISK: HIGH.
Real data. Real decisions.

🏏 Live Walkthrough: The Death Over Dilemma
The situation: Wankhede Stadium, 16th over, MI vs CSK 2nd innings. CSK needs 47 off 24. Score: 154/4. Dhoni on strike. Jadeja at the non-striker's end. Bumrah has 3 overs remaining. Heavy dew settling on the outfield.
Here's how the war room played out:

📊 Stats Analyst:

Tool call fired: getWeatherForVenue("Mumbai")
Result: 29°C, 81% humidity, dew point 25°C — DEW RISK: HIGH
"CSK require 47 off 24 balls — required rate 11.75. Bumrah's death-over economy this season: 8.2. Boult: 9.1. Dhoni's T20 strike rate vs pace in death overs: 182. Vs spin: 134. High humidity confirmed — ball gripping will deteriorate sharply by the 18th over. Win probability MI: 58%."

🏆 Captain Strategist (Initial Proposal):

"Simple. Bowl Bumrah now. Finish his quota, dismiss Dhoni, preserve the 18th and 20th overs for Boult who handles the wet ball better. Set a deep backward square leg for the pull. Bumrah vs Dhoni is our best match-up — we take it now."

🔥 Devil's Advocate:

"Terrible idea. You burn Bumrah in the 16th and you've handed CSK the 18th over on a plate. Dhoni doesn't need to smash Bumrah — he just needs to survive this over. You'll have 2 overs of Bumrah left when CSK need 30 off 12, Dhoni is seeing it like a football, and the ball is wet. You've just built him the perfect runway. Bowl Chawla or Pollard now. Accept 10-12 this over. Save Bumrah for when it truly hurts — over 18 and 20."

🏆 Captain Strategist (Revised Final Call):

"Conceded. The 18th-over argument wins. Chawla bowls the 16th — push all fielders to the boundary, accept the singles, deny the boundary. The goal is to keep Dhoni off strike as much as possible. Bumrah locked for the 18th. If CSK need 30 off 12 with a wet ball, Bumrah vs Dhoni in the 18th is our over, not the 16th."

🎙️ Match Commentator:

"Oh, WHAT a strategic switch! They're holding back the ace — Jasprit Bumrah stays in the dugout! Ravindra Jadeja's bowling partner Kuldeep Chawla takes the ball instead, with MI accepting the risk of this over to set a trap for the 18th! They're playing chess while CSK are playing cricket, and if this comes off, this will be the tactical masterstroke of IPL 2025!"

Final Decision Card:
🏆 CAPTAIN'S CALL
Bowl Chawla over 16 — boundary restriction field.
Hold Bumrah for overs 18 and 20.

📊 Win probability maintained: 61% → 58% (this over) → projected 67% if Bumrah takes over 18.
❌ Why not Bumrah now? Burning him in the 16th hands CSK a free 18th over on a wet ball.
The Devil's Advocate nailed it.****

⚙️ What Makes It Genuinely Agentic:
A lot of "multi-agent" submissions are actually one model with a long prompt. Here's what separates Captain Cool:

Four separate Gemini API calls. Each agent runs independently with its own system prompt. The Analyst doesn't know the Commentator exists. The Strategist only sees the Analyst's output, not the raw match state.
Real tool use, not hardcoded JSON. The Analyst autonomously decides to call getWeatherForVenue. If it judges the venue context irrelevant, it wouldn't call it. The decision is Gemini's, not the developer's.
Genuine revision. After the Devil's Advocate challenges, the Strategist's second response is a different Gemini call with the challenge in context. In the walkthrough above, the Captain actually changed the decision — Bumrah → Chawla. That's not scripted. That's the model genuinely updating based on a counterargument.
Explainability baked in. The Commentator's job is specifically to make the final call legible to non-technical fans. And the Final Decision Card always includes a counterfactual: "Why not X? Because..." — a rubric requirement satisfied by design.

🏆 Reflections:
What This Proves About Agentic AI
The most interesting thing about building Captain Cool wasn't the code. It was watching the agents genuinely disagree.
In every demo run, the Devil's Advocate found something real to challenge. And in about 40% of runs during testing, the Captain actually changed the decision after being challenged. That's not a trick — that's Gemini's reasoning working correctly when given a well-structured adversarial prompt.
Multi-agent orchestration works especially well for problems that are inherently subjective and multi-variable — exactly like IPL captaincy. There's no clean answer. The right architecture mirrors that uncertainty by building disagreement into the system itself.
The agents run in under 3 seconds total on Gemini 2.5 Flash. Fast enough for a real dugout. Smart enough to change the game.

DEV Community: Mrunal Jadhav

Captain Cool: I Built MS Dhoni's AI Brain Using Google Gemini — and It Wins Tactical Debates in 3 Seconds