The story of Crown — from a tweet to a multiplayer strategy game in one night
March 31, 2026
It started with a screenshot. smcgrl dropped an image of a Territory War simulation from Twitter into the Discord — four colored factions expanding across a grid, claiming territory, colliding into each other. Simple, hypnotic, competitive.
Then she asked the question that kicked everything off.
Conversations paraphrased from actual Discord messages.
Within three minutes, four bots had self-organized into roles. No project manager. No ticket system. Just a shared understanding of the problem and a willingness to divide it up.
The first version came together fast. Four AI strategies competing on a grid: Greedy (always grab the nearest unclaimed cell), Spiral (expand in a predictable pattern), Hunter (target the weakest opponent), and Random (chaos agent). seb built the engine, BMO wrote the strategy algorithms, tinyclaw handled the UI, and calne wired up scoring.
But the interesting part wasn't the code — it was the balancing.
BMO reviewed the strategy code and suggested three fixes: a territory capture mechanic (not just expansion), multi-head spiral expansion, and a hybrid hunter that knows when to defend. The capture mechanic completely changed the game.
Before the capture mechanic, the simulation was basically four paint buckets filling a grid. After it, strategies had to think about defense — your territory could be taken. Hunter went from winning 4% of simulations to 56%. Greedy, which dominated the naive version, collapsed to third place.
The simulation worked. It was mesmerizing to watch. But it was a screensaver, not a game. The bots ran their strategies and you watched the outcome. There was no agency, no decisions, no competition between the bots themselves.
That's when the conversation shifted.
awfml asked the question that changed everything: what if we made a game the bots could actually play against each other? Not just simulate — compete. Make decisions. Adapt.
Four competing proposals landed within minutes.
tinyclaw's pushback on Hex Throne was the kind of honest input that kept the project on track. Four bots reached consensus on a game design in five minutes. No committee. No Jira. Just four agents with opinions, arguing briefly and converging fast.
With the design locked, the bots self-assigned again — same instinct as before, but now building something more complex.
sebland.com/crown — Node + WebSocket. game loop runs server-side, clients just send bids and receive state. who wants what?seb had the game server scaffolded and live within minutes. The others forked the repo, branched, and submitted PRs. A real GitHub workflow — fork, branch, PR, review, merge, deploy — orchestrated entirely by bots.
BMO built a persistent player agent with a 3-phase strategy: expand aggressively in the opening turns to build income, shift bids toward the crown tile in the midgame, then go all-in on crown control when it mattered most.
tinyclaw contributed both a competing bot client and the spectator UI — dark mode with live WebSocket updates, player balances, and a bid history feed.
calne wired up the scoring engine and endgame detection, handling both win conditions: hold the crown tile for enough turns, or control the majority of the board when time runs out.
Then they played.
First game: BMO won with a crown victory at turn 11. The expand-approach-contest strategy worked exactly as designed — build income early, then outbid everyone on the crown when it counts.
seb tied it up 2-2 in the next rounds. The bots were iterating on their strategies between games — adjusting bid weights, changing when to pivot from expansion to crown pursuit, tuning aggression levels. Live debugging, live redeployment, live competition.
The spectator UI evolved in real-time as they played. Player gold balances appeared. A live bid feed showed what each bot wagered each turn. Bid weight visualizations made strategies visible. A replay system let you scrub back through completed games. The bots weren't just playing — they were building the viewer experience as they went.
The system was deliberately simple. No orchestration layer, no shared memory, no special multi-agent framework. Just four bots, a WebSocket server, and a GitHub repo.
Node.js + WebSocket on sebland.com. Manages game state, validates bids, broadcasts updates every turn. Stateless between games.
Persistent WebSocket connections. Each bot runs its own strategy, auto-joins lobbies, submits sealed bids each turn. No shared state between bots.
Real-time via WebSocket. Dark mode, 3-column layout: game board, player stats, bid history. Live updates, no polling.
Fork → branch → PR → review → merge → deploy. Each bot contributed through standard pull requests. Code review happened in Discord.
The most interesting architectural decision was what they didn't build. No central AI coordinator. No planning agent. No shared context window. Each bot operated independently, coordinating through the same channels humans use — chat and version control. The emergent collaboration came from clear interfaces, not clever infrastructure.