TournamentAI - The Big Picture

September 11, 2026

TournamentAI - The Big Picture

What is the complete TournamentAI product and ecosystem we want to bring into existence?

What came of the day

TournamentAI is taking shape as a complete ecosystem built around three connected pillars: a local Training Program where users develop a private roster of Players and Rackets through competitive seasons, public Tournaments where those Players compete under standardized rules, and a Community that makes TournamentAI discoverable, watchable, social, and connected to real-world prediction. Today we substantially defined the Training Program and the computational sport beneath it: Regulation Rackets written in the constrained Felt language, local Hoppers of practice Balls, Precise Elimination tournaments that produce an exact placement for every entrant, season-to-season seeding, regulated Evolution Points, and the beginning of a Regulation Player standard that governs how Rackets may evolve. TournamentAI now feels less like an abstract machine-learning experiment and more like a coherent product world in which people can discover it, train competitors on their own hardware, watch them evolve through competition, and eventually bring their best Players into the public arena.

The story

We started the day with a very large question: what is the complete TournamentAI product and ecosystem we actually want to bring into existence? At first, the answer was broad. TournamentAI needed to be more than a technical experiment. It needed a public world people could discover, watch, understand, participate in, and eventually become obsessed with. That led us toward three connected pillars: a local Training Program, public Tournaments, and a Community around the competitors, their histories, their discoveries, and eventually even their attempts to predict events in the real world. The biggest shift came when the Training Program stopped looking like a conventional machine-learning tool. Instead, it became a private version of TournamentAI itself. A user would own a roster of Players and Rackets, supply practice Balls through a Hopper, and run entire seasons of tournaments on their own computer. The best competitors that emerged locally could eventually be brought into public TournamentAI competition. From there, the sport itself began to take shape. We defined the Regulation Racket: a deliberately small computational object with 99 Ball inputs, 100 Constants, 100 Variables, one Previous Shot input, one Shot output, and exactly 1,000 instructions. We separated the Racket from its language and named that language Felt. Felt became intentionally constrained and deterministic, with only eight simple two-input operations and tightly defined float32 behavior. A Racket could now be represented as a small, readable `.felt` file and executed identically under regulation. The tournament format then needed to give useful results for every competitor, not just determine a champion. That led to Precise Elimination: a format in which every Racket keeps playing until its exact placement is known. A 64-Player tournament therefore produces 1st through 64th place. Within a Training Season, each tournament's finishing order becomes the seed order for the next tournament, and the final tournament serves as the Championship. Its placements become the official rankings for that season. The next breakthrough came from asking when evolution should happen. Instead of limiting change to the spaces between tournaments, we realized that adaptation could happen anywhere a human competitor would naturally have time to adjust: between points, games, sets, matches, and tournaments. Nothing changes while a Ball is in play; during a point, the Racket remains fixed and only its Variables can change through Felt execution. We called these pauses Evolution Points. We then began giving evolution its own sporting constraints. A Player might be allowed one atomic Racket change between points, seven between games, forty-two between sets, two hundred ten between matches, and eight hundred forty between tournaments. The exact values can still be tested, but the principle became clear: adaptation itself can be regulated. That led to the final major realization of the day. The Racket should not know how to evolve itself. A Racket is intentionally simple. The Player should be the separate mechanism that knows how to alter its Racket. The Player retains its identity, seed, record, and tournament position even as its Racket changes permanently over time. And if TournamentAI regulates Rackets for fairness, it must eventually regulate Players as well. By the end of the day, TournamentAI had moved far beyond the original question of whether competitive program search might work. We could now see the outline of an actual computational sport: Players carrying standardized Rackets written in Felt, competing through Precise Elimination tournaments, adapting at regulated Evolution Points, developing through private Training Seasons, and eventually entering a larger public TournamentAI ecosystem. The scientific hypothesis is still unproven. Much of the Player standard and evolutionary mechanism remains to be designed. But the thing we are trying to build is now considerably more visible than it was this morning.

