Captain Cool — How I built a multi-agent IPL strategist with Gemini & ADK in one sitting

Talib glacier Max — Sun, 17 May 2026 12:36:51 +0000

description: "Five Gemini agents argue with each other about who should bowl the next over. Then they tell you who won the argument."
tags: gemini, agents, ai, cricket

🏏 Cricket is a captain's game. AI is an orchestration game. This is both.

The problem

You're MS Dhoni. Innings 2, over 17.2, MI need 38 off 16 with Suryakumar set on 48 and Tilak Varma at the other end. Dew is heavy. Jadeja has 1 over left. Mustafizur has 1. Pathirana has 2.

What do you do?

There is no clean "right answer" — it's matchup math + pitch read + gut feel + risk appetite, all weighted against the next ball. Real captains decide this in 90 seconds. They confer with the bowling coach, the analyst flashes a sheet, the assistant coach pushes back. Then the captain calls it.

That's the system I wanted to build. Not a chatbot that recites stats. A dressing room — multiple specialised agents that genuinely debate, with the disagreement rendered transparently, before a final call is committed.

This was my submission for the Agentic Premier League by GDG Cloud Pune. Mandatory stack: Google Gemini, ADK, Antigravity, AI Studio. So I leaned in.

Architecture

Five Gemini-powered agents, orchestrated by ADK's SequentialAgent, each writing to shared session state that the next agent reads via prompt template substitution.

        ┌───────────────────────────────────────────────────────┐
        │                Captain Cool (SequentialAgent)         │
        └───────────────────────────────────────────────────────┘
   1. Stats Analyst  (Flash) ──── FunctionTools: lookup_batter,
                                                  lookup_bowler,
                                                  lookup_venue,
                                                  matchup_score
   2. Pitch Reader   (Flash) ──── FunctionTool:  lookup_venue
   3. Strategist     (Pro)   ──── FunctionTool:  win_probability   ← proposes
   4. Devil's Adv.   (Pro)   ──── FunctionTool:  win_probability   ← challenges
   5. Strategist     (Pro)   ──── FunctionTool:  win_probability   ← revises / defends
   6. Commentator    (Flash)                                       ← packages for fans

Why SequentialAgent over a LoopAgent? Because the roles are sequential and named. A captain's debate isn't an unbounded loop — it's a structured exchange: stats → conditions → call → challenge → defend → publish. ADK lets me model that exactly.

Two Strategist invocations sit in the pipeline (StrategistPropose and StrategistRevise) because the same role is asked to do two distinct things — write to different output_keys, with the second reading the dissent before deciding to defend or revise.

The agents (with their actual prompts)

1. Stats Analyst — `gemini-2.5-flash`

You are the Stats Analyst on a virtual IPL captain's bench.
Your job: take the raw match state and produce a factual brief.

Required tool usage:
- For each batter at the crease, call `lookup_batter` once.
- For each bowler with overs remaining, call `lookup_bowler` once.
- Call `lookup_venue` for the ground.
- For the bowler types still available, call `matchup_score` against the striker.

Output format (strict, in this order):
**MATCH SITUATION** — one sentence
**BATTERS** — name, handed, role, SRs vs pace / spin / leg-spin
**BOWLING OPTIONS** — type, overs left, phase economy, who they favour
**VENUE & CONDITIONS** — par score, ground size, dew expectation, pitch behavior
**KEY MATCHUPS** — 2-4 bullets of the most decisive matchups

Be terse. This is a brief, not a column.

The strict output format matters — downstream agents read it via {stats_brief} template substitution, so consistent structure beats verbose prose.

2. Pitch Reader — `gemini-2.5-flash`

Translates pitch / dew / boundary size into actionable "do X, avoid Y" guidance. I want this in voice-of-a-coach, not voice-of-a-model:

"two-paced wicket — stroke-makers will find it hard to time the cut"
"dew is coming in by the 12th over — bowling first will get the harder ball gripping for half the innings"
"60-metre straight boundary — leg-spin into the breeze is asking for trouble"

3. Strategist (Propose) — `gemini-2.5-pro`

The captain. Reads both briefs, calls win_probability, commits a call:

**THE CALL** — one specific sentence (who bowls / who comes in / field setup)
**WHY (cricket talk)** — 3–5 sentences in commentator language
**WIN PROBABILITY** — number from tool call + meaning
**ALTERNATIVE CONSIDERED** — the second-best option ruled out

4. Devil's Advocate — `gemini-2.5-pro`

This is the agent that makes the system agentic — not just a pipeline. Its prompt explicitly says:

"You are NOT here to disagree for the sake of disagreement. You are here to surface the best alternative the Strategist may have under-weighted. If the proposal is genuinely correct, say so plainly and stand it up."

And critically: it calls win_probability on its counterfactual, so its dissent comes with a number, not vibes:

