Arbitra: The Zero-Look AI Match Engine

Arbitra is the first Zero-Look AI match engine for field hockey. It replaces $300 of gear with a smartphone, using gesture-based controls and Gemini AI to log events in real-time.

Comment

Arbitra: The Zero-Look AI Match Engine

💡 Inspiration

Field hockey umpires manage fast-paced matches using a fragmented, outdated hardware stack that costs upward of $\$300+$:

  • A specialized digital watch (running count-up/count-down timers)
  • Plastic penalty cards (Green, Yellow, Red)
  • Waterproof paper notebooks + pencils (to log scores, jersey numbers, and suspension times)
  • Short-range radios for communication

This physical friction causes cognitive overload. Every time an umpire issues a card or records a goal, they must look down, find their pencil, and write on a card. This forces them to take their eyes off the play, missing critical fouls or off-the-ball misconduct.

Arbitra solves this by replacing physical hardware friction with a single, gesture-driven mobile app optimized for forearm armbands and paired with a real-time technical table dashboard. The goal is simple: keep the umpire's eyes on the field at all times.

$$T_{\text{gaze_on_field}} \to 100\%$$

🛠️ What It Does

Arbitra is the first "Zero-Look" digital match management system. It bridges on-field physical officiating with immediate B2B administrative visibility through several key features:

  • Gesture Logic (Armband UI): The mobile UI is optimized for high-visibility OLED black and uses full-screen macro-swipes and taps to register match events without looking at the screen:

    • $\text{Double Tap} \to$ Toggle match clock (start/pause)
    • $\text{Swipe Up} \to$ Issue Green Card (2-minute suspension)
    • $\text{Swipe Right} \to$ Issue Yellow Card (5-to-10-minute suspension)
    • $\text{Swipe Down} \to$ Issue Red Card (permanent expulsion)
    • $\text{Two-Finger Swipe} \to$ Initiate Video Challenge
    • $\text{Long Press} \to$ Record a Goal
    • $\text{Two-Finger Double Tap} \to$ Request Official Timeout
    • $\text{Two-Finger Triple Tap} \to$ Trigger Emergency Medical Alert

  • AI Voice-to-Action: When a card or goal gesture is registered, a low-latency microphone overlay opens. The umpire speaks the event details (e.g., "Yellow card on number fourteen, blue"). Gemini AI parses the voice input and extracts structured event parameters in under $1.5\text{ seconds}$:

$$T_{\text{latency}} \le 1.5\text{ s} \quad (\text{with target processing budget } T_{\text{process}} < 800\text{ms})$$

  • Live Dashboard: Tournament directors and fans get a real-time web view of all matches, scoreboards, and active card suspension countdowns as they happen on the pitch.
  • Automated Reporting & Cryptographic Archiving: On match completion, the system generates an official, FIH-compliant A4 PDF match report. To guarantee compliance and prevent post-match tampering, the report is cryptographically sealed:

$$\text{Hash} = \text{SHA-256}(\text{PDF}_{\text{MatchReport}})$$

This hash is anchored directly onto the Polygon blockchain via a transaction to the zero address ($\emptyset$), making the report mathematically immutable before it is submitted to federation APIs (USA Field Hockey, Hockey Canada, FIH, or England Hockey).

  • AI Business-Operating Agents: Human effort is reserved for the field. Everything else is run by four background AI agents in production:
    1. Federation-Submission Agent (FSA): Handles post-match report compilation, PDF generation, blockchain anchoring, and API submissions.
    2. Umpire Performance Advisor Agent (UPAA): Executes weekly, analyzing umpire statistics and decision latencies to deliver personalized coaching reviews and training drills.
    3. Tournament Growth Agent (TGA): Scans the founder's match calendar to auto-prospect Tournament Directors at active venues and draft outreach emails.
    4. In-App Support Agent (ISA): An always-on onboarding helper running keyword-based RAG over the product documentation to troubleshoot user issues instantly.

🏗️ How We Built It

Arbitra is built as a monorepo containing three core architectural pillars:

Arbitra/
├── apps/
│   ├── mobile/         # Flutter Client (Armband UI)
│   └── web/            # Vite + TypeScript Dashboard (Technical Table telemetry)
└── functions/          # Google Cloud Functions (Serverless AI & Agents Layer)
  • Mobile App: Built with Flutter for cross-platform iOS and Android capability. It handles on-device Voice Activity Detection (VAD), WebRTC noise suppression, local SQLite event queues for offline resilience, and bluetooth earpiece integration.
  • Web Dashboard: A single-page application built with Vite, TypeScript, and Vanilla CSS/HTML. It uses the Firebase Web SDK to open live Firestore snapshot listeners, reflecting scores, cards, and suspension countdowns instantly.
  • Backend & AI Core: Written in Node.js 18 running on Firebase Cloud Functions and Google Cloud Storage. AI capabilities are powered by Gemini 2.5 Flash (via Vertex AI) for voice-to-action parsing and support RAG.
  • Blockchain Layer: Integrates Ethers.js inside the submitMatchReport Cloud Function to broadcast SHA-256 metadata directly to the Polygon Network.

