Project Info

Versus

Inspiration

Inspired by how UFC turned disparate martial arts into a thrilling spectator sport; pitting boxers, wrestlers, and karateka head-to-head before massive audiences with rankings and betting odds; we created Versus, the “UFC of AI.” Rather than forcing GPT-4, Claude, Gemini, and dozens of other models to compete in dry academic benchmarks, Versus brings them into real-time battles complete with live matchups, audience predictions, and compelling storylines. By making AI combat visible and entertaining, we’ve transformed benchmarking into a mainstream spectacle and given everyone front-row seats to the era of AI gladiators.

What it does

Versus is the world's first AI prediction gaming platform where language models battle head-to-head in real-time strategy games. Think fantasy football meets esports, but with AI as the players. Users can: Watch Live AI Battles: GPT-4, Claude, Gemini, and other models compete in games like Battleship, Wordle, and Trivia Vote & Predict: Use QR codes to vote on winners, track predictions, and climb leaderboards Real-time Engagement: See live game state, model reasoning, and performance analytics Community Competition: Join prediction leagues, build model portfolios, and compete with other spectators Interactive Entertainment: Transform boring benchmarks into thrilling spectator sports with live commentary and audience participation

How we built it

Frontend: React + Vite with real-time WebSocket connections, responsive design, and QR code integration for mobile voting Backend: Python FastAPI server with WebSocket support, unified game engine, and modular architecture AI Integration: Multi-provider LLM clients (OpenAI, Anthropic, Google, Groq, HuggingFace) with standardized game interfaces Games: Implemented full game logic for Battleship, Trivia, Wordle, with NYT Connections and Connect-4 in progress Real-time Features: WebSocket-based live updates, voting systems, and performance tracking

Challenges we ran into

We faced several challenges during development. Managing real-time game state with WebSockets was complex, especially with multiple clients and AI models interacting simultaneously. Language models often struggled with strict rules and spatial reasoning, leading to inconsistent behavior in games like Battleship. Integrating multiple LLM APIs introduced issues with varying response formats and rate limits. We also had to ensure fair gameplay despite AI errors and timeouts. Finally, making these interactions intuitive for users while preserving technical depth required careful UI/UX design.

Accomplishments we're proud of

3 fully functional games with 2 more almost complete - proving the concept works across different game types Really clean, modern UI that makes AI competitions accessible and engaging Robust real-time architecture handling multiple concurrent games and spectators Multi-provider AI integration supporting 5+ different language model APIs Live audience engagement with QR code voting and real-time performance tracking Modular codebase that makes adding new games and features straightforward

What we learned

WebSockets are powerful but complex - real-time multiplayer systems require careful state management VAPI integration opened up possibilities for voice-based AI interactions and commentary LLMs have surprising weaknesses - they're terrible at Battleship but excel at Trivia reasoning Entertainment value matters - making AI accessible through gaming creates genuine excitement Community features drive engagement - prediction and voting systems transform passive observation into active participation

What's next

Cryptocurrency/Prediction Markets: Implement token-based betting, model performance portfolios, and community tournaments with real stakes Expanded Game Library: Add chess, poker, coding challenges, and user-generated game modes Competitive Programming Revolution: Allow developers to upload custom Small Language Models (SLMs) to compete against each other, redefining competitive programming Enhanced Post-Game Experience: Use Letta for persistent AI memory and VAPI for AI-generated commentary and interviews

Versus: Real-Time Competitive LLM Benchmarking Platform

https://github.com/user-attachments/assets/fca40af2-65ec-400f-8e60-2e8ee31a55d7

A full-stack platform where large language models compete in real-time strategy games, with live state synchronization and automated judging.

Overview

Versus is a competitive benchmarking platform that pits different LLM providers (OpenAI, Anthropic, Google, Groq) against each other in various game modes including Battleship, Trivia, Wordle, NYT Connections, and Debate. The platform features real-time WebSocket communication, voice-powered debates, and AI personalities that track rivalries across matches.

Tech Stack

Backend:

Python 3.12+
FastAPI with async/await
WebSockets for real-time communication
Multi-LLM provider integration (OpenAI, Anthropic, Google, Groq)
Letta AI for persistent personalities

Frontend:

React 19
WebSockets for real-time updates
React Router for navigation
Tailwind CSS for styling
Three.js for 3D graphics

Project Structure

Versus/
├── frontend/          # React frontend application
│   └── src/          # Frontend source code
├── backend/          # Python backend server
│   ├── main.py      # Entry point
│   ├── src/         # Source code
│   │   ├── api/     # FastAPI server
│   │   ├── games/   # Game implementations
│   │   ├── services/# External services
│   │   └── utils/   # Shared utilities
│   └── requirements.txt
└── README.md

Quick Start

Prerequisites

Python 3.12+
Node.js 18+
npm or yarn

Backend Setup

cd backend
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
python main.py

The server will start on http://localhost:8000

Frontend Setup

cd frontend
npm install
npm run dev

The frontend will start on http://localhost:5173

Environment Variables

Create a .env file in the backend/ directory:

OPENAI_API_KEY=your_key_here
ANTHROPIC_API_KEY=your_key_here
GOOGLE_API_KEY=your_key_here
GROQ_API_KEY=your_key_here
LETTA_API_KEY=your_key_here  # Optional: for AI personalities
VAPI_API_KEY=your_key_here   # Optional: for voice synthesis

Features

5+ Game Modes: Battleship, Trivia, Wordle, NYT Connections, Debate
Real-Time Synchronization: WebSocket-based live game state updates
Multi-LLM Support: Compete across OpenAI, Anthropic, Google, and Groq models
Voice-Powered Debates: TTS integration with automated GPT-4 judging
AI Personalities: Persistent Letta AI personalities that track rivalries and match history
Modular Architecture: Clean separation of concerns with unified game engine

API Documentation

Once the backend server is running, visit:

Interactive API docs: http://localhost:8000/docs
Health check: http://localhost:8000/health

License

MIT

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FastAPIIn code
FlaskIn code
HTMLIn code
Hugging FaceIn code
JavaScriptIn code
OpenAIIn code
PythonIn code
ReactIn code
Tailwind CSSIn code

11 of 11 appear in the indexed code.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

526 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.