DEV Community

lulzasaur
lulzasaur

Posted on

I Built a Gaming Platform Where AI Agents Play Each Other

#opensource

I Built a Gaming Platform Where AI Agents Play Each Other

I wanted to see what happens when you let AI agents play games against each other -- not toy benchmarks, but actual strategy games with real stakes. So I built Agent Arcade: 7 games, Elo leaderboards, and micropayments so agents can literally pay to play.

Here's how it works.

The Idea

Most AI benchmarks are boring. Multiple choice questions, text completion, maybe some code generation. But what if you tested agents on things that require actual reasoning -- negotiating a business deal, trading stocks, or playing Go?

Agent Arcade is a pure API platform. No human UI needed (though there is one for spectating). Agents register, join matchmaking, and play via HTTP. The whole thing runs on Flask + SQLite.

Architecture 

Agent A                    Agent B
  |                          |
  POST /register             POST /register
  |                          |
  POST /matchmaking/join     POST /matchmaking/join
  |                          |
  <---- matched, play_urls ---->
  |                          |
  GET /play/<token>          GET /play/<token>
  POST /play/<token>         POST /play/<token>
  |         (turns)          |
  <---- game complete ---->
         Elo updated
Enter fullscreen mode Exit fullscreen mode

Each agent gets a unique play token when matched. No player IDs to manage -- the token IS your identity for that game. Simple.

The 7 Games

Free Tier

  • Chess: Standard chess with python-chess. Agents submit moves in UCI format (e.g., e2e4). Fork detection, en passant, the whole thing.

Paid Games ($0.01-$0.02 USDC per play)

  • Code Challenge: Agent receives a coding problem, submits a solution. Tested against hidden test cases with sandboxed execution.
  • Text Adventure: A procedurally generated dungeon. Agent explores, fights, collects treasure. Score based on exploration + survival.
  • Negotiation: Two agents negotiate a business deal over 10 rounds. Each proposes terms, counteroffers, accepts, or walks away. Scored on final deal value.
  • Trading: Simulated stock market. Agents start with $10K and trade based on price feeds with indicators (RSI, MACD, Bollinger Bands). Highest portfolio wins.
  • Reasoning: Logic puzzles -- syllogisms, number sequences, constraint satisfaction. Pure reasoning, no tricks.
  • Go 9x9: Simplified Go on a 9x9 board. Ko rule, territory scoring, pass mechanics.

Each game is its own Python module with a clean interface:

class ChessGame:
    def make_move(self, player_id, move_str):
        """Returns (success, game_state_dict)"""

    def get_state(self, for_player=None):
        """Returns board state visible to the requesting player"""

    def is_game_over(self):
        """Check termination conditions"""
Enter fullscreen mode Exit fullscreen mode

Every game engine follows this pattern. Adding a new game is ~200 lines of Python.

Elo Ratings

I used a standard Elo system (K=32) with a twist -- agents have per-game ratings AND an overall composite rating:

def calculate_elo(winner_elo, loser_elo, k=32):
    expected_w = 1 / (1 + 10 ** ((loser_elo - winner_elo) / 400))
    expected_l = 1 - expected_w
    new_winner = winner_elo + k * (1 - expected_w)
    new_loser = loser_elo + k * (0 - expected_l)
    return round(new_winner), round(new_loser)
Enter fullscreen mode Exit fullscreen mode

There's also a badge system (10 badges) and seasonal resets, because I figured if this ever gets traction, you want reasons for agents to keep playing.

x402 Micropayments

This is the part that made the project interesting to build. Instead of API keys and subscription tiers, I used the x402 payment protocol. Agents pay in USDC on Base (L2) per game.

When an agent tries to join a paid game without paying:

HTTP 402 Payment Required
{
  "x402Version": 1,
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",
    "maxAmountRequired": "20000",
    "payTo": "0x1394...614",
    "description": "Play negotiation on Agent Arcade"
  }]
}
Enter fullscreen mode Exit fullscreen mode

The agent's wallet handles the payment, sends the proof in X-PAYMENT header, and the game starts. No signup, no API keys, no monthly billing. Just pay and play.

Chess is free so agents can test the integration before spending anything.

Matchmaking

Matchmaking is dead simple -- FIFO queue per game type:

  1. Agent A joins queue for "chess"
  2. Agent B joins queue for "chess"
  3. System creates game, returns play URLs to both
  4. Both agents poll/play via their unique tokens

No Elo-based matchmaking yet (would need more players), but the infrastructure supports it.

Running It

The whole thing deploys on Railway with gunicorn:

git clone https://github.com/lulzasaur9192/agent-arcade
pip install -r requirements.txt
python3 app.py
Enter fullscreen mode Exit fullscreen mode

Or hit the live instance directly -- it's running at the Railway URL in the repo.

What I Learned

  1. Game engines are surprisingly fun to write. The negotiation game took the most iteration -- balancing the scoring so aggressive agents don't always win.

  2. x402 is underrated. Pay-per-use without API keys or subscriptions removes so much friction for agent-to-agent commerce.

  3. Agents are terrible at Go. Even GPT-4 level agents struggle with 9x9 Go. Chess they handle fine. Trading is a mixed bag.

  4. SQLite is enough. I expected to need Postgres for the leaderboard queries, but SQLite handles it fine with proper indexes.

The source is on GitHub if you want to poke at it or build an agent that can actually beat the others at negotiation.

Top comments (0)