💰 Unit Economics (COGS per Match)

By running a serverless AI stack, the cost of running Arbitra is extremely low:

$$\text{COGS}{\text{match}} = \text{Gemini}{\text{parse}} + \text{Firestore}{\text{I/O}} + \text{Storage}{\text{audio}} + \text{BigQuery}_{\text{analytics}} \approx \$0.08\text{ per match}$$

At a Pro Tier subscription of $\$19.99/\text{month}$ for an umpire officiating $\approx 8$ matches per month, Arbitra achieves outstanding margins:

$$\text{Gross Margin} = \frac{\$19.99 - (8 \times \$0.08)}{\$19.99} \approx 96.8\%$$

🛑 Challenges We Ran Into

  • Low-Latency Voice Processing in Serverless Environments: Parsing audio payloads in under $1.5\text{ seconds}$ required optimizing the network pipeline. We solved this by using a streaming-friendly audio buffer on the mobile client, utilizing Remote Config to cache API endpoints, and keeping our Gemini system instructions highly structured to minimize inference token output (capping maxOutputTokens at $256$ tokens).
  • Decryption overhead: For privacy, audio data is encrypted on-device via AES-GCM before transmission. Decrypting the buffer in Google Cloud Functions required careful handling of crypto keys stored securely in the match Firestore documents without introducing performance lag.
  • Context Resolution in Loud Stadiums: Crowd noise and ambient whistling occasionally corrupted the audio buffer. We addressed this by running WebRTC-based noise suppression on the mobile client before transmission and formatting the Gemini system instructions with contextual constraints (e.g., matching spoken team colors against the match parameters: $\text{Home} = \text{"Blue"}$, $\text{Away} = \text{"White"}$).
  • Offline-First Resilience: In physical sports venues, cellular connectivity can drop. We designed a dual-tiered data strategy: all gestures and events are appended to a local SQLite queue first. The queue attempts to push to Firestore in the background, but if sync fails, the mobile UI remains functional offline and alerts the umpire to sync once cellular service resumes.

🎉 Accomplishments That We're Proud Of

  • True "Zero-Look" Officiating: We successfully verified that an umpire can complete an entire match (clock control, green cards, yellow cards, goals) without looking at their phone screen, relying entirely on haptic rumble cues and macro-gestures.
  • Cryptographic Play-to-Record Integrity: Bridging the physical match actions directly with an immutable blockchain audit trail. The fact that a local youth club match can be officially logged and cryptographically sealed on Polygon in under $10\text{ seconds}$ from the final whistle is a major milestone for grass-roots sports compliance.
  • Fully Automated AI Operations: Building a business model where administrative, coaching, marketing, and customer support loops run independently via serverless AI agents, freeing the founders to focus entirely on product design and officiating.

📖 What We Learned

  • Two-Tiered Data Separation: Real-time sports applications require separating low-latency transient data from immutable records. For the technical table, transient streams via Firestore listeners (updating scores and clocks) are ideal. However, for official compliance, only validated snapshots (cryptographically hashed PDFs) should be filed and submitted to external APIs.

  • Agentic Boundary Constraints: AI agents running in production must have structured guardrails. For outward-facing actions (like emailing prospective directors or filing official reports), implementing human-in-the-loop review panels directly on the Vite dashboard creates a safe environment that mitigates LLM hallucination risks.

🔮 What's Next for Arbitra

  • Multi-Pitch Tournament Dashboards: Expanding the Vite web dashboard to support grid-monitoring of up to $8$ pitches simultaneously, allowing a single technical officer to oversee an entire tournament from a single dashboard screen.
  • Local Federation Pilots: We are actively planning pilot test matches with local hockey associations to measure real-world umpire cognitive load changes using EEG headbands compared to traditional paper cards.
  • Live Audio Streaming: Upgrading our voice model from text-based callable commands to real-time audio streams via Gemini Live, enabling the AI to act as an immediate audio assistant in the umpire's earpiece as the match develops.

Built With

  • ajv
  • dart
  • ethers.js
  • express.js
  • firebaseauthentication
  • firebasecloudfunctions
  • firebasecloudstorage
  • firebaseemulatorsuite
  • firebasefirestore
  • firebaseremoteconfig
  • flutter
  • gemini2.5flash
  • googlebigquery
  • googlecloudsecretmanager
  • googlevertexai
  • javascriptes6+
  • node.js
  • pdfkit
  • polygonblockchain
  • sqflite
  • sqlite
  • typescript
  • vite
  • webrtcnoisesuppression
Share this project:

Updates