CourtOS

What it does

CourtOS turns a court-side tablet into an autonomous scoring and tournament coordination system.

Players already announce scores during a match. CourtOS listens for calls such as “30–15,” “Fault,” and “Correction”, interprets them, validates what happened against the current tennis state, and updates the court scoreboard without requiring players to constantly touch the tablet.

Those updates appear in real time on a multi-court organizer dashboard, so tournament staff can see scores, match status, disputes, and newly freed courts without walking between courts or waiting for players to report results.

CourtOS is designed around the messy conditions of amateur tournaments:

Noisy voice input: speech recognition is state-aware. An AI interpretation cannot directly change the score; every proposed action is checked against the legal next states of the match. Ambiguous or failed calls can fall back to another interpretation or the large tactile controls.
Real tennis formats: the scoring engine supports singles and doubles state, server/receiver rotation, No-Ad scoring, tiebreaks, and configurable tournament rules.
Unreliable internet: courts continue scoring locally when connectivity disappears. The organizer sees that the court is stale rather than receiving fake updates, and locally recorded events synchronize when the connection returns.
Disputes and corrections: scoring can be frozen and reconstructed from append-only event history instead of silently overwriting previous state.
Centralized tournament rules: organizers can publish rules such as No-Ad, deciding tiebreaks, and timing policies while protecting matches already in progress from unsafe rule mutation.
Changeovers: the 90-second rest becomes a managed court state with sponsor audio/video and an explicit “Time” alert at 80 seconds.
Tournament scheduling: when a match ends, the organizer immediately knows the court is free and the scheduling system can recompute the next valid court assignment.

The result is one continuous loop:

players call the score → CourtOS validates it → every screen stays synchronized → the match completes → the court becomes available → the tournament decides what should happen next.

How we built it

We separated probabilistic interpretation from deterministic tournament state.

Speech-to-text (ASR) interprets spoken tennis calls. Instead of trusting the transcript blindly, candidate interpretations are evaluated against the current match context. If the primary interpretation is unusable, the same buffered audio can be passed through a fallback recognizer; uncertain cases fall back to tactile confirmation.

A deterministic finite-state machine owns tennis state. It validates every legal transition and tracks points, games, sets, No-Ad behavior, tiebreaks, and serving/receiving order. Speech recognition can propose an action, but it cannot directly write the score.

An append-only event log records accepted scoring actions and corrections. This gives us an audit trail for disputes and also enables offline operation: a disconnected tablet continues applying legal events locally and queues them for synchronization.

WebSocket synchronization propagates acknowledged court events to the organizer's real-time multi-court view. On reconnect, queued events are resent in order and deduplicated by event ID so the court and organizer converge without recording the same point twice.

A receding-horizon constraint optimizer recomputes upcoming court assignments as tournament state changes. It considers court availability, player conflicts, dependencies, rest constraints, and estimated match duration instead of simply assigning the first waiting match.

Send Match Scores to the league organizer.

The court UI is designed for fence-mounted tablets: large typography, ultra-high contrast, large tactile controls, explicit connection state, and audio timing cues.

For the hackathon demonstrator, two courts run concurrently: one interactive scoring tablet and one simulated court node, both represented on the organizer dashboard. A lightweight 3D tennis layer choreographs the demo, but it has no authority over scoring—the deterministic scoring and event systems remain the source of truth.