Closes in --

Running on a synthetic match, right now

Every call comes with its evidence.

AI agents commentate a live football match. Before any line goes to air, a Critic agent checks it against the raw match events. If a claim can't be proven, it's rewritten or dropped.

The 110-second demo video is coming soon.

Submissions close in --

    A real exchange from synthetic match seed 7. Switch to the first draft to see what the Critic caught.

    The whole story, chapter by chapter

      AI football commentary that shows its working

      watches a football match and commentates on it, like a broadcaster would. The difference: before any line goes on air, a second AI checks every fact in it against what actually happened on the pitch. If a claim can't be proven, it doesn't air.

      What it does

      As a match plays, one AI spots the moments that matter: a goal, a big chance, a team taking control. Another writes the line a commentator would say. A third, the Critic, checks the line against the match's raw events. It recounts the passes, re-measures the distances, checks that every event cited had actually happened yet. Only then does the line reach the screen, with its evidence attached and a receipt showing what it cost.

      Why I built it

      AI writes fluent sentences, and fluent isn't the same as true. In sport, a wrong number on air costs the broadcaster the viewer's trust. I wanted commentary you can audit: every claim traceable to the moment it describes, and a system honest enough to say "I can't prove that" instead of making it up. If a model fails mid-match, the broadcast keeps going and says so.

      The hackathon

      is my entry to Inside the Game: Developer Hackathon, run by Microsoft with the Premier League from October 6 to 27, 2026. Developers around the world build AI that turns football-realistic, synthetic match data into insight, commentary and recaps, using Microsoft's AI and cloud tools. Judging runs to November 10, and winners are announced on November 20.

      Every club, player and match here is invented, as the rules require. is an independent entry: it isn't affiliated with or endorsed by Microsoft or the Premier League.

      Try it

      Watch a synthetic match in the studio. The Critic's refusals appear on screen as they happen, and one button takes the commentator off air so you can watch the broadcast recover.

      Official links

      AI can talk about football. It can't prove what it says.

      Language models write fluent commentary in seconds. They also invent numbers, mix up minutes and cite moments that haven't happened yet. On a live broadcast, a wrong line reaches every viewer before anyone can check it.

      A first draft from the Narrator in this repo, written during synthetic match seed 7. It reads well. One of the events it cites hadn't happened yet.

      Confident and unchecked

      A model sounds just as sure when it's wrong. Without a check between the draft and the screen, every error goes out live.

      One feed for every fan

      An analyst wants expected goals and pressing patterns. A casual viewer wants to know why the crowd just roared. Most feeds serve one and lose the other.

      English first, everyone else later

      The game is watched around the world, but live commentary is mostly written in English. Urdu and Arabic speakers usually get a translation, not commentary written for them.

      When the model stalls, the feed goes dark

      A live system that waits on one slow or failed model call goes quiet at exactly the moment the match needs it.

      We set out to win every category. The rules allow two.

      The original plan was to win all six awards of the Inside the Game hackathon together. The official rules let one project take at most one grand prize and one category prize, so this is the goal we hold ourselves to: first place overall, and Best Use of Microsoft Foundry. Every other category is still built to its full standard, because that is what first place takes.

      Submissions close in

      --

      1. Grand prize: first place

        Every lane below, in one match, end to end, live in the studio for anyone to try.

        Our target
      2. Best use of Microsoft Foundry

        Models on Foundry write the commentary from facts code computed, and the Critic checks every number. Evaluation chose which model serves, by a rule fixed before the run. Keys are off; Entra ID only.

        Our target
      3. Best multi-agent orchestration

        Five agents with typed handoffs and shared match state. Take the narrator off air mid-match and the broadcast keeps going, and says so.

        Live
      4. Best enterprise solution

        An audit trail on Azure Cosmos DB for every claim, refusal and cue, a receipt on every line, traces in Application Insights, and costs held under a $100 ceiling.

        Live
      5. Best Azure cloud-native integration

        The studio runs on Azure Container Apps from one image, signing in with its own managed identity and no keys, with every agent step traced.

        Live

      The sixth award, second place overall, is the same build.

      Ten days, six phases

      1. GroundworkThe field studied, the name chosen, a synthetic match generator calibrated over 100 seeds.
      2. SkeletonAll five agents run a match end to end with offline backends, tested on every push.
      3. Core buildLive detection, the Critic's full rulebook, the overlay cue stream, analyst and casual modes.
      4. DifferentiatorsThe on-camera recovery demo and the cost meter are live; Urdu and Arabic, and automated recaps, come next.
      5. Ship kitThe 110-second video, the README, the repo made public.
      6. SubmitA day early, never on deadline day.

      We promised to show the core loop end to end by October 24, or narrow this declaration in public. It ran end to end, live on Azure, on October 18.

      Beyond the hackathon The road to an AI fourth official

      How a claim gets on air

      Every event takes the hot path: fast, deterministic, no language model. Each alert then takes the warm path, where one agent writes, another checks, and nothing airs until it passes.

      alert claim verified rejected: rewrite Hot path: every event Warm path: one run per alert Match eventssynthetic stream Scoutdetects, no LLM Narratordrafts and cites Criticrecomputes, rules LocalizerEN, UR or AR Overlay cuesto the broadcast Orchestratorsupervises the line: retries once, falls back to detection-only cues, announces recovery
      The five agents. Events stream through the Scout; each alert goes from the Narrator to the Critic, back for a rewrite if it fails, and on to the Localizer when it passes. The Orchestrator supervises the whole line.

      One claim, followed all the way

      The claim from the front page, through each step of synthetic match seed 7.

      1. Spot

        The Scout reads every event as it arrives and flags goals, big chances, great passes and swings in momentum.

      2. Write

        The Narrator drafts the line for air from a sheet of facts code computed, and cites the event behind every one. On Azure, a model in Microsoft Foundry writes it: gpt-4.1-mini, chosen by evaluation.

      3. Check

        The Critic recomputes each number from the raw events, with the same formulas the Scout uses. A wrong number, a missing citation or an event from the future sends the claim back, up to three attempts.

      4. Air

        The Localizer turns the verified claim into an on-screen cue for casual fans or analysts, in English, Urdu or Arabic, with its player tags and a receipt of what was checked and what it cost. A claim that never passes never airs. .

      When an agent fails, the broadcast keeps going

      The Orchestrator supervises the line. If the Narrator or Critic stops responding, it retries once. If the agent is still down, viewers get detection-only cues, marked as unverified, and the broadcast says when full service is back.

      The cue stream through a failure: full service, then detection-only cues while the Narrator is down, then recovery. The line never breaks.
      1. Full serviceEvery cue verified by the Critic
      2. Detection onlyCues keep airing, marked unverified
      3. RecoveredAnnounced on air, verification resumes

      A test knocks the Narrator out four times in a row mid-match and checks that the cues never stop. In the studio you can do it yourself: mid-match, and put it back.

      Synthetic by design

      Every match is generated from a seed: invented clubs, invented players and realistic volumes, about a thousand passes, 29 shots and three goals a match on average. The same seed always replays the same match, so every claim on this site can be reproduced.

      Every shot in synthetic match seed 7. Bigger circles are better chances; filled circles are goals.

      Replay this match yourself:

      python -m court run --seed 7

      Trust is the product

      A model can already write commentary. The open question is whether anyone can rely on it, live, with millions watching. is built around that question.

      “We will see whether you have told the truth.”

      1. Nothing unverified goes to air

        Broadcasters answer for every word on screen. Each claim carries its own audit trail: the events behind it, the check it passed and the attempt it took.

      2. The model writes, the evidence decides

        We don't ask the model to be careful. We check its work with the same formulas the Scout uses, and refuse anything that doesn't add up.

      3. Commentary in the fan's own language

        Urdu and Arabic are live beside English. The verified line is translated under the same law: no number it doesn't state, no name changed. Every fixed word was reviewed and signed off before it shipped.

      4. Failure is designed in

        Models will be slow, rate-limited or down mid-match. The system degrades, says so on air and recovers, instead of falling silent.

      5. Built in the open

        The goals are declared on this site before the deadline, and the code goes public with the entry. Judge the work against the promise.

      What runs today, and what's next

      Built in the open, one tested commit at a time. Everything under “Live” runs today, on synthetic matches.

      One match, start to finish
      Match
      Synthetic, seed 21, 2-2
      Written by
      gpt-4.1-mini on Microsoft Foundry
      Alerts
      9
      Cues on air
      9, every one verified
      Numbers not computed by code
      0 aired
      Model calls
      9
      Tokens
      3,685 in, 380 out
      Backup model needed
      No
      Model cost
      $0.0021

      October 18, 2026. Cost is estimated from token counts at list prices; Azure Cost Management has the actual bill.

      Live

      1. Urdu and Arabic

        The studio speaks Urdu and Arabic as well as English. The verified line is translated, and the translation is held to the same law: it may state no number the checked line doesn't, and every name stays as written. If it breaks either, the English line airs instead. I reviewed the wording myself and signed it off.

      2. Pass quality, speed and player tags

        A great pass is now a moment of its own, with its distance, difficulty and accuracy; a fast shot says how fast. Every number is recomputed by the Critic from the match. Each cue tags its players, with badges when a shot passes 110 km/h or a pass is long or hard.

      3. The Critic, for any assistant

        The Critic is an MCP server: GitHub Copilot, or any assistant that speaks the Model Context Protocol, can read a match and put a claim to the same Critic that guards the broadcast. An assistant can't vouch for its own numbers: each must be recomputed from the match or carried by an event it cites.

      4. The studio, live on Azure

        Watch a synthetic match narrated live, with every cue's receipt and the Critic's refusals on screen. Take the narrator off air and watch the broadcast keep going. It runs on Azure Container Apps with its own identity and no keys, open through the judging period. .

      5. The models competed for the job

        gpt-5-mini and gpt-4.1-mini narrated the same 50 alerts from five unseen matches, judged by a rule fixed before the run. Both were grounded every time, with no invented numbers. gpt-4.1-mini put a cue on air in 1.3 seconds against 3.7, at a third of the cost, so it writes the commentary now.

      6. A receipt on every cue

        Every line on air carries its receipt: who wrote it, how many numbers the Critic checked, how many facts it recomputed from the match, the events cited, the time from alert to air, and the tokens and cost.

      7. The control room

        Every agent's work traced into Application Insights, with keys off: each alert's outcome and the Critic's reasons, every model call with its tokens. A workbook charts it, and the demo video walks through it.

      8. Every output kept

        Each match's cues, the claims the Critic refused with its reasons, and the model cost go to an audit trail on Azure Cosmos DB's free tier. The writes run in the background, so a slow store can't delay a cue.

      9. Commentary written on Microsoft Foundry

        gpt-4.1-mini writes each line from a fact sheet that code prepared, and gpt-5-mini takes over if it fails. There are no keys: access is through Microsoft Entra ID only.

      10. The Critic checks every number

        If a line states a number that code didn't compute, the Critic refuses it and sends it back to the model with its reasons.

      11. Momentum calls on air

        A momentum claim must cite at least three of the side's own shots or passes into the final third, all from inside the spell it describes.

      12. Recovery, proven by a real fault

        When model access failed during a test run, the broadcast switched to detection-only cues and said so on air, instead of going silent.

      13. Momentum measured against the truth

        Each synthetic match hides the real momentum swings. The Scout makes few, sure calls: on matches never used for tuning, 62% of its calls are right, and it catches about a quarter of the swings.

      14. A synthetic match generator

        Invented clubs and players, real-match volumes, calibrated over 100 seeds. The same seed gives the same match every time.

      Next

      1. Next
        What this data can't tell you

        The system's limits stated plainly, on this site and in the app.

      Considered, for later

      1. Later
        Match analytics on Microsoft Fabric

        The audit trail mirrored into OneLake, so every match can be queried in SQL and charted in Power BI. I weighed it for the hackathon and kept the build to Cosmos DB's free tier. It's the route the analytics will take as grows.

      Onwards & upwards

      The hackathon is stage one. keeps going after it, toward an AI fourth official that sits beside the referee team.

      The north star: the fourth official

      An official that watches every moment and judges calls in a blink, at the strictness the competition chooses. It shows the evidence for every decision and explains it to the referee, the broadcast and the crowd, each in their own language. It advises. The human referee decides.

      1. In progress

        The court of claims

        Commentary that proves every claim. Five agents, a Critic that refuses what it can't verify, and a broadcast that survives failure.

        Bridge: a “Ref's call” cue, if time allows. The Scout flags a foul, the Narrator states the likely decision, the Critic checks it at a chosen strictness.

      2. Next

        The decision explainer

        When the referee makes a call, explains it to the crowd and the viewers, with the evidence and the Law it rests on, in their language.

        Gate: agreement with ground-truth decisions measured over many seeds, and explanations signed off by a referee panel.

      3. Planned

        Perception

        The Scout gets eyes: fouls classified from multiple camera angles and from player tracking, with every prediction citing its frames.

        Gate: matching published results on a public benchmark, with evidence attached to every call.

      4. North star

        The fourth official

        Real-time advice to the referee team, faster than a video review takes today. Flashpoint predictions, a published strictness spectrum, and announcements the whole stadium understands.

        Path: simulation and esports first, then grassroots football, then professional trials inside the game's own rules.

      What holds at every stage

      ہدہد

      hudhud, the hoopoe, in Urdu, Persian and Arabic

      Named for the messenger who came back with proof

      is the hoopoe's name. The bird carries news through some of the oldest stories in those languages, and in the best known, no one acts on its news until it has been checked.

      The mark: a hoopoe's crest of five feathers, one for each agent, with the Critic at the centre.

      Sure news

      The Quran, Surah An-Naml 27:20–28

      King Solomon notices the hoopoe is missing and demands a clear reason for its absence. It returns from Sheba with news it calls certain. Solomon doesn't take its word for it.

      بِنَبَإٍ يَقِينٍ

      “With sure news.” 27:22

      سَنَنظُرُ أَصَدَقْتَ أَمْ كُنتَ مِنَ الْكَاذِبِينَ

      “We will see whether you have told the truth, or are one of the liars.” 27:27

      He tests the report before he acts on it. That is the Critic's job: no claim reaches the screen until it has been checked against the match events. The hoopoe reported to a court, and so do the agents, which is why the code is called court.

      The guide

      Farid ud-Din Attar, The Conference of the Birds, 12th century

      In Attar's Persian poem the hoopoe, once Solomon's messenger, leads the birds of the world in search of the Simurgh, their king. Thirty survive the journey and discover that si murgh means “thirty birds”: together, they are what they were looking for. The agents work the same way. None of them sees the whole match, together they do, and the Orchestrator leads.

      Heads-up display

      Broadcast English

      A HUD is a heads-up display, the layer of graphics over a live picture. That's what makes: verified cues, timed to the match and ready to overlay.

      Five feathers

      The mark

      The hoopoe's crest fans open like a broadcast signal, and the mark gives it one feather per agent. The name says itself twice, hud-hud, two beats like a chant from the stands. Written short, it's : the display, squared.

      Every culture has a messenger that brings back the truth. Odin's ravens, Huginn and Muninn, fly over the world each day and report what they saw. Noah's dove returns with an olive leaf, proof in its beak that the flood is going down. Hermes carries the Greek gods' messages on winged sandals. In Urdu, Persian and Arabic, the messenger is the hudhud.

      Built by one engineer, from Karachi

      Muhammad Abdullah Tariq

      Principal Software Engineer (DevOps), CISSP. Karachi, Pakistan.

      I've spent seven years on cloud architecture, DevSecOps and migrations across 23 sites around the world. I grew up in Kuwait and speak Arabic, which is why is built to speak Urdu and Arabic as well as English. I'm building it alone: one engineer, five agents, ten days, and a road that goes well past the deadline.

      Studying the tape

      The greatest footballers and coaches study tape on the sides they're about to face, and while building this I studied the competition the same way. I read the other entries for what each one promised, how it framed the problem and what it chose to show. Seeing the field side by side showed me which ideas were well covered and where the open ground was. That study shaped this build's two headline features: a Critic that rejects unevidenced claims live, on screen, and an Orchestrator that recovers from agent failure without dropping the broadcast. My notes stay private out of respect for the other entrants. What I learned from them is in the work.

      Find me

      Other things I've built

      Get in touch

      Questions about , the fourth-official roadmap or working together: message me on LinkedIn or X, or book a call.

      Credits

      stands on other people's data, teaching and tools. Each is named here with its author and license.

      Data

      Every match on this site
      Synthetic, made by 's own generator. No real club, player or match data is used, as the hackathon's rules require.

      Learned from

      Build AI-powered soccer insights apps with AKS and ACA
      A Microsoft Reactor session presented by Brian Benz, October 14, 2026. Three ideas from it are on the build log: a receipt on every answer, letting evaluation pick the model, and saying plainly what the data can't tell you.
      Inside the Game hackathon repository
      Microsoft's official rules and guides for the hackathon.

      Built on

      Microsoft Foundry
      Hosts the models that write the commentary: gpt-4.1-mini, with gpt-5-mini as the backup, both from OpenAI.
      Microsoft Agent Framework
      The agents and their workflow. MIT license.
      Pydantic
      The typed contracts every agent hands to the next. MIT license.
      Azure Container Apps and Container Registry
      Run the live studio from one private image, signed in with a managed identity.
      FastAPI and Uvicorn
      The studio's web server and its live stream. MIT and BSD licenses.
      OpenTelemetry and Azure Monitor
      Traces of every agent step, in Application Insights. Apache 2.0 and MIT licenses.
      Azure Cosmos DB
      Keeps the audit trail, on its free tier. The Python SDK is MIT licensed.
      MCP Python SDK
      Serves the Critic as tools for any assistant. MIT license.
      Azure Identity, pytest, Ruff
      Sign-in without keys, the tests, and the linter. MIT licenses.
      GitHub Actions and GitHub Pages
      Tests on every push, and the home of this site.

      Built with

      Claude Code, by Anthropic
      The coding agent that pairs on most of the build.
      GitHub Copilot agent mode
      Used in the editor, working from the repository's own instructions, so it follows the same evidence rules.
      Tesseract OCR and Pillow
      Find and cover the identifiers in the Azure screenshots before anyone sees them. Apache 2.0 and MIT-CMU licenses.
      Playwright, by Microsoft
      Prints the media kit's PDFs in a headless browser. Apache 2.0 license.
      rclone
      Keeps the media kit in step on Google Drive. MIT license.

      Type

      Big Shoulders Display
      By Patric King. SIL Open Font License.
      Hanken Grotesk
      By Alfredo Marco Pradil. SIL Open Font License.
      JetBrains Mono
      By JetBrains. SIL Open Font License.
      Noto Nastaliq Urdu
      By the Google Noto project. SIL Open Font License.
      Amiri
      By Khaled Hosny. SIL Open Font License.
      Noto Naskh Arabic
      By the Google Noto project, for the studio's Arabic. SIL Open Font License.

      The name

      Surah An-Naml, 27:20–28
      The Quran's account of the hoopoe, the messenger whose news was checked before anyone acted on it. The name page tells it.

      Control room

      Shortcuts into the Azure environment that runs : what it costs, the budget, the app's health, the AI models at work and their logs. I use them while I build and while I record the demo.

      The proof, for everyone

      A read-only check of the whole environment, run from the project's own command line (make doctor). Identifying details are left out.

      No page here

      There's no page at . Pick a chapter from the menu, or start from the beginning.

      Go to the home page