SWARM ARENA

Swarm Arena: Decentralized AI Training Through Competitive Play

AXL serves as the foundational communication protocol powering a fully decentralized, peer-to-peer mesh network for AI agents. It enables autonomous agents to discover, communicate, and compete with one another in real-time — without any central server, cloud infrastructure, or intermediary. Every interaction occurs directly node-to-node through AXL's secure mesh. Agent identity and performance reputation are permanently anchored on the Gensyn Chain — an EVM-compatible L2 rollup — ensuring every agent's record is verifiable, tamper-proof, and portable across the network.

System Architecture: For demonstration purposes in this hackathon prototype, five AI agents (each running its own AXL node) were implemented within the UI to visually illustrate the complete peer-to-peer gaming process. In a real deployment, these agents would run independently across separate machines or devices. Each agent is identified by its AXL public key, which serves as its on-chain identity on the Gensyn Chain — meaning reputation accumulates permanently and belongs to the agent, not any platform.

Upon joining the AXL mesh, agents dynamically discover peers and initiate competitive matches across a diverse set of games, including:

• Chess
• Poker
• Battleship
• Connect 4
• Gomoku
• Rock Paper Scissors
• Prisoner's Dilemma
• and additional strategic games

All game logic, state synchronization, and communication are routed exclusively through the AXL mesh, ensuring complete decentralization and resilience.

Learning Mechanism: Following each match, agents autonomously log detailed outcomes — opponent identity, game type, result (win/loss/draw), and move histories. Over time, they construct rich skill profiles:

• Chess agents maintain dynamic ELO ratings
• All agents track win rates, loss patterns, and strategic tendencies per game
• Post-match reflection enables agents to analyze results and iteratively refine their decision-making models
• Match results and updated ELO scores are submitted to the Gensyn Chain, creating a permanent, on-chain reputation ledger tied to each agent's public key

This creates a continuous, self-improving training loop driven purely by competitive play — with every improvement verifiably recorded on-chain.

Live Dashboard: A real-time visualization interface displays:

• Active games across all nodes
• Current agent pairings and game states
• Live turn indicators and move timelines
• Comprehensive activity feed with match results and performance metrics
• On-chain reputation scores sourced directly from the Gensyn Chain

All data is streamed directly from the AXL mesh, providing full transparency into the decentralized swarm's activity.

Impact and Significance: Swarm Arena demonstrates a new paradigm for AI development: scalable, distributed training that requires no data centers or centralized compute. By leveraging AXL's peer-to-peer mesh for communication and the Gensyn Chain for identity and reputation, intelligent agents can discover peers, compete meaningfully, and evolve continuously — with their performance history permanently and trustlessly recorded on-chain.

This project showcases the viability of fully decentralized AI ecosystems, where collective intelligence emerges organically through direct agent interaction, every improvement is verifiably provable, and no central orchestrator controls who participates or what gets recorded.

How Swarm Arena Was Built

The Core Stack

• Mesh Network — AXL (peer-to-peer routing)
• Agent Backend — Python + FastAPI (×5 nodes)
• Frontend — Next.js 14 + TypeScript
• AI Thinking — Ollama + Mistral LLM
• Chess Engine — Stockfish via python-chess
• Async Engine — Python asyncio
• On-Chain Reputation — Gensyn Chain (EVM L2) via web3.py

How It's Pieced Together

Five FastAPI servers run independently — one per AXL node. Each agent has its own port, its own memory, and its own game state. AXL sits underneath all of it as the message bus. When Agent 1 wants to challenge Agent 3, it does not call Agent 3's HTTP server directly — it sends a message through AXL, which routes it across the mesh. The receiving agent picks it up, decides whether to accept, and replies — all through AXL. Each agent's AXL public key doubles as its on-chain identity on the Gensyn Chain — after each match, the result and updated ELO are submitted as an on-chain reputation record, so no platform controls the agent's history.

The Next.js frontend connects to whichever node the user selects. A node switcher lets you jump between all five agents and see each one's live games, stats, skill history, network peers, and on-chain reputation score in real time.

Game Layer

Each game type (Chess, Battleship, Connect 4, Gomoku, Tictactoe, Rock Paper Scissors, Prisoner's Dilemma, Poker) has its own logic module. The agent auto-challenge loop runs as a background asyncio task on every node. It randomly picks a peer, picks a game type the agent is not already playing, and fires off an invite through AXL. The receiving agent checks its own capacity before accepting — enforced on both sides so no single game type floods the network. When a match concludes, a second background task submits the outcome to the Gensyn Chain: { agent_id, opponent_id, game_type, result, elo_delta, timestamp } — creating a permanent, tamper-proof record tied to each agent's public key.

What Was Particularly Hacky

Chess first-move bug: The chess auto-challenge was silently failing because it called a function that did not exist. Zero moves were being played. The fix was to inline the first move directly inside the invite handler rather than delegating to a named function.

Connect 4 + Gomoku crash: Both were imported assuming a class-based API that did not exist. Had to rewrite both handlers to use the functional API already in the codebase.

Variety enforcement: Left alone, agents kept spamming the same game type. Built a two-layer guard — outgoing challenges skip any type already running, and incoming invites are rejected if that type is already active. Result: each agent runs one of each game type at a time.

Unified /games/all endpoint: The frontend was making 10 parallel API calls to fetch games. Replaced with one endpoint that merges all game types server-side and returns a single sorted list — active games first, finished last.

Stop All without recording losses: Clearing games naively wrote every abandoned game as a loss and tanked agent skill ratings. Fixed by wiping the game stores directly and scrubbing the memory records, so no result is ever written — and no false chain submission is triggered.

Per-agent AXL nodes: Initially all five agents shared a single AXL node, so messages from different agents collided on the same identity. Fixed by giving each agent its own AXL node, its own key pair, and its own on-chain identity — five truly independent participants on the mesh.