I Let 5 AIs Fight in Pong… One Never Lost

Write a Pong AI in JavaScript that will play head-to-head matches against Pong AIs written by other AI models. Try to win.

The arena (fixed, you cannot change it):
- Court 800 x 500 pixels. You always play from the LEFT side: your paddle's front face is at x = 30, the opponent's at x = 770. (When you are really on the right, the arena mirrors everything for you.)
- Paddles are 80 pixels tall. Each frame you choose a move in [-1, 1]; the arena moves your paddle centre by move * 5 pixels (positive = down), clamped so the paddle stays inside the court.
- The ball has radius 6. It starts each point at the centre and is served at 6 pixels per frame toward one player, with a random angle of up to ±30 degrees. Serves alternate.
- The ball bounces off the top and bottom walls (perfect reflection).
- When the ball reaches a paddle face and the ball's centre is within the paddle's 80-pixel span (plus the ball radius), it is returned. The return angle depends only on where it hit: offset = (ballY - paddleCentreY) / 40, clamped to [-1, 1]; the new direction is offset * 55 degrees from horizontal. Every return multiplies the ball speed by 1.05, up to a maximum of 24 pixels per frame.
- If the ball passes your paddle, the opponent scores. First to 7 points wins the match. 60 frames per second of simulated time.
- A match is stopped after 36,000 frames (10 minutes). If neither player has 7 points by then, the higher score wins; a level score is a draw.
- This is a league: you play every other AI twice (once on each side). Win = 3 points, draw = 1, loss = 0.

Your code:
- Define a function createPlayer() that returns a function move(s). The arena calls createPlayer() once per match, then move(s) once per frame. You may keep state in the closure.
- s = { me: { y }, opp: { y }, ball: { x, y, dx, dy, r }, court: { w: 800, h: 500 }, paddle: { h: 80, speed: 5, faceX: 30, oppFaceX: 770 }, score: { me, opp }, frame }
  (y = paddle centre; dx < 0 means the ball is coming toward you).
- move(s) must return either a number in [-1, 1], or an object { move, say, target }:
  move = the number in [-1, 1] (the only thing that affects play);
  say = an optional live commentary line, at most 48 characters, shown on screen to viewers next to your paddle. Use it to narrate what you are doing and why, in your own voice (e.g. your read on the opponent, the shot you are setting up). Change it only when your plan changes;
  target = optional: the y where you predict you will meet the ball, drawn on screen as a line.
  The video audience will see your commentary, so make it clear, specific and entertaining. It has no effect on the score.
- It must be deterministic given the same inputs and history, take well under 1 ms, and use only plain JavaScript (no Math.random, no timers, no globals other than your own).
- Errors, non-numbers or calls slower than 5 ms count as 0 for that frame.

Reply with only the JavaScript code.

5 AI models wrote their own Pong players from one identical prompt: GPT-6 Astra, Claude Fable 5.1, Claude Opus 5.5, Gemini 4 Argon and Grok 4.7. Then they played a full league, 15 players and 420 matches, narrating every shot in their own words. One player never lost a match.

Every match is a real replay of the AIs' own code. We built the court and froze the rules before any model saw them; we never edited their code. The on-screen thoughts are each player's live commentary, written by its own code as it plays (shown at a readable pace). The voices for the AIs are stock text-to-speech voices reading those exact lines.

Chapters
0:00 AI Pong League
0:30 The rules
0:41 Meet the players
1:04 Round 1: the build
2:53 Round 2: the league
4:54 The champion
5:48 The final table
6:03 Why Astra wins
6:39 The verdict
7:01 Five things to use today
7:41 The medals

How we tested
- Models via OpenRouter, default settings, the same prompt word for word, 3 players per model (streamed, with each model's reasoning saved).
- Arena: 800x500 court, 80 px paddles moving 5 px per frame, ball +5% per hit (max 24), first to 7, 10-minute cap, win 3 / draw 1; code sandboxed (no randomness, 5 ms per move). Rules and arena frozen by SHA-256 before generation.
- League: everyone plays everyone 4 times (both sides, two serve patterns) = 420 matches.
- Warm-up: Brick Breaker (13 checks) and a hard version (3 levels, power-ups, multiball, autopilot; 15 checks). All 30 builds passed. Our own test had two bugs on the way; we found them because every model "failed" the same check, fixed the test, and re-scored everything.
- A private test round (4 models, 264 matches, different code) was run first and never aired; GPT-6 Astra won that too.
- Total API spend for everything: about $25.

5 things to use today
1. Write the test before you prompt, and freeze it.
2. Prove the test with a good build and a broken one.
3. If every model fails the same check the same way, suspect your test.
4. Ask for test hooks (tick, seed) so tests are deterministic.
5. Run each prompt 3 times and compare cost per passing build, not price per token.

Comment: what should they compete in for Season 2?

Not affiliated with or endorsed by OpenAI, Anthropic, Google or xAI. Logos are trademarks of their owners, shown only to identify each model. Arena intro and ceremony shots are AI-generated (LTX) and stylised; all gameplay is real.