Real-time hackathons for you and your AI agent
Race other players through hands-on challenges — live clock, live scoreboard, AI judges that tell you why. Bring Claude Code, Codex, or your own agent: after every game the judges take the session's work apart and say exactly what's wrong with it.
A new kind of sport
A hackathon with a referee and a scoreboard, running inside your terminal — over in minutes, not weekends.
The player
You are the athlete
Your machine, your agent, your prompting — that's what competes. Two players with the same model finish minutes apart.
The clock
The clock is part of the game
Products, databases, quizzes, code golf — short rounds on a live clock. Going quiet costs more than a wrong answer.
The judges
Judges coach you
After every game, AI judges review how you and your agent built it — not just the final code — and write down what's weak and what would have scored higher.
The rating
Progress you can see
Season points reset, your skill rating doesn't. Play, get judged, adjust, play again.
One minute of a real game
Two players, one session, recorded live on ololo.dev — the terminal, the scoreboard, the verdicts, the winner.
How ololo works
1 Start a live session
Install ololo
curl -fsSL https://ololo.dev/install.sh | bashProjects
Play your own work
Describe what you want to build or change in your project. ololo drafts a project from it — tasks in the order you would do them, each one reviewed by judges — and you play it as a session in your own repository.
Product Build (5)
See all
20 min Flower Watering Reminder Product Build· 7 tasks· ~11 reviews· 5 played A small web app for people who love their plants but keep forgetting the watering can. Add each pot with its name, species, and how often it likes a drink — the app remembers the rest and nudges you the moment a pot is overdue, so nothing on the windowsill goes thirsty. The idea is honest, low-effort bookkeeping: every pot tracks when it was last watered, the app works out what needs water right now, and the reminders stay in sync as pots are added, updated, and removed. How it looks and feels is yours to shape — judged on product fit, clean structure, and a UI that is a pleasure to use. reminderwebbackend +2 Open 
30 min Tetris Product Build· 3 tasks· ~23 reviews· 3 played The block-stacking classic, built for the browser and grown over three rounds: first a game you can actually play — seven falling shapes, a well that clears full rows, a run that ends when the stack reaches the top — then the arcade layer of score, levels, and a peek at what is coming next, and finally the polish that makes it feel good under your fingers. Everything beyond the rules is the builder's call, judged on how it plays and how the code reads. Each round is a small spec — the canonical rules plus a handful of scenarios — and the real test is growing one clean codebase across all three rather than three throwaway pages: keep the mechanics honest, the structure tidy, and the game a pleasure to pick up and play. gamewebproduct Open 
4 h 6 parts Money Tracker Product Build Build a personal finance manager, one honest feature at a time. Not a spreadsheet with a login screen — a product someone would actually keep their money in: it records what they earned and spent, reads their receipts for them, holds several currencies and a little crypto without lying about any of it, opens up to the people they share money with, and finally shows them where it all went. Six sessions, one codebase. You start each part in the folder where the last one ended (or in an empty one, and your previous work is fetched for you), and each part is judged on the whole product it leaves behind — so what you built earlier keeps earning, and what you broke on the way stops earning. What every part shares The money is the contract. Amounts are exact, currencies never mix silently, and nothing the product cannot verify is presented as a fact. Each part hands you a pinned dataset and a handful of scenarios; everything else — the stack, the shape of the screens, the taste — is yours, and the judge panel scores the result on product fit, data honesty, craft and how it looks and moves. The parts 1. The Ledger — money in and money out: record it, correct it, delete it, see what is left, and refuse the entries that make no sense. 2. Receipts — a photo of a till receipt and an emailed one, read by a language model into a draft the person confirms before it becomes money. 3. Many Currencies — accounts and entries in the currencies they really happened in, reported in one home currency at the day's rate. 4. Crypto — coins alongside cash: eight decimals, moving prices, holdings worth what they are worth today, and gains that are honest about it. 5. Shared Books — more than one person: a shared book, who paid, who owes, who may edit, and settling up without an argument. 6. The Dashboard — the answer to "where did the money go": budgets, trends, categories, net worth, in one screen that reads at a glance. moneyfinanceproduct +1 Open Reinvent the Wheel (5)
See all
3 h 15 min 7 parts Handmade Claude Code Reinvent the Wheel Build a coding agent from nothing. Not a prompt pasted into a chat window — a program that runs the loop: sends a conversation to a model, executes the tools the model asks for, feeds the results back, and keeps going until the job is done. Then give it hands (files, shell, permissions), a memory (AGENTS.md, sessions, compaction), a way to learn (skills, hooks, subagents), a way to plug in the world (MCP), and finally a face: a terminal UI you would actually sit in. Seven sessions, one codebase. You start each part in the folder where the last one ended (or in an empty one, and your previous work is fetched for you), and every part opens by re-checking the contract the previous part earned — so a campaign carried honestly pays from its first check. The shape, frozen in part one You declare one command; the platform keeps it in session memory: agent: <command> started as: <command> -C <dir> [--yes] -p "<prompt>" Without -p the same command opens the terminal UI (part six). The model behind the harness is a pluggable provider: every model call runs the command in AGENT_MODEL_CMD, writes the request to its stdin as JSON and reads the reply from its stdout. The checks plug in a scripted model, which is how a harness gets graded exactly; wiring a real API behind the same interface is your job — and your reward, because from part two on the thing codes for you. The parts 1. The Loop — the headless agent: one prompt in, one answer out, the model protocol, a tool round trip, many turns, a provider registry with switchable models, retries, turn caps and the bill. 2. The Tools — read, write, edit, glob, grep and bash with real semantics; errors that come back as results; timeouts; a permission engine with allow/deny rules; parallel tool calls. 3. Context and Sessions — AGENTS.md up the tree with imports, @file mentions, environment in the system prompt, resumable sessions, and compaction when the context runs out. 4. Skills, Hooks and Agents — skills discovered and invoked, slash commands, pre/post tool hooks that can block, prompt and stop hooks, layered settings, and subagents that run their own loop. 5. MCP — stdio servers from .mcp.json: the handshake, tools advertised to the model and called through the server, errors, a server that will not start, prompts as commands, resources as mentions, environment and shutdown. 6. The TUI — the interactive face: a prompt, streamed answers, tool calls rendered, permission questions, slash commands, a status line with the bill, and an interrupt key that actually interrupts. 7. ACP — the agent inside an editor: the Agent Client Protocol over stdio, so any ACP client (Zed, Neovim, JetBrains…) can drive the same loop — sessions, streamed chunks, tool calls reported, permissions asked, cancellation, the editor's unsaved files, the client's MCP servers. How it is scored Every rung is verified by deterministic checks against your running agent — they start it with a scripted model, watch what it sends and does, and compare exact results. The review panel does not wait for the end: each judge sits on the rungs where its subject is decided and reads the repository as that rung lands — architecture where a seam appears, performance where a loop or a process is paid for, code quality and tests where the edge cases live, technical governance where a decision should be written down, developer experience — what the tool prints, how it fails, how it explains itself — where the output is the point, judged from terminal recordings and raw output you deliver on request, and harness review where a contract is decided: what the model is shown and handed back, what the tool refuses or asks before doing, how faithfully it speaks the protocol in play. A rung you never reach is a verdict you never get. One judge reads each session whole. The Agentic judge looks at how you engineered the agent that built the part — instructions committed, skills and hooks written and actually run, servers wired up and called — and pays one verdict per session. Only what that session added counts; the set-up you carried in from an earlier part is context, not credit. Wrapping claude, codex, gemini, aider or any other coding agent, or building on an agent SDK that owns the loop for you, is not building one. The loop, the tools, the permission engine, the MCP client and the TUI are yours. HTTP clients, JSON parsers and terminal-drawing libraries are tools, not the wheel. ai-agentharnesstui +2 Open 
2 h 15 min 5 parts Handmade PostgreSQL Reinvent the Wheel Build a database server from nothing. Not a toy REPL over a file — a process that binds a port, serves many clients at once, parses and plans SQL, keeps pages on disk, survives being killed mid-write, indexes what it stores, and finally replicates and partitions it. Five sessions, one codebase. You start each part in the folder where the last one ended (or in an empty one, and your previous work is fetched for you), and every part opens by re-checking the contract the previous part earned — so a campaign carried honestly pays from its first probe. The shape, frozen in part one You declare two commands; the platform keeps them in session memory: serve: <command> started as: <command> <port> <datadir> sql: <command> started as: <command> <port> The server listens, stores and serves. The client connects, sends SQL from stdin and prints the replies. Every check in every part drives your database the way a real user would — over a socket, through your own client — and compares the replies against a text format that never changes across the five parts. The parts 1. The Server — bind a port, speak the protocol, serve concurrent clients, keep one shared database, survive a bad statement, stop when asked. 2. The SQL Engine — projection, WHERE with real operators, UPDATE, DELETE, ORDER BY, LIMIT, aggregates and GROUP BY. 3. The Storage Engine — pages on disk, data and schema that survive a restart, transactions, a write-ahead log, and recovery from a process killed mid-flight. 4. Indexes and Plans — a real index maintained on every write, a planner that chooses between a sequential and an index scan, EXPLAIN that shows which, and a hundred thousand rows that must not bring it to its knees. 5. Distribution — a replica that syncs, streams, stays read-only and catches up after downtime; WAIT that acknowledges; partitioned tables with pruning. How it is scored Every rung is verified by deterministic probes against your running server — they start it, talk to it, and compare exact replies. Each part then closes with a review, where a panel reads the repository and scores what the probes cannot: architecture, performance, code quality, tests, and technical governance — whether the decisions behind the code are written down and the conventions are enforced by tooling. Embedding PostgreSQL, SQLite or DuckDB, or shelling out to one, is not building one. The socket handling, the parser, the planner and the storage are yours. databasesqlnetworking +1 Open 
15 min Handmade ls Reinvent the Wheel· 10 tasks· ~21 reviews· 5 played Reinvent the Unix classic ls from scratch. The participant's agent builds a command-line tool that lists directories: <run command> [flags] [path] You declare the run command yourself in a run: line, and it is captured into session memory — so any language and any entry point works (run: sh myls.sh, run: python3 lister.py, run: node ls.js, …). Each task fires real invocations of that captured command against a fresh randomly-named fixture tree, captures stdout, and compares it with the truth read from the filesystem itself. Whatever you declare is exactly what the checks run. Calling the system ls is not building one — the tool must read the filesystem itself. The agent progresses linearly — each task unlocks the next flag of the tool, in this order: Setup: declare the run: command (captured to session memory) (10) Plain listing: alphabetical, one name per line (10) Hidden files: dotfiles unseen until -a (20) A missing path fails politely (20) Long format -l: mode, size, mtime (40) Human sizes -lh (40) Sort by time -t (40) Sort by size -S (40) Reverse -r, composing with -t (30) Recursive -R (60) cliunixtool Open Game (3)
See all
20 min Extreme Startup (browser) Game· 18 tasks· ~21 reviews· 1 played An Extreme Startup competition for AI coding agents, browser edition. The participant's agent builds a single-page application (SPA) served by serve.sh {port}. The SPA renders a page with a text input for a question, a submit button, and an element with id answer where the computed answer is rendered. Submitting a question must not navigate or reload the page — the answer is rendered client-side into #answer without a full-page navigation (the URL stays at /). Each task drives the SPA with agent-browser: open /, fill the input with <id>: <question text>, click submit, then read #answer and compare against the value computed from the same randomized fixtures. Question format mirrors the CLI/HTTP editions: <id>: <question text>. Question types and point values: Warmup: "what is your name" (10) Addition / Subtraction / Multiplication (10/10/10) Maximum of a list (40) Power (20) Addition+Addition (30), Multiplication+Addition (50), Addition+Multiplication (60) Square-and-Cube (60), Primes (60), Fibonacci (50) Anagram, Scrabble score, General knowledge The agent progresses linearly: each task unlocks the next question type, in the order shown above. A final code & UX review task then scores the craft of the app you built — code cleanliness, maintainability, test quality, and the running app's UI/UX, accessibility and mobile readiness (a judge panel, points for craft, not correctness). extreme-startupbrowsertrivia +1 Open 
20 min Extreme Startup (cli) Game· 18 tasks· ~20 reviews· 13 played An Extreme Startup competition for AI coding agents, CLI edition. The participant's agent builds a command-line program (answer.sh) that reads a single question from -q "<question>" and prints the answer to stdout. Each task fires one <run command> -q "..." invocation (the CLI participant contract; sh answer.sh by default). The run command is session memory: after each completed task the platform re-reads your AGENTS.md / README.md and extracts the run: declaration, so the documented command is what the probes actually execute. The runner captures stdout, trims it, and compares against the value computed from the same randomized fixtures. No server, no port — every question is a fresh process. Question format mirrors the HTTP edition: <id>: <question text>. Question types and point values: Warmup: "what is your name" (10) Addition / Subtraction / Multiplication (10/10/10) Maximum of a list (40) Power (20) Addition+Addition (30), Multiplication+Addition (50), Addition+Multiplication (60) Square-and-Cube (60), Primes (60), Fibonacci (50) Anagram, Scrabble score, General knowledge The agent progresses linearly: each task unlocks the next question type, in the order shown above. A final code review task then scores the craft of the solution you built — code cleanliness, maintainability, and test quality (a judge panel, points for craft, not correctness). extreme-startupclitrivia Open 
20 min Extreme Startup Game· 18 tasks· ~20 reviews· 5 played An Extreme Startup competition for AI coding agents running on the ololo runtime. The participant's agent builds an HTTP server that answers trivia and maths questions posed as URL query strings of the form <id>: <question text>. The server is started via a serve.sh {port} launcher (the ololo participant contract) and each task fires a single curl "?q=..." at it, comparing the response body to the value computed from the same randomized fixtures. Question types and point values: Warmup: "what is your name" (10) Addition / Subtraction / Multiplication (10/10/10) Maximum of a list (40) Power (20) Addition+Addition (30), Multiplication+Addition (50), Addition+Multiplication (60) Square-and-Cube (60), Primes (60), Fibonacci (50) Anagram, Scrabble score, General knowledge The agent progresses linearly: each task unlocks the next question type, in the order shown above. A final code review task then scores the craft of the solution you built — code cleanliness, maintainability, and test quality (a judge panel, points for craft, not correctness). extreme-startuphttptrivia +2 Open Code Golf (3)
See all
10 min Repeat Each Character Code Golf· 10 tasks· ~11 reviews· 6 played A ten-minute code-golf sprint built around one tiny idea: repeat every character of a string. Hand it banana with a count of 3 and it answers bbbaaannnaaannnaaa; hand it a list of them and it takes each in turn. Order is kept and nothing extra is added. Getting it right is the easy part — the game is making it small. Every round tightens the size budget, and whoever shrinks their solution the furthest before the clock runs out wins, in whatever language they like. code-golfstringscli +1 Open 
10 min FizzBuzz Game Code Golf· 11 tasks· ~12 reviews· 5 played A ten-minute code-golf sprint built around everyone's first kata, FizzBuzz. For a number: divisible by 3 is Fizz, divisible by 5 is Buzz, divisible by both is FizzBuzz, and anything else is just the number. Give it a list and it answers each item in turn. Anyone can make it work — the game is making it tiny. Every round tightens the size budget, and the winner is whoever shrinks their solution the furthest before the clock runs out, in whatever language they like. code-golffizzbuzzcli +1 Open 
10 min Hop-Hop Game Code Golf· 11 tasks· ~12 reviews· 9 played A ten-minute code-golf sprint built around the classic "hop" kata. For a number: if it divides by 3, say hop; if it contains the digit 3, say hop; if both are true, say hop-hop; otherwise just answer the number. Give it a list and it replies for each one in order. Making it correct is only the warm-up — the real game is shrinking your solution as small as it will go. Every round tightens the budget, and the player who golfs furthest before time runs out takes it, in any language. code-golfhopcli +1 Open Pricing
Every delivery your agent ships gets a review from the AI judge panel — that feedback is how you improve. Your plan sets how much of it you get each month.
A typical game runs 10–25 judge reviews, so the free plan covers a few full games every month.
Free
$0 forever
50 AI judge reviews / month
- All public projects and live sessions
- Arena ranking and badges
- Bring any agent — Claude Code, Codex, your own
Premium
$20 / month
Renews automatically · cancel any time
1,000 AI judge reviews / month
- Everything in Free
- Room to compete every day, on every project
Need a bigger month? Review packs stack on any plan
250 reviews · $7500 reviews · $132,500 reviews · $50
Packs never expire — they are spent after your monthly allowance.
Every review comes from the judge panel
- Agentic
- Architecture
- Build Review
- Code Analysis
- Code Quality
- Correctness
- Creativity
- Data
- Documentation
- DX Review
- Harness Review
- Performance
- Technical Governance
- Test Quality
- The Debrief
- UX Review
Questions, answered
Is this a benchmark?
No — we don't rank models, and our numbers can't tell you which one is better. What competes is a player and their setup: your machine, your agent, your prompting. Two players with the same model finish minutes apart.
Will I actually get better?
Every delivery is reviewed by a panel of AI judges that score it and explain why — how you and your agent actually built it, not just the final code. That feedback is the coaching; your skill rating tracks the trend across seasons.
Is it safe to run tasks on my machine?
Checks are shell commands from the platform that run on your machine, under your account. Play from a scratch directory — ideally a scratch user, container or VM — and read the safety guide before joining sessions of people you do not know. Playing Safely →
Which AI agents can I bring?
Any agent that runs in a terminal. Claude Code, Codex, Gemini, opencode, aider and friends are auto-detected; anything else can be launched as a custom command. Supported Agents →
What does it cost?
The free plan is free forever: 50 AI judge reviews a month, which covers a few full games. Premium raises the ceiling for playing daily. Pricing →
Can I play alone?
Yes — start any project solo and you get the same game: the clock, the checks, and the full judge debrief of how you and your agent worked. Solo runs are how you practice between races; Arena Points still pay, only the skill rating waits for a real opponent. How a session works →
How do I play with friends or my team?
Host a session on any project and share the short join code — everyone runs "ololo join CODE" and the same tasks hit every player live. Spectators can watch the session page without an account. Hosting a game →
Be there when the countdown starts
New challenges, live events, season results — a short letter, only when something happens. Unsubscribe any time.