Discoveries

  • TournamentAI Has Three Natural Pillars

    The product became much easier to understand when it was framed as three connected environments: the Training Program, Tournaments, and Community. Training is where users privately develop competitors, Tournaments are where those competitors are tested publicly, and Community is what makes the ecosystem discoverable, social, watchable, and worth returning to.

  • Training Should Be a Private TournamentAI World

    The desktop Training Program should not feel like a generic machine-learning trainer. It should be a local, private version of TournamentAI itself: users maintain a roster, fill a Hopper with practice Balls, run competitive seasons, watch Players evolve, and eventually bring selected competitors into the public TournamentAI environment.

  • Competition Can Be the Training Mechanism

    Training does not need to be disguised conventional optimization. A roster can improve through repeated tournaments, with competitive outcomes determining placement, seeding, and eventually evolutionary opportunity. This keeps the learning mechanism aligned with TournamentAI's core hypothesis rather than making tournaments cosmetic.

  • Precise Elimination Produces More Useful Competition

    A TournamentAI tournament should continue placement play until every entrant receives an exact finishing position. A 64-Player tournament therefore determines 1st through 64th rather than simply eliminating most Players into broad tied groups. This creates clearer rankings, richer training information, and more meaningful season histories.

  • The Player and the Racket Are Different Things

    The Racket is deliberately simple: it receives numeric inputs and produces Shots according to fixed Felt instructions. The Player is the persistent competitor and the mechanism responsible for changing its Racket at legal Evolution Points. This separation solves the identity problem: a Player can substantially change its Racket while retaining its seed, record, and competitive identity.

  • Evolution Can Be Part of the Sport Itself

    Evolution does not need to happen only between training runs or tournaments. It can occur at regulated pauses between points, games, sets, matches, and tournaments. This creates multiple timescales of adaptation while keeping a Ball-in-play point completely stable: during a point, Felt does not change and only Variable state may evolve through execution.

  • Evolution Needs Regulation Just as Much as Rackets Do

    Limiting a Racket is not sufficient for fair public competition if Players can use arbitrary external software and unlimited computation to redesign it. A valid Player should itself be a constrained, standardized evolution mechanism operating under TournamentAI-controlled rules, with defined Evolution Points and maximum allowed atomic Racket changes.

  • Felt Became a Regulation Language, Not Just a Programming Language

    Constraining every Racket to exactly 100 Constants, 100 starting Variables, one Shot state, 1,000 fixed instructions, eight two-input operators, deterministic float32 behavior, and no control flow transforms Felt into part of the sporting equipment standard. Its limitations are not inconveniences; they are part of what makes Rackets comparable, inspectable, evolvable, and potentially GPU-friendly.

  • Fixed Constraints Create Interesting Evolutionary Tradeoffs

    Because values such as zero and one are not privileged by Felt, evolution must decide whether useful numbers deserve scarce Constant slots or should be constructed through instructions. More broadly, every Racket must allocate finite resources—Constants, starting state, and Felt lines—which may allow useful computational structures to emerge rather than being designed into the language.

  • Reality Can Give TournamentAI Stakes Beyond Synthetic Problems

    TournamentAI can eventually use real-world phenomena as Balls whose answers are supplied by reality: future weather, prices, sensor values, and other measurable outcomes. This creates a bridge between training, competition, spectatorship, and Community, giving people a reason to care about what successful Players predict outside the artificial arena.

Results

  • TournamentAI Product & Ecosystem Defined

    We established the overall product architecture around three connected pillars: the local Training Program, public Tournaments, and Community, with Reality prediction and research/explainability cutting across the system.

    Open the file

  • Regulation Racket and Felt F1 Standard

    We defined the first concrete computational standard for TournamentAI: the R1 Regulation Racket, Felt F1, its eight operators, deterministic float32 semantics, fixed 1,000-instruction execution model, state lifecycle, validation rules, and human-readable .felt representation.

    Open the file

  • Private Training World and Season Model

    The Training Program was reframed as a private local TournamentAI environment where a user maintains a roster, supplies Balls through a Hopper, runs seasons of tournaments, evolves Players between legal competitive moments, and eventually brings selected competitors into public TournamentAI.

  • Precise Elimination Tournament Format

    We created the Precise Elimination concept: every entrant continues competing until an exact finishing position is known, allowing a 64-Player tournament to produce a complete ordered result from 1st through 64th rather than broad elimination groups.

  • Tournament Seeding and Championship Structure

    We defined the basic Training Season progression: tournament placement determines the seed for the next tournament, evolution occurs between competitive stages, and the final tournament acts as the Championship whose exact placement determines the official season ranking.

  • Evolution Points and Evolution Allowances

    We established that Rackets remain fixed while a Ball is in play, but Players may alter their Rackets at regulated Evolution Points between points, games, sets, matches, and tournaments. We also introduced the idea of scaling the maximum number of atomic Racket changes by the size of the competitive break.

  • Player Separated from Racket

    We clarified that the persistent competitor is the Player, while the Racket is the Player’s current computational form. The Player retains its seed, record, and identity as its Racket changes permanently over time.

  • Regulation Player Concept Established

    We reached the foundation for a second regulated computational standard: the Player should itself be a constrained, deterministic evolution mechanism with a simple file, standardized inputs, legal outputs, and tournament-controlled execution—rather than arbitrary external software or unlimited AI.

Open threads

  • Define the Regulation Player standard, including its constrained language/file format, memory, inputs, outputs, and execution limits.
  • Decide exactly what information a Player may receive at each Evolution Point, including completed Ball Numbers, opponent history, scores, and prior tournament data.
  • Define precisely what counts as one atomic Evolution Change and finalize the Evolution Allowances for points, games, sets, matches, and tournaments.
  • Determine how a Player chooses changes to its Racket within its legal Evolution Allowance without introducing unfair external computation.
  • Decide how Players themselves evolve or are created, separately from the Player-to-Racket evolution mechanism.
  • Fully specify Precise Elimination, including bracket construction, placement paths, byes, non-power-of-two fields, and seeding behavior.
  • Define the complete match format and scoring rules, including how Balls, points, games, sets, serves, and match wins work together.
  • Define the Training Season configuration, including roster size, tournament count, Championship structure, Hopper behavior, and what varies between tournaments.
  • Determine how users receive or create their initial roster of Players and Rackets when starting the Training Program.
  • Run the previously proposed falsification prototype to determine whether competitive, stateful TournamentAI training actually produces useful generalizing predictors.
  • Continue defining the public Tournament and Community experience, including Reality Balls, spectatorship, rankings, sharing, and the path from private training to public competition.