The model names, the engine decides: small language models in a generated sports entertainment service
Abstract
Language models can now write rules, rosters and commentary for sports that do not exist, which suggests a new kind of entertainment service: a league that any user can create and that plays its games live around the clock. This article asks how the work of such a service should be divided between language models and conventional code. It reports a design study of Daily League, a deployed web service in which users create a league for any sport and watch its games with live text commentary, animation and audio. Games are simulated in full by deterministic engines when they are scheduled and revealed by the clock. Small language models running in the viewer’s browser draft new sports and add colour commentary. Four evaluations are reported. Simulated scoring is close to real professional levels (4.13 runs per team per game in baseball against 4.39 in Major League Baseball in 2024; a batting average of .245 against .243), but competitive balance is weaker than in the real leagues. Qwen2.5–1.5B chose an appropriate game format for 28 of 30 sports that were not built in, against 20 of 30 for Qwen2.5–0.5B, while the moves, translations and names it proposed still needed correction. In colour commentary, between 6.8 and 20.3 per cent of remarks contained an automatically detectable grounding error, most often a claim that a game in progress had been won. The results support a division of labour in which models propose names and the deterministic engines decide outcomes, and they identify where human editing remains necessary.
Keywords: sports simulation; large language models; procedural content generation; live commentary; on-device inference; design science
Word count: approximately 8,200 words, including abstract, references and tables.
1. Introduction
Watching sport is one of the largest forms of entertainment, and most of its appeal rests on two conditions that are hard to manufacture: the outcome is uncertain, and everyone watching learns it at the same time (Knobloch-Westerwick et al., 2009; Peterson and Raney, 2008). Fantasy sports, sports video games and simulated “virtual” races have each tried to recreate parts of that experience without real athletes (Billings and Ruihley, 2013; Dwyer and Kim, 2011). Large language models add a capability that these earlier forms lacked. A model can be asked to invent a sport, name its teams and players, and describe each play as it happens, in more than one language. In principle a single user could create a professional league for any game they can describe and watch it play every day.
Whether this is a good idea depends on what the models are asked to do. Language models produce fluent text that is not reliably true (Ji et al., 2023), and small models that can run on a viewer’s own device are less reliable than large ones. A sports broadcast is unforgiving of that kind of error. A commentator who announces the wrong score, or a league whose results change when the page is reloaded, destroys the uncertainty and the shared moment on which the entertainment depends. Earlier work on automated sports journalism drew the same line from the other side: template systems that write match reports from data are trusted because they cannot invent facts (Carlson, 2015; van Dalen, 2012).
This article asks how the work of a generated sports entertainment service should be divided between language models and conventional code, and how well small models perform the parts that are given to them. It answers through a design study of Daily League, a web service built by the author and deployed in October 2026. In Daily League, users create a league for any sport, including ones they describe in their own words, and edit the teams and players. The service then schedules and plays games around the clock, with live text commentary in English and Traditional Chinese, an animated view of the field and audio generated in the browser. The guiding rule of the design is stated in the title: the model names, the engine decides. Language models propose names, descriptions and remarks. Seeded simulation engines decide every event and every result, and they do so before the game is shown.
The article makes three contributions. The first is the design itself: an architecture that separates outcome generation, which is deterministic, stored and revealed by the clock, from language generation, which is optional, local to the viewer and never stored. The second is an evaluation of that design against real data. Simulated games are compared with five professional leagues, and two small open models, Qwen2.5–0.5B and Qwen2.5–1.5B (Qwen Team, 2024), are tested on the two tasks the service gives them: drafting a new sport and commenting on plays. The third is a set of findings about where such models help and where they must be fenced in by code or by the user. The model is useful as a naming and drafting aid. It is a poor judge of game structure at 0.5 billion parameters and an adequate one at 1.5 billion. When it comments on live play, it sometimes declares a game in progress won, a failure that is easy to detect automatically and that the architecture keeps from reaching the stored record.
Section 2 reviews research on mediated sport, automated sports writing and language models in games. Section 3 describes the service and the reasoning behind its division of labour. Section 4 sets out the evaluation methods, and Section 5 reports the results. Section 6 discusses implications and limitations, and Section 7 concludes.
2. Background
2.1 Uncertainty, suspense and liveness in mediated sport
Sports economics has treated uncertainty of outcome as the product that leagues sell since Rottenberg (1956) and Neale (1964). A league in which the same team always wins attracts fewer spectators, and leagues have designed drafts, salary caps and revenue sharing to keep contests close (Fort and Maxcy, 2003; Szymanski, 2003). Competitive balance is usually measured by the ratio of the standard deviation of teams’ winning percentages to the standard deviation expected if every game were a coin toss, the Noll–Scully ratio. Owen and King (2015) showed that this ratio grows with the number of games when teams differ in strength, so that comparisons between leagues must hold season length constant. That point matters below, because a simulated league can play far more games in a month than a real one plays in a season.
Communication research has studied the same quality from the viewer’s side. Enjoyment of a televised game rises with suspense, the uncertainty about an outcome the viewer cares about (Peterson and Raney, 2008), and Knobloch-Westerwick et al. (2009) found that suspense in sports viewing depends both on uncertainty and on the viewer’s affective involvement with the teams. Spoilers are a related concern. Laboratory studies of fiction found that knowing the ending did not reduce, and sometimes increased, enjoyment (Leavitt and Christenfeld, 2011), but later work found that spoiled narratives were less enjoyable on some dimensions (Johnson and Rosenbaum, 2015). Sport is the clearest case in which audiences avoid learning the result before they watch, and broadcasters protect the shared moment of discovery. Hutchins and Rowe (2012) describe how this “liveness” has survived the move of sport from broadcast television to networked media.
Live streaming of video games shows that audiences will watch play that has no physical stakes. Hamari and Sjöblom (2017) found that escapism, learning about the game, novelty and the aggressiveness of the players predicted how often people watched esports. Sjöblom and Hamari (2017) found that tension release and social and affective motives were associated with the time people spent watching game streams, and Wulf et al. (2020) found that the social side of streaming, including viewers’ relationships with the streamer, contributed most to their enjoyment. A generated league sits between these forms. Like fantasy sport it involves a user’s own selections, like a streamed game it is watched rather than played, and like a broadcast it depends on outcomes that are uncertain and revealed to everyone at once.
2.2 Automated sports writing
Sport was the first domain in which news organisations wrote articles automatically, because match data are structured and abundant. Van Dalen (2012) studied how journalists reacted to an early generator of sports reports and found that they saw it taking over routine work, leaving them to compete on analysis and style. Clerwall (2014) found that readers rated an automatically written sports report as more boring than one written by a journalist but did not judge it less credible. Carlson (2015) and Diakopoulos (2019) placed such systems in the history of newsroom automation, and Graefe et al. (2018) found that readers rated computer-written articles slightly higher on credibility and lower on readability. Thurman et al. (2017) reported that journalists valued these systems for speed and accuracy but disliked their dependence on a fixed data feed. The common feature of these systems is that the text cannot contradict the data, since every sentence is filled from a template.
Research on data-to-text generation tried to replace templates with neural models (Gatt and Krahmer, 2018). Wiseman et al. (2017) introduced a corpus of basketball box scores paired with human summaries and showed that neural models produced fluent summaries that stated facts not in the data. Puduppully et al. (2019) improved faithfulness by planning content before writing. Taniguchi et al. (2019) generated live commentary for football from play data, which is close to the task studied here. Hallucination, the production of content not supported by the input, has since become a central concern for all generation with language models (Ji et al., 2023). The trade-off described in this literature, between the fluency of a model and the faithfulness of a template, is the one a live sports service has to resolve.
2.3 Language models in games
Games research has long generated content algorithmically, from levels and maps to rules (Shaker et al., 2016; Togelius et al., 2011). Procedural content generation through machine learning trains models on existing content and samples new content from them (Summerville et al., 2018), and Yannakakis and Togelius (2018) survey the wider role of artificial intelligence in games. Gallotta et al. (2024) review how language models are being used in games: as players, as non-player characters, as designers’ assistants, as commentators and as generators of game content, and they identify unreliable output as a main obstacle. Park et al. (2023) showed that language-model agents could sustain believable social behaviour in a simulated town, at considerable computational cost.
Two developments make a consumer service of the kind studied here practical. Instruction tuning made models follow short directions (Ouyang et al., 2022), and smaller open models with a few hundred million to a few billion parameters can now run in a web browser through WebGPU or WebAssembly (Ruan et al., 2024). Running the model on the viewer’s device removes the per-request cost of a hosted model and keeps the viewer’s input local. The price is reliability, since the models that fit in a browser are much smaller than those for which most reliability results are reported. Instruction following can be measured with constraints that are checked automatically, such as length and language (Zhou et al., 2023), and Section 4.3 adopts that approach. Speech synthesis has become similarly portable. The Massively Multilingual Speech project released compact text-to-speech models for more than a thousand languages (Pratap et al., 2024), one of which is used here.
3. The service and its division of labour
3.1 Approach
The study follows design science research, in which an artefact is built to address a problem and then evaluated, and the knowledge gained lies in the design principles and in the evidence about how well they work (Hevner et al., 2004; Peffers et al., 2007). The artefact is a public web service, Daily League, built with Next.js, a Postgres database and the transformers.js library for running models in the browser. It was built in two stages in late September and early October 2026: first with baseball and association football, then with support for any sport and for user-made teams and players. The evaluation in this article was carried out on the second version.
3.2 Requirements
Five requirements guided the design. The first is consistency: every viewer of a game must see the same events at the same time, and a reload must never change a result. The second is credibility: the games should resemble professional sport in scoring and in how often favourites lose. The third is generality: a user should be able to create a league for any sport, including one that the system does not know. The fourth is authorship: users should be able to make the teams and players their own. The fifth is low running cost, so that leagues can play around the clock without a hosted model.
3.3 Architecture
Figure 1 shows where each part of the service runs and which parts involve a neural model.
Figure 1. Architecture of the service. Orange components use a neural model; the outcome of every game is decided by deterministic code before the game is shown.
Simulation and reveal. Every game is simulated in full when it is scheduled, from a seed derived from the league and the game’s slot, and stored as a list of events with timestamps, a final score and a box score. The game page and the feed that it polls return only the events whose time has come. All viewers therefore see the same game at the same moment, and nobody can learn the result before it is shown. This meets the consistency requirement by construction, and it is what makes a generated league behave like a broadcast rather than a game the viewer controls. Schedules are round-robin, a standard design in sports scheduling (Kendall et al., 2010), with a game every 15 minutes to 4 hours and seasons of 28 days.
Engines. Baseball and association football have dedicated engines. The baseball engine resolves each plate appearance from batter and pitcher ratings, in the tradition of probabilistic baseball models going back to Lindsey (1963). The football engine models possessions, chances, shots and saves, with team strengths that act multiplicatively on scoring rates in the manner of Poisson models of football scores (Dixon and Coles, 1997; Maher, 1982). Every other sport is played by a generic engine with three formats. Timed games such as basketball or handball are sequences of possessions over periods of a clock. Set games such as volleyball or tennis are sequences of points grouped into sets, with a win by two points and tie-breaks. Round games such as boxing, sumo or chess are sequences of exchanges that move a momentum score, with finishing moves that can end a bout early. Sixteen presets define real sports in these formats, with typical scoring rates, period lengths, positions, scoring moves and errors in English and Chinese. All engines write their play-by-play from templates in both languages, so the text of the broadcast cannot contradict the simulated events.
The sport designer. When a user types the name of a sport that is not built in, a small language model in the user’s browser drafts a definition. Early trials showed that small models were unreliable when asked for a complete definition as structured data, and much better at short list answers. The designer therefore asks a sequence of short questions: which built-in sport the new one most resembles, its name in Traditional Chinese, four ways to score, three ways to fail, the playing positions and ten team nicknames, followed by a separate translation request for each move. The answer to the first question selects a preset, which supplies every rule and number. The model supplies only names. The draft is then shown to the user for editing, together with generated teams and rosters that the user can rename, recolour, strengthen or weaken, player by player. The server checks and clamps every value it receives.
Broadcast-time models. Two models run while a game is watched, both optional and both in the viewer’s browser. A text-to-speech model (MMS-TTS for English; Pratap et al., 2024) reads the English play-by-play aloud, and Chinese commentary is read by the browser’s own voice. A small language model (Qwen2.5–0.5B by default) adds a one-sentence colour remark after highlights. Its remarks are shown and spoken but never stored, so an error affects one viewer for one play and never enters the record.
Figure 2 shows a live game in a sport played by the generic engine.
Figure 2. A live game played by the generic engine (basketball preset), with a scoreboard, the animated court and the text commentary.
The design therefore gives language models two jobs and withholds a third. They name things, and they react to things, but they do not decide anything that is stored or that another viewer will see. The evaluations below test whether the engines are credible without the models, and how well the models do the jobs they are given.
4. Evaluation methods
4.1 Simulated games against real leagues
The first evaluation asks whether the deterministic engines meet the credibility requirement. For baseball, football and each of the sixteen presets, 1,000 games were simulated between the eight teams of a generated league, with 20-minute broadcasts, the default on the service. The statistics recorded were scoring per team per game, the share of drawn games, the share of decided games won by the home team, the share won by the weaker team (an upset, with strength measured as the mean of all player ratings), the share of decided games in which the eventual winner was not ahead at half-way and with a fifth of the game left, lead changes, events and highlights per game, simulation time and stored size. Competitive balance was measured by the Noll–Scully ratio over full seasons, averaged over 30 independently generated leagues. Because the ratio depends on season length (Owen and King, 2015), seasons were simulated with the number of games per team of the corresponding real league, and separately at the 336 games per team that a team plays in a 28-day season on the service.
The real benchmarks were computed from raw data for the most recent completed seasons: Major League Baseball 2024 from the league’s statistics interface, the National Basketball Association 2023–24 from ESPN standings, the National Hockey League 2023–24 from the league’s statistics interface, the Premier League 2023–24 from match results published by football-data.co.uk and the National Football League 2023 from the nflverse game records. For football and American football, upsets were defined against the betting market, as wins by the team with the higher average closing odds or the team not favoured by the closing spread. Simulated upsets were defined against rating strength, so the two measures are related but not identical.
4.2 Drafting a new sport
The second evaluation asks how well the sport designer works for sports that are not built in. Thirty sports were chosen to cover the three formats: fourteen timed team sports (such as kabaddi, korfball, netball and Australian rules football), seven set sports (such as sepak takraw, squash and padel) and nine round sports (such as judo, Muay Thai, xiangqi, Go and robot combat). Before running the models, the author coded the format that a reasonable designer would choose for each. The service’s own designer routine was then run for each sport with Qwen2.5–0.5B-Instruct and Qwen2.5–1.5B-Instruct, with greedy decoding and 4-bit weights, on the CPU of an Apple M4 computer with 24 GB of memory. The CPU is the slower of the two paths the browser can take, so the timings are an upper bound for users whose devices support WebGPU. Every prompt and answer was logged.
The measures were automatic. They were whether the model’s answer to the style question could be parsed; whether the resulting format matched the coded format; whether the Chinese name contained Chinese characters, used Simplified characters despite the request for Traditional ones (tested by converting to Traditional characters with OpenCC and checking for any change), or was the name of another sport; whether the moves, errors, positions and nicknames came from the model or from the fallback; the share of moves and errors translated into Chinese; translations that echoed the instruction instead of translating; and moves phrased as outcomes or descriptions (“won the game”, “achieved a high score”) rather than as actions in play. The last measure is a keyword proxy and undercounts semantic errors.
4.3 Colour commentary
The third evaluation asks whether the commentator’s remarks are faithful to the play. One game was simulated in each of eight sports (baseball, football, basketball, ice hockey, volleyball, tennis, boxing and esports), and up to ten highlights were taken from each, giving 59 plays. For each play, the exact prompt used by the service was sent in English and in Traditional Chinese to both models, with the service’s decoding settings (greedy decoding, at most 48 new tokens, a repetition penalty of 1.15), and only the first sentence of each answer was kept, as on the service. This produced 236 remarks.
Each remark was checked automatically for the instructions in the prompt and for grounding. The instruction checks were length (at most 20 English words, or at most 30 characters in Chinese, with each name in Latin letters counted as one character), language (no Chinese characters in English remarks; at least 80 per cent Chinese characters in Chinese remarks, after removing names that appear in the prompt) and, for Chinese, the use of Simplified characters. The grounding checks were numbers that do not appear in the prompt, capitalised names that do not appear in the prompt (after allowing for possessives and accents), a baseball inning or half-inning that differs from the one in the prompt, and, for the four sports with a clock or innings, a claim that the game has been won or is over. The last check was not applied to set and round sports, where winning a set, a round or one game of a series is a real event. These checks catch only errors of particular kinds, so the rates reported are lower bounds on the true error rate.
4.4 Footprint
The fourth evaluation records what the service costs to run. It reports the download size of each model file from the Hugging Face model repositories, the simulation time per game and the storage used by the deployed database, measured by read-only queries on 1 October 2026.
All scripts, raw data and outputs are listed in the data availability statement.
5. Results
5.1 Credibility of the simulated games
Table 1 compares the simulated games with the real leagues.
Table 1. Simulated games against real leagues.
Note. Games: games per team in the real season, also used for the simulated seasons. Score: points, goals or runs per team per game. Simulated values from 1,000 games per sport; Noll–Scully ratios are means (standard deviations) over 30 simulated seasons. Home wins and upsets are shares of decided games. Real upsets are wins by the betting underdog (average closing odds for football, closing spread for American football); simulated upsets are wins by the team with the lower mean player rating. The simulated league batting average was 0.245 against 0.243 in MLB 2024. Sources: MLB Stats API; ESPN; NHL statistics API; football-data.co.uk; nflverse.
Scoring is close to professional levels. The baseball engine produces 4.13 runs per team per game against 4.39 in Major League Baseball in 2024, and a league batting average of .245 against .243. The basketball, ice hockey and American football presets fall within 4 per cent of the real leagues. Football is the exception: 1.19 goals per team per game against 1.64 in the 2023–24 Premier League, a season with an unusually high scoring rate. The football engine draws 24.4 per cent of games against 21.6 per cent in that season, and its home side wins 55.0 per cent of decided games against 58.7 per cent. The share of decided football games won by the weaker side (27.1 per cent) is close to the share won by the betting underdog in the Premier League (24.9 per cent). In American football, simulated upsets are more frequent than real ones (41.1 against 32.0 per cent), and the engine gives no home advantage (49.1 per cent against 55.5).
Competitive balance is where the simulation departs from the real leagues. With seasons of the same length as the real ones, the Noll–Scully ratio of the simulated baseball league is 5.53, against 1.96 in Major League Baseball, and the simulated basketball league reaches 4.64 against 2.96 in the NBA. In football and American football the simulated leagues are close to the real ones (2.20 against 2.16, and 1.13 against 1.33). The source of the difference is the spread of team strengths that the generator assigns. Individual games are uncertain enough, but over 162 games the stronger teams separate from the weaker ones much more than real teams do, because real leagues restrict talent concentration through drafts and salary rules and generated ones do not. Over the 336 games a team plays in a 28-day season on the service, the ratios rise to between 2.79 (rugby union) and 10.53 (boxing), as Owen and King (2015) would predict.
Table 2 reports the remaining presets, for which no benchmark league was computed, together with the measures of suspense and broadcast density.
Table 2. The other preset sports.
Note. 1,000 simulated games per sport with 20-minute broadcasts. Score per team is shown only for timed sports, with the preset’s design target in parentheses. Upsets: share of decided games won by the team with the lower mean rating. Trailing at half: share of decided games in which the eventual winner was not ahead at half-way. Events: events per game. Noll–Scully: mean over 30 simulated seasons of 82 games per team.
Scoring in the timed presets is within 10 per cent of each preset’s design target. The suspense measures vary in the way the formats would lead one to expect. In basketball, with many scoring events, the eventual winner was not ahead at half-way in only 16.3 per cent of decided games, whereas in volleyball the figure was 51.5 per cent, because a match can turn on its later sets. Chess games are decided late by construction. Broadcast density is suited to live text. The engines produce between 7 events per game (sumo, a single short bout) and 190 (volleyball), and in most sports an event every 6 to 26 seconds of a 20-minute broadcast.
5.2 Drafting a new sport
Table 3 summarises the sport designer’s results.
Table 3. Drafting 30 sports that are not built in.
Note. Greedy decoding, 4-bit weights, Apple M4 CPU. A rule that always chooses a timed format would be right for 14 of 30 sports. Team sports are those for which the chosen style is a team sport, so n differs between models. Outcome phrasing is a keyword proxy and undercounts semantic errors.
The larger model is much better at the structural decision. Qwen2.5–1.5B chose an appropriate format for 28 of the 30 sports, against 20 of 30 for Qwen2.5–0.5B and 14 of 30 for a rule that always chooses a timed format. Part of each score was luck: when the answer to the style question could not be parsed, the designer fell back to basketball, a timed sport, and this happened to be right for three sports with the smaller model and four with the larger. Among parsed answers, the larger model was right for 24 of 25 sports and the smaller for 17 of 27. The smaller model’s errors were of a kind no user would accept. It matched arm wrestling and mixed martial arts to badminton, and polo and bandy to badminton as well, and its draft then described an arm-wrestling bout in badminton’s terms (“smashes a winner”).
Above the level of format, both models needed correction. The larger model produced its own moves for 28 of 30 sports, and 95.4 per cent of its moves and errors were translated into Chinese, but 28.0 per cent of its scoring moves were phrased as outcomes or descriptions rather than as actions. For robot combat it proposed “innovates”, “implements”, “enhances” and “explores”; for Go, “develops superior strategies” and “enhances player engagement”. In 2.3 per cent of its translations it answered with the start of a sentence (“翻譯成繁體中文是…”, “translated into Traditional Chinese is …”) instead of a translation. The Chinese names show different failures in each model. The smaller model always answered in Chinese characters but used Simplified characters for 36.7 per cent of names, despite the request, and it transliterated kabaddi as 杨巴迪. The larger model used Simplified characters only once but returned the English name unchanged for 8 of 30 sports, and for netball and bandy it gave the names of other sports (網球, tennis; 棒球, baseball). Domain knowledge was uneven. The larger model knew the scoring objects of quidditch (“Quaffle score”, “Snitch catch”) and the basic actions of sepak takraw, but proposed “touchdown” for polo and hurling.
Speed was acceptable. A complete draft took 9.6 seconds on average with the smaller model (9.5 model calls) and 27.4 seconds with the larger (11.9 calls) on the computer’s CPU. Users wait for the draft once, when they create a league.
5.3 Colour commentary
Table 4 reports the commentary results.
Table 4. Colour commentary on 59 highlights in eight sports.
Note. Prompts and decoding as on the service; the first sentence of each answer is kept. ᵃ Baseball, football, basketball and ice hockey only (n = 30 per column), since in set and round sports a set, round or game can be won. All checks are automatic and give lower bounds on the error rate.
Get Jung-Hua Liu’s stories in your inbox
Join Medium for free to get updates from this writer.
In English, both models followed the format instructions closely. Every English remark from the smaller model was within the length limit, and 89.8 per cent from the larger. Neither used emoji or hashtags. The grounding errors differed. The smaller model claimed that a game in progress had been won in 13.3 per cent of remarks on clock-based sports (“Luis Castillo’s strikeout was crucial for his team’s victory”), and invented names in 6.8 per cent of all remarks, usually awards (“the Game Master Award”) or misspelled team names. The larger model made fewer errors of these kinds (a claimed result in 3.3 per cent, an invented name in 1.7 per cent) but was the only one to contradict the game state, placing two baseball plays in the wrong half of the inning. Overall, 13.6 per cent of the smaller model’s English remarks and 6.8 per cent of the larger model’s contained at least one detected grounding error.
In Chinese, the smaller model performed worse on every measure. Only 20.3 per cent of its remarks were within the length limit, because it tended to begin with a stock phrase (“這是一句精彩的棒球評論！”, “this is a wonderful baseball comment!”) and continue past the limit until the token budget ran out. It used Simplified characters in 69.5 per cent of remarks, against 15.3 per cent for the larger model, and in 20.0 per cent of remarks on clock-based sports it said that the game had been won, sometimes with an invented final score. The larger model’s Chinese remarks were within the length limit in 91.5 per cent of cases, but it too claimed a result in 10.0 per cent of remarks on clock-based sports, for example that a home run in the third inning “helped the Herons win” (幫助 Harbor City Herons 取得勝利).
Latency suits live text. On the CPU, a remark took 1.2 seconds (English) and 2.1 seconds (Chinese) with the smaller model and about 3.5 to 3.9 seconds with the larger. Highlights occur every 40 seconds or more in most sports, so the remark arrives well before the next highlight.
5.4 Footprint
Table 5 reports the cost of running the service.
Table 5. Running costs.
Note. Simulation on one core of an Apple M4 (Node.js v18.20.8). Database figures from read-only queries on 2026–10–01; stored size is after Postgres compression. Download sizes of the model weight files from the Hugging Face model repositories; tokenizer and configuration files add under 10 MB.
The deterministic parts of the service are cheap. Simulating a game took on average between 0.005 and 0.18 milliseconds on one CPU core, and a stored game occupied between 1.9 and 68.6 kilobytes of event data before compression. On the deployed database, 254 scheduled games held 78.5 events each on average and occupied 10.2 kilobytes each after Postgres compression. The neural parts are cheap to the operator and costly to the viewer. Nothing is run on the server, but the viewer downloads 38 megabytes for English speech, 483 megabytes for the smaller language model on WebGPU (786 megabytes on the CPU path), and 1.2 gigabytes for the larger model (1.8 gigabytes on the CPU path). The models are cached by the browser after the first download.
6. Discussion
6.1 The model names, the engine decides
The evaluations support the central design choice. The deterministic engines met the consistency and credibility requirements without a language model, and they did so at negligible cost. The language models, when tested on the jobs they were given, made errors at rates that would be unacceptable in anything that decides outcomes or enters a shared record: a fifth of the smaller model’s Chinese remarks on clock-based sports announced a result that had not happened. Under the architecture of Figure 1, such a remark is a passing mistake heard by one viewer. Had the same model been asked to narrate the game without a simulation behind it, the error would have become the game.
This is the division that automated journalism reached by other means. Template systems are trusted because they cannot state what is not in the data (Carlson, 2015; Clerwall, 2014), and neural data-to-text systems lost that guarantee in exchange for fluency (Wiseman et al., 2017). A generated sports service does not have to choose between the two, because it can use templates for everything that must be true and a model for colour that is allowed to be wrong in small ways. The remaining failures are concentrated in a few detectable patterns: claims of a final result, invented names and numbers, and wrong language. Each can be checked with a few lines of code before a remark is shown, as the measures in Section 4.3 do, and remarks that fail can be discarded. Detection of hallucination in general is harder (Manakul et al., 2023), but the structured context of a sports broadcast makes the most damaging kinds easy to catch.
6.2 Generation as a draft for the user
The sport designer shows a different role for the model. Here errors are not fleeting but are made once and then fixed by the user. The 1.5 billion parameter model was good enough at the structural decision (24 of 25 parsed answers) that a user would rarely need to change the game style, and good enough at naming that most drafts were a useful starting point. It was not good enough to be trusted with moves or translations, and neither model should be asked to set rules or numbers. The design kept rules and numbers in presets and made every generated item editable, so the model’s errors reduce the value of a draft without breaking a league. This matches the role that Gallotta et al. (2024) describe for language models as designers’ assistants rather than designers.
The difference between the two models has a practical consequence. The smaller model is a third of the download, which matters for a browser application, but its structural errors are severe enough to make the draft misleading. For drafting, which is done once by a user who has chosen to wait, the larger model is the better choice. For commentary, which runs for the whole broadcast and is optional, the smaller model’s English is serviceable and its Chinese is not, so the choice of model should depend on the language of the broadcast.
6.3 Uncertainty and balance
The simulated games are credible one at a time but not as a league. In baseball and basketball the stronger generated teams separated from the weaker ones far more than real teams do. For an entertainment service this matters more than it would in a statistical exercise, since the uncertainty-of-outcome argument applies at the level of the season as well as the game (Fort and Maxcy, 2003; Rottenberg, 1956). A league in which the same two teams always reach the top is less interesting to follow. The remedy lies in the generator, not the engines: a narrower spread of team strengths, or a mechanism that redistributes talent between seasons, as real leagues do. Season length compounds the problem. A 28-day season with a game every 30 minutes gives each team 336 games, and the Noll–Scully ratio rises with season length when strengths differ (Owen and King, 2015). Generated leagues may need to be designed for balance over many more games than any real league plays.
The reveal mechanism protects the other source of suspense. Because the result is stored before the game is shown and the feed returns only past events, viewers cannot learn the outcome ahead of time, and every viewer discovers it together. This reproduces the liveness that Hutchins and Rowe (2012) describe for networked sport, at the cost of making games unchangeable once scheduled. Whether viewers of a generated league care about spoilers as much as viewers of real sport is an empirical question that this study does not answer.
6.4 Risks
Three risks deserve attention. The first is confusion with real sport. Generated players have realistic names and nationalities, and a generated result could be mistaken for a real one if shared without context. The service states on every page that all teams, players and games are simulated, and the share images were designed to show the matchup and not the result. The second is gambling. Simulated races and matches are already offered as betting products, and a generated league with a published schedule could be used in the same way. Nothing in the service supports wagering, but its outputs are public and predictable to anyone who can read the database. The third is linguistic. The smaller model drifted into Simplified Chinese in most of its Chinese commentary despite an explicit request for Traditional characters, which for users in Taiwan is a visible failure and not a matter of taste. Users of languages that small models handle less well will receive a worse service, a pattern that has been noted for language models generally (Bender et al., 2021).
6.5 Limitations
The study has the limitations of a single-artefact design study. The format coding in Section 4.2 was done by the author, and a different coder might judge some sports differently. The automatic measures detect only certain kinds of error and are lower bounds. No human ratings of quality and no study of viewers were collected, so the article says nothing about whether people enjoy the service or find its commentary engaging. The models were run on a CPU with greedy decoding; browsers with WebGPU would be faster, and sampling would change the outputs. Only two models from one family were tested. The simulated benchmarks rest on one season of each real league, and the Premier League season of 2023–24 had more goals than most recent seasons. Finally, the author built the service, which gives an insider’s understanding of its design and an interest in its success.
7. Conclusion
A sports entertainment service can now be built in which any user creates a league for any game and watches it play live, with text, animation and voice, at almost no cost to the operator. This study suggests how to divide the work in such a service. Outcomes should be decided by deterministic, seeded simulation, stored before they are shown and revealed by the clock, so that every viewer sees the same game and nobody can learn the result in advance. Small language models are useful for proposing names and drafts that a user then corrects, and for optional remarks that are never stored. They are not reliable enough to decide anything that other viewers will see. At 1.5 billion parameters a model makes a sound structural choice for most unfamiliar sports. At either size it still announces results that have not happened in a meaningful share of its remarks. The most useful next steps are human evaluation of the commentary and of viewers’ experience, automatic filters for the detectable errors, and generators that keep generated leagues as balanced as real ones.
Declarations
Data and code availability. The scripts, raw benchmark data and outputs for this article are in the replication folder that accompanies the manuscript: scripts/00_benchmarks.sh and 00_benchmarks.py (real leagues), 01_simulation.ts (Table 1, Table 2 and part of Table 5), 02_design.mts and 03_commentary.mts (model runs, with all prompts and answers logged in output/design_runs.json and output/commentary_runs.json), 04_footprint.sh and 05_production.ts (Table 5) and 06_analysis.py (Tables 3 and 4). The source code of the service is available from the author on request. The real-league data come from the MLB Stats API (statsapi.mlb.com), the NHL statistics API (api.nhle.com), ESPN’s public standings interface, football-data.co.uk and the nflverse project (github.com/nflverse/nfldata).
Declaration of generative AI and AI-assisted technologies in the writing process. During the preparation of this work the author used Claude (Anthropic), an AI assistant, to help write the software of the service and the analysis scripts and to draft and edit the text. After using this tool, the author reviewed and edited the content as needed and takes full responsibility for the content of the publication.
Competing interests. The author built and operates the service studied in this article. The author has no financial interest in it and declares no other competing interests.
Funding. This research received no specific grant from any funding agency in the public, commercial or not-for-profit sectors.
References
Bender, E.M., Gebru, T., McMillan-Major, A., Shmitchell, S., 2021. On the dangers of stochastic parrots: Can language models be too big? In: Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency. ACM, New York, pp. 610–623. https://doi.org/10.1145/3442188.3445922
Billings, A.C., Ruihley, B.J., 2013. Why we watch, why we play: The relationship between fantasy sport and fanship motivations. Mass Communication and Society 16 (1), 5–25. https://doi.org/10.1080/15205436.2011.635260
Carlson, M., 2015. The robotic reporter: Automated journalism and the redefinition of labor, compositional forms, and journalistic authority. Digital Journalism 3 (3), 416–431. https://doi.org/10.1080/21670811.2014.976412
Clerwall, C., 2014. Enter the robot journalist: Users’ perceptions of automated content. Journalism Practice 8 (5), 519–531. https://doi.org/10.1080/17512786.2014.883116
Diakopoulos, N., 2019. Automating the News: How Algorithms Are Rewriting the Media. Harvard University Press, Cambridge, MA. https://doi.org/10.4159/9780674239302
Dixon, M.J., Coles, S.G., 1997. Modelling association football scores and inefficiencies in the football betting market. Journal of the Royal Statistical Society: Series C (Applied Statistics) 46 (2), 265–280. https://doi.org/10.1111/1467-9876.00065
Dwyer, B., Kim, Y., 2011. For love or money: Developing and validating a motivational scale for fantasy football participation. Journal of Sport Management 25 (1), 70–83. https://doi.org/10.1123/jsm.25.1.70
Fort, R., Maxcy, J., 2003. Competitive balance in sports leagues: An introduction. Journal of Sports Economics 4 (2), 154–160. https://doi.org/10.1177/1527002503004002005
Gallotta, R., Todd, G., Zammit, M., Earle, S., Liapis, A., Togelius, J., Yannakakis, G.N., 2024. Large language models and games: A survey and roadmap. IEEE Transactions on Games, 1–18. https://doi.org/10.1109/TG.2024.3461510
Gatt, A., Krahmer, E., 2018. Survey of the state of the art in natural language generation: Core tasks, applications and evaluation. Journal of Artificial Intelligence Research 61, 65–170. https://doi.org/10.1613/jair.5477
Graefe, A., Haim, M., Haarmann, B., Brosius, H.-B., 2018. Readers’ perception of computer-generated news: Credibility, expertise, and readability. Journalism 19 (5), 595–610. https://doi.org/10.1177/1464884916641269
Hamari, J., Sjöblom, M., 2017. What is eSports and why do people watch it? Internet Research 27 (2), 211–232. https://doi.org/10.1108/IntR-04-2016-0085
Hevner, A.R., March, S.T., Park, J., Ram, S., 2004. Design science in information systems research. MIS Quarterly 28 (1), 75–105. https://doi.org/10.2307/25148625
Hutchins, B., Rowe, D., 2012. Sport Beyond Television: The Internet, Digital Media and the Rise of Networked Media Sport. Routledge, New York. https://doi.org/10.4324/9780203120415
Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., Xu, Y., Ishii, E., Bang, Y.J., Madotto, A., Fung, P., 2023. Survey of hallucination in natural language generation. ACM Computing Surveys 55 (12), 248:1–248:38. https://doi.org/10.1145/3571730
Johnson, B.K., Rosenbaum, J.E., 2015. Spoiler alert: Consequences of narrative spoilers for dimensions of enjoyment, appreciation, and transportation. Communication Research 42 (8), 1068–1088. https://doi.org/10.1177/0093650214564051
Kendall, G., Knust, S., Ribeiro, C.C., Urrutia, S., 2010. Scheduling in sports: An annotated bibliography. Computers & Operations Research 37 (1), 1–19. https://doi.org/10.1016/j.cor.2009.05.013
Knobloch-Westerwick, S., David, P., Eastin, M.S., Tamborini, R., Greenwood, D., 2009. Sports spectators’ suspense: Affect and uncertainty in sports entertainment. Journal of Communication 59 (4), 750–767. https://doi.org/10.1111/j.1460-2466.2009.01456.x
Leavitt, J.D., Christenfeld, N.J.S., 2011. Story spoilers don’t spoil stories. Psychological Science 22 (9), 1152–1154. https://doi.org/10.1177/0956797611417007
Lindsey, G.R., 1963. An investigation of strategies in baseball. Operations Research 11 (4), 477–501. https://doi.org/10.1287/opre.11.4.477
Maher, M.J., 1982. Modelling association football scores. Statistica Neerlandica 36 (3), 109–118. https://doi.org/10.1111/j.1467-9574.1982.tb00782.x
Manakul, P., Liusie, A., Gales, M., 2023. SelfCheckGPT: Zero-resource black-box hallucination detection for generative large language models. In: Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, Singapore, pp. 9004–9017. https://doi.org/10.18653/v1/2023.emnlp-main.557
Neale, W.C., 1964. The peculiar economics of professional sports. The Quarterly Journal of Economics 78 (1), 1–14. https://doi.org/10.2307/1880543
Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C.L., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al., 2022. Training language models to follow instructions with human feedback. In: Advances in Neural Information Processing Systems 35, pp. 27730–27744.
Owen, P.D., King, N., 2015. Competitive balance measures in sports leagues: The effects of variation in season length. Economic Inquiry 53 (1), 731–744. https://doi.org/10.1111/ecin.12102
Park, J.S., O’Brien, J., Cai, C.J., Morris, M.R., Liang, P., Bernstein, M.S., 2023. Generative agents: Interactive simulacra of human behavior. In: Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology. ACM, New York, pp. 1–22. https://doi.org/10.1145/3586183.3606763
Peffers, K., Tuunanen, T., Rothenberger, M.A., Chatterjee, S., 2007. A design science research methodology for information systems research. Journal of Management Information Systems 24 (3), 45–77. https://doi.org/10.2753/MIS0742-1222240302
Peterson, E.M., Raney, A.A., 2008. Reconceptualizing and reexamining suspense as a predictor of mediated sports enjoyment. Journal of Broadcasting & Electronic Media 52 (4), 544–562. https://doi.org/10.1080/08838150802437263
Pratap, V., Tjandra, A., Shi, B., Tomasello, P., Babu, A., Kundu, S., Elkahky, A., Ni, Z., Vyas, A., Fazel-Zarandi, M., Baevski, A., Adi, Y., Zhang, X., Hsu, W.-N., Conneau, A., Auli, M., 2024. Scaling speech technology to 1,000+ languages. Journal of Machine Learning Research 25 (97), 1–52.
Puduppully, R., Dong, L., Lapata, M., 2019. Data-to-text generation with content selection and planning. Proceedings of the AAAI Conference on Artificial Intelligence 33 (01), 6908–6915. https://doi.org/10.1609/aaai.v33i01.33016908
Qwen Team, 2024. Qwen2.5 technical report. arXiv preprint arXiv:2412.15115. https://doi.org/10.48550/arXiv.2412.15115
Rottenberg, S., 1956. The baseball players’ labor market. Journal of Political Economy 64 (3), 242–258. https://doi.org/10.1086/257790
Ruan, C.F., Qin, Y., Parthasarathy, A.R., Zhou, X., Lai, R., Jin, H., et al., 2024. WebLLM: A high-performance in-browser LLM inference engine. arXiv preprint arXiv:2412.15803. https://doi.org/10.48550/arXiv.2412.15803
Shaker, N., Togelius, J., Nelson, M.J., 2016. Procedural Content Generation in Games. Springer, Cham. https://doi.org/10.1007/978-3-319-42716-4
Sjöblom, M., Hamari, J., 2017. Why do people watch others play video games? An empirical study on the motivations of Twitch users. Computers in Human Behavior 75, 985–996. https://doi.org/10.1016/j.chb.2016.10.019
Summerville, A., Snodgrass, S., Guzdial, M., Holmgård, C., Hoover, A.K., Isaksen, A., Nealen, A., Togelius, J., 2018. Procedural content generation via machine learning (PCGML). IEEE Transactions on Games 10 (3), 257–270. https://doi.org/10.1109/TG.2018.2846639
Szymanski, S., 2003. The economic design of sporting contests. Journal of Economic Literature 41 (4), 1137–1187. https://doi.org/10.1257/jel.41.4.1137
Taniguchi, Y., Feng, Y., Takamura, H., Okumura, M., 2019. Generating live soccer-match commentary from play data. Proceedings of the AAAI Conference on Artificial Intelligence 33 (01), 7096–7103. https://doi.org/10.1609/aaai.v33i01.33017096
Thurman, N., Dörr, K., Kunert, J., 2017. When reporters get hands-on with robo-writing: Professionals consider automated journalism’s capabilities and consequences. Digital Journalism 5 (10), 1240–1259. https://doi.org/10.1080/21670811.2017.1289819
Togelius, J., Yannakakis, G.N., Stanley, K.O., Browne, C., 2011. Search-based procedural content generation: A taxonomy and survey. IEEE Transactions on Computational Intelligence and AI in Games 3 (3), 172–186. https://doi.org/10.1109/TCIAIG.2011.2148116
van Dalen, A., 2012. The algorithms behind the headlines: How machine-written news redefines the core skills of human journalists. Journalism Practice 6 (5–6), 648–658. https://doi.org/10.1080/17512786.2012.667268
Wiseman, S., Shieber, S., Rush, A., 2017. Challenges in data-to-document generation. In: Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, Copenhagen, pp. 2253–2263. https://doi.org/10.18653/v1/D17-1239
Wulf, T., Schneider, F.M., Beckert, S., 2020. Watching players: An exploration of media enjoyment on Twitch. Games and Culture 15 (3), 328–346. https://doi.org/10.1177/1555412018788161
Yannakakis, G.N., Togelius, J., 2018. Artificial Intelligence and Games. Springer, Cham. https://doi.org/10.1007/978-3-319-63519-4
Zhou, J., Lu, T., Mishra, S., Brahma, S., Basu, S., Luan, Y., Zhou, D., Hou, L., 2023. Instruction-following evaluation for large language models. arXiv preprint arXiv:2311.07911. https://doi.org/10.48550/arXiv.2311.07911
