Blog for APL Pune 2026

Shubham — Sun, 17 May 2026 12:42:43 +0000

🏏 Captain Cool: The Multi-Agent IPL Strategist Built on Gemini
Cricket isn’t just played with a bat and ball; it’s played in the captain’s head. When the match is on the line, the dew is falling, and MS Dhoni is on strike, a single bowling change decides the game.

For this hackathon, I didn't want to build just another chatbot that spits out generic cricket facts. I wanted to build a Virtual Strategy Room.

Enter Captain Cool: a fully interactive, multi-agent AI system built entirely on the Google Gemini stack. It ingests match state, visual pitch data, and historical context to debate the next best move before delivering a final, captain-style tactical decision.

Here is a deep dive into the architecture and how I brought this to life during a frantic vibe-coding session in Google Antigravity.

Link to GitHub Repository - https://github.com/shubhamxpawar/cool-cricket-agent

🛠️ The Tech Stack (Google's House)
Google Antigravity: My primary IDE for the build. The seamless agentic assistance helped me pivot architectures and generate testing scripts autonomously.

Gemini 2.5 Flash: via the @google/genai Node.js SDK. Blazing fast and perfect for chaining agent outputs.

Multimodal Vision: Processing raw images of cricket pitches.

Structured Outputs: Utilizing Gemini's responseSchema (JSON) to guarantee deterministic handoffs between agents.

Interactive CLI: Built with Node readline, formatted beautifully with chalk and ora.

🧠 The Architecture: Four Agents in a Room
The core requirement of this challenge was genuine collaboration. A single LLM call wearing four hats doesn't cut it. My architecture splits the workload into four distinct, highly specialized agents.

The Pitch Inspector (Multimodal Vision)
Before any stats are crunched, we need to know the surface. This agent ingests pitch.jpg using Gemini's native vision capabilities, evaluates the cracks, moisture, or grass, and outputs a one-sentence assessment (e.g., "Dry and cracking, heavy turn expected").
The Stats Analyst (Structured Data)
The Analyst takes the visual pitch data, the current match scenario, and the memory of previous balls.

The Agentic Twist: It doesn't output text. It is constrained via responseSchema to output strict JSON containing a proposedMove and reasoning. This mimics true enterprise Model Context Protocol (MCP) data passing.

The Devil’s Advocate (Counterfactual Risk) Every good captain needs someone to tell them why they are wrong. The Advocate ingests the Analyst's JSON proposal, tears it apart, and calculates a counterfactual.

The Agentic Twist: It is forced to return a JSON payload with a specific winProbabilityDrop metric, highlighting the exact statistical risk of the Analyst's plan.

Captain Cool (The Final Call) The ultimate decision-maker. It reads the Pitch Inspector's visual data, the Analyst's logic, and the Advocate's warnings. It synthesizes this into a single gut call, delivered in pure cricket slang.

🎙️ The Prompts (Google AI Studio)
Before touching the code, I spent time prototyping the distinct personas in Google AI Studio to ensure the Advocate was actually aggressive and the Captain sounded authentic.

Check out the raw system instructions here:

https://aistudio.google.com/app/prompts?state=%7B%22ids%22:%5B%2218psZgnrzMX8sjT4linDQeYGerp_rlI0V%22%5D,%22action%22:%22open%22,%22userId%22:%22107523829563042115214%22,%22resourceKeys%22:%7B%7D%7D&usp=sharing

🔄 End-to-End Walkthrough: The Final Over Drama
To prove the system's "Memory across overs" capability, I ran an interactive CLI session.

The Setup: CSK is batting against MI. 18.2 overs in. 35 runs needed off 16 balls. Heavy dew.

Turn 1:
The Analyst looks at the required run rate (13+ RPO) and suggests firing wide yorkers to prevent boundaries. The Devil's Advocate steps in, warning that pure defense will drop the win probability by 18%, suggesting they hunt for a wicket instead.

Captain Cool's Verdict:

"Right, 35 off 16, they're fancying it. We ain't just going defensive here and hoping they miss. Get our gun death bowler on... mix it up: precise seam-up, the disguised slower ball. We need a breakthrough, a proper wicket, to turn this game around."

Turn 2 (The Memory Loop):
I interacted with the CLI and fed the system the next event: "Bumrah bowls a searing wide yorker, dot ball."

Because the system maintains a running matchHistory context window, the agents instantly adapt. On the very next calculation, the Analyst notes the dot ball has spiked the required run rate, and the Advocate adjusts its risk metric based on the momentum shift. The agents remember the match state, ball by ball.

🚀 Conclusion
Building this was an incredible exercise in orchestration. By leaning into Gemini's Structured JSON schemas, we bypass the hallucination risks of text-to-text agent chains. By adding Vision and a continuous CLI memory loop, the app stops feeling like a chatbot and starts feeling like an actual assistant sitting in the dugout.

Thanks for reading! Check out the GitHub repo to run the Virtual Strategy Room locally.

DEV Community: Shubham

Blog for APL Pune 2026