SportWarren — Rec Football Gets Its Intelligence Layer

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

SportWarren is a tactical command center for recreational football — the 5-a-side, 6-a-side, Sunday league kind that hundreds of millions of people play every week and that has, until now, left absolutely no trace.

You play every week. You score goals. You build chemistry with the same five people over years. And then the final whistle goes and none of it happened. No stats, no record, no reputation. Rec players are invisible.

SportWarren fixes that. Set your formation, put your squad on the pitch, share a challenge link to the group chat — and every matchday becomes verified stats, XP, and permanent squad history. Six attributes per player (pace, shooting, passing, dribbling, defending, physical) that actually evolve with every game. AI coaches that give you tactical banter and real analysis. Group verification via Telegram or WhatsApp so results are confirmed by the people who were there.

But the piece that makes this more than a stats tracker — and the piece that was entirely missing from the hackathon prototype — is the agentic commerce layer. Tactical simulations in SportWarren aren't just animations. They're on-chain economic actions: pay-per-simulation settled via x402 and USDC, running on GOAT Network's Bitcoin-secured infrastructure. An agent that doesn't just analyse your formation but charges for the analysis, settles the payment instantly, and logs it verifiably on-chain.

That's the Kite AI Agentic Commerce track in a sentence: rec football as an entry point into agent-native payments. Unglamorous use case, real economic primitives.

Built in collaboration with @udirobert · Find me on Farcaster · Lens

Demo

🔗 Live app: sportwarren.com

📦 Repo: github.com/udirobert/sportwarren

📱 Telegram bot: t.me/sportwarrenbot

[Add screenshots here: the tactics board, the player card / XP view, and ideally a simulation payment flow]

The Comeback Story

The honest state of SportWarren before the Kite AI hackathon: everything was scattered. The tactics board existed but the challenge flow was broken. The player cards rendered but XP didn't update correctly after matches. The group verification system — the mechanic that makes stats trustworthy, not self-reported — was stubbed out. And the AI layer was a collection of disconnected pieces that didn't form a coherent loop.

Most critically: there was no agentic commerce layer at all. The simulation engine ran locally, produced output, and then nothing. No payment, no settlement, no reason for the simulation to be a product rather than a feature.

The Kite AI Global Hackathon — and the support from GOAT Network's builder grants program — gave this a forcing function. Kite's agentic commerce track is specifically designed for agents that discover, pay, and manage via x402 and programmable constraints settled on-chain. SportWarren turned out to be a natural fit: tactical simulations are discrete, high-value moments where a user genuinely wants an answer, making them a clean unit of commerce. Here's what actually got built and fixed:

The core loop stabilised. Formation setup → challenge link → opponent counter-pick → simulation → result logging → group verification. All five steps now work end-to-end without broken states or dead ends.

XP and player progression wired up correctly. Six attributes now actually update after every logged match. The progression curve — slower at higher levels, volatile early — is tuned to feel like a real career arc rather than a grind.

Group verification shipped. Squadmates can now confirm or dispute a logged result via Telegram or WhatsApp. This is what separates SportWarren from self-reported stat apps: the social layer is the integrity layer.

The agentic simulation engine built. The tactical AI now runs opponent formations against each other, produces a match simulation with probabilities, and delivers a readable breakdown — not just a scoreline but an explanation of why a 4-1 lost to a 1-2-1.

x402 payment integration on GOAT Network. Each simulation is now a payable API call. The agent charges in USDC via x402 protocol, settles on GOAT Network's Bitcoin-secured infrastructure, and logs the transaction with a verifiable on-chain receipt. First call is free; subsequent simulations are paid. The economics are deliberately micro — this is about proving the primitive works, not extracting revenue.

Kite AI agent passport registered. The simulation agent has its own on-chain identity via Kite's agent passport system, making it a first-class participant in the agentic economy rather than a backend function with a webhook.

The project went from a scattered prototype with broken flows to a working app with a genuine on-chain commerce layer. Rec football as a trojan horse for agent-native payments.

My Experience with GitHub Copilot

I used Copilot heavily on SportWarren — both inline autocomplete and Copilot Chat, often switching between them mid-session depending on what the problem needed.

Inline autocomplete earned its keep most on the repetitive but precision-sensitive work: building out the player attribute system, writing the XP calculation logic for different match outcomes, scaffolding the Telegram bot handlers. These are tasks where the pattern is clear but the details matter — getting the attribute deltas wrong would make the progression feel fake, and Copilot's suggestions were consistently close enough that reviewing them was faster than writing from scratch.

Copilot Chat was where the more interesting collaboration happened. The x402 payment integration on GOAT Network was genuinely new territory — x402 is a young protocol and there's limited prior art to draw from. Walking through the payment flow architecture in Chat, getting hypotheses about where the handoff between the simulation agent and the payment settlement should happen, and debugging the cases where a simulation completed but the payment confirmation hadn't propagated yet — that back-and-forth saved meaningful time.

The other place Chat proved its worth was in the verification system design. Group verification sounds simple but has real edge cases: what happens when one player disputes a result the other four confirmed? What's the timeout window? How do you handle a player who never responds? Copilot Chat was useful for thinking through the state machine before writing it, catching the cases I'd glossed over.

Between both modes, Copilot was present in most of the meaningful decisions in this build — not leading them, but keeping pace with them.

Supported by GOAT Network builder grants — Bitcoin-secured infrastructure for the agentic economy.

Find me on Farcaster and Lens — always building at the intersection of AI, emerging markets, and on-chain infrastructure.