"If we bowl Mustafiz at SKY here, WP drops to 0.62. Save him for the 19th when Hardik's at strike; that climbs back to 0.71."

5. Strategist (Revise) — `gemini-2.5-pro`

Reads the proposal and the dissent. Decides: DEFEND or REVISE. Has explicit guidance against caving and against pride:

"Don't cave to the dissent just because it sounds smart. Don't cling to your call out of pride. This is the difference between an average captain and a great one."

Outputs a CONFIDENCE number 0-100 and a WHY-NOT-THE-ALTERNATIVE line that directly addresses the dissent.

6. Match Commentator — `gemini-2.5-flash`

The explainability layer required by the rubric. Channels Harsha Bhogle's clarity, Ravi Shastri's punch:

"This is captaincy 101. He's saving Bumrah for the 19th. With the lefty at the crease and dew settling in, it's a no-brainer to bring Jadeja in now."

The tools (real function calls, not hardcoded JSON)

Five Python functions wrapped as ADK FunctionTools:

Tool	Used by	Purpose
`lookup_batter`	Stats Analyst	Returns handedness, SR vs pace/spin/leg-spin, role
`lookup_bowler`	Stats Analyst	Returns type, phase economies, vs-left/right averages
`lookup_venue`	Stats Analyst, Pitch Reader	Returns par score, boundary size, dew factor
`matchup_score`	Stats Analyst	Computes batter-vs-bowler-type advantage with handedness adjustment
`win_probability`	Strategist, Devil's Advocate	Heuristic WP model: RRR vs CRR, wickets in hand, dew, pitch

The win_probability calculator is the real unlock for the debate. It's a sigmoid-on-rate-gap model — not perfect calibration, but defensible and consistent. Both Strategist and Devil's Advocate call it on different decisions and compare the deltas. The captain's call now includes a counterfactual: "bowling Pathirana here is WP 0.71; if I'd given Mustafiz the ball instead, it'd drop to 0.62."

Bonus tool: fetch_live_match (BeautifulSoup over Cricbuzz/ESPN HTML) lets the user paste a live URL and pre-fill the form.

The streaming dressing room

One thing I really wanted: the user should see the disagreement, not just the conclusion.

So the FastAPI endpoint /api/decide/stream is a Server-Sent-Events stream. Each ADK event yields one of:

tool_call — small badge appears showing the agent called a function
agent_turn — the agent's final markdown lands as a card
final — structured decision payload renders into the verdict box

The frontend reads the stream with fetch().body.getReader() and appends agent cards as they arrive, with a …thinking ellipsis between turns. It feels like watching a dressing room work in real time.

A walkthrough — the Wankhede scenario

The default scenario in the UI:

Wankhede Stadium · 2nd innings · Over 17.2 · MI 148/4 · target 186 · two-paced pitch · heavy dew
Suryakumar 48(29) on strike · Tilak Varma 22(18) at the non-striker · Jadeja, Mustafizur, Pathirana, Ashwin all have overs left.

What the agents actually say in this run:

Stats Analyst flagged the SKY-vs-leg-spin SR of 145 (high), Tilak's left-hand SR vs off-spin (132 — okay), and Pathirana's death economy of 9.1.

Pitch Reader noted Wankhede is dew-heavy and 64-metre straight — yorker plans favoured, leg-spin into the wind avoided.

Strategist (Propose) called: "Bowl Mustafiz right now. Angle the ball across SKY, who scores 70% of his off-side runs through cover — a left-armer cramps him. Save Pathirana for the 19th." WP: 0.68.

Devil's Advocate pushed back: "With dew this heavy, Mustafiz's grip is gone. Even if he beats SKY twice, the four overs he and Pathirana will bowl combined give up 40+. Bowl Jadeja now while the ball still grips, force a strike change, then attack the new batter." Counterfactual WP for Jadeja-now: 0.71.

Strategist (Revise) verdict: REVISE. "The dissent's right on dew. Jadeja in — left-arm spin into the lefty Tilak is the mismatch we want." Confidence: 78.

Commentator: "Captaincy 101 from the dressing room. They're going Jadeja before the dew makes him useless — Tilak's the soft target, force a strike turn, then Mustafiz for the 18th when SKY's facing again. Smart cricket, this."

That's the system working.

What I'd add next

Memory across overs — Gemini context caching so a full innings of debates costs almost nothing.
Real form pull — Cricbuzz player page scraper feeding into lookup_batter to replace the seed JSON.
Vertex AI Agent Engine hosting — currently runs locally via python run.py.
Multimodal pitch image input — upload a photo of the pitch; Gemini Vision reads cracks/wear.

Try it / clone it

GitHub: <your-repo-here>
AI Studio prompt for the Strategist (Propose): <your-AI-Studio-link>

Built on Google Gemini · ADK · Antigravity · AI Studio · vibed in one sitting.

🏏 Cricket is a captain's game. Built on Gemini.

DEV Community: Talib glacier Max