I Built a 3D Multiplayer Trading Floor — With AI Agents Doing the Heavy Lifting
Every trading app looks the same: a chart, an order ticket, a positions table. Functional, joyless, identical. Meanwhile the most iconic image in all of finance — the NYSE floor, the pit, the bell, people shouting at screens — exists nowhere you can actually go. So I built it. A GTA-feel trading floor that runs in your browser: walk around as an avatar, see other real traders walking around too, talk to whoever's near you over voice chat, watch the wall of live market screens, and place real trades on real on-chain markets without leaving the world.
I'm a solo founder. There is no graphics team, no netcode team, no animation department. What there is, is Claude — Anthropic's coding agent — running in my terminal. This post is an honest accounting of how that worked: what the AI built, what I built, where it was magic, and where it confidently shipped bugs that took a day to find.
The idea
xXTrade is a frontend for Hyperliquid, a decentralized exchange with fully on-chain order books. The "normal" app exists and works. The floor started as a question: since the trading backend is just an API a browser can sign requests against, what's stopping the frontend from being a place instead of a page? Nothing, it turns out, except a few thousand hours of engineering I didn't have. The premise that made it feasible: agentic coding had gotten good enough that one person plus an AI could plausibly do the work of a small game studio, if the person supplied direction and taste and the AI supplied volume.
The stack
- Three.js for rendering. No game engine, no WASM build of Unity — a plain web app that happens to contain a building. Loads like a website because it is one.
- A small presence relay on Railway for multiplayer. Each client streams position/orientation snapshots; the relay fans them out. Deliberately dumb — no server-side physics, no authority. For a social space (not a shooter), trust-the-client is the right call and keeps the server tiny.
- WebRTC proximity voice. Peer-to-peer audio, with a TURN relay (Cloudflare) for the strict-NAT cases where direct connections fail. Voice attenuates with distance, so conversations are local — walk away from a conversation and it fades, exactly like a real floor.
- Hyperliquid for the actual trading. This is the part that makes it not just a toy: the screens show real markets, and the trades you place from inside the world are real on-chain orders, non-custodial, signed by your own wallet.
What Claude actually built
I want to be precise here, because "AI built my app" usually means either "AI autocompleted some functions" or is marketing. Neither applies. These are systems where the agent did the genuinely hard engineering:
The lighting pipeline
The difference between "programmer art demo" and "place that feels real" is almost entirely lighting. Claude implemented shadow-mapped key lights, ambient occlusion, bloom, image-based lighting from the hall environment, and a color-grade pass — iterating against screenshots I captured with a small headless rig, so each round of feedback was "here are six renders, the balcony reads flat, the parquet specular is too hot." It would read the render code, hypothesize, patch, and we'd re-shoot. That loop — agent writes graphics code, human judges images — turned out to be the single most productive pattern of the whole project.
Mocap-retargeted NPC walks
Procedural walk cycles look like procedural walk cycles. The fix was retargeting real motion-capture data (the CMU mocap database — research-grade captures of real humans walking) onto the floor's avatar skeletons. Retargeting is fiddly, mathematical, joint-mapping work that I would never have attempted solo. Claude wrote the retargeting pipeline, plus the layers on top: per-NPC gait individuality, head-gaze toward nearby players, foot-aware steering. The crowd doesn't loop one animation; people on the floor walk like people.
Multiplayer interpolation
Raw network snapshots at relay rates look like teleporting mannequins. Claude implemented snapshot interpolation — buffering remote players' states and rendering them a beat in the past, smoothly interpolated — the same technique real multiplayer games use. Other humans now glide around the floor convincingly even on bad connections.
And a hundred smaller things
Device screens that detect their own display plane geometrically. NPCs with jobs (there is a cashier; there is a service desk). Crowd-life systems. A deep link (?floor) so you can send someone straight in. Each of these was a session of "here's what I want, here's the constraint" followed by the agent doing an afternoon of work in minutes.
What the human did
Direction, taste, and verification — which sounds smaller than it is.
- Choosing what to build. The agent doesn't know a trading floor needs a bell, or that voice should be proximity-based, or that the right vibe is GTA-not-Bloomberg. Every system above started as a human sentence.
- Rejecting what looked wrong. AI graphics code compiles and runs and is frequently aesthetically wrong in ways only eyes catch. A lot of my job was being the eyes.
- Catching confident bugs. An honest example: a crowd-simulation change once shipped where the crowd was being simulated, steered, and animated — and was invisible. Everything ran; nothing rendered. The agent was sure it worked because the code was correct in isolation. Cross-network voice, NAT traversal, multiplayer sync — anything touching two machines needed real two-device testing that no agent can fake. I spent real evenings as both test users at once.
- Architecture calls with consequences. Dumb relay vs authoritative server, browser-first vs engine export, non-custodial always — decisions where being wrong costs months. The agent argues the options well, but someone has to own the bet.
If you forced me to put a number on it: by code volume, the large majority is agent-written. By decisions, it's the other way around. Both halves were necessary; neither was sufficient. The honest framing isn't "AI built this" or "AI assisted" — it's that the agent was the engineering team and I was the studio head of a studio of one.
What surprised me
- Graphics programming is a sweet spot for agents. Tight feedback loops, self-contained math, screenshot-verifiable results. The lighting work would have taken me months to learn; the loop with the agent took days.
- The bottleneck moves to judgment. When implementation is nearly free, the scarce resource is knowing what's worth implementing and whether it's actually right. My days became mostly reviewing, testing, and deciding — which is a strange and slightly vertiginous way to build software.
- Verification doesn't compress. The agent writes code 50x faster than me. It does not test multiplayer voice across two networks 50x faster than me, because that takes two devices, two networks, and a human ear. Plan for it.
Walk the floor yourself
The floor is live, in the browser, no install: app.xxtrade.xyz/floor. Walk in, look at the screens, find another trader and say hi — exploring costs nothing, and trading from inside is entirely optional (and, obligatory note, risky — see our perps explainer before touching leverage). If you're curious what one person plus an AI agent can ship in 2026, this is my best evidence.
FAQ
What is the xXTrade trading floor?
A 3D multiplayer NYSE-style floor in the browser: walk as an avatar, see real traders, talk over proximity voice, watch live market screens, and place real on-chain trades from inside the world.
What was it built with?
Three.js rendering, a Railway presence relay for multiplayer, WebRTC proximity voice with a Cloudflare TURN fallback, and Hyperliquid's on-chain order books for real trading — with Claude, Anthropic's coding agent, writing large parts of the engineering.
Did AI really write the code?
Most of it by volume — lighting pipeline, mocap retargeting, netcode interpolation included. The human side was direction, taste, architecture bets, and real-world testing. Both were necessary.
Can I try it?
Yes — app.xxtrade.xyz/floor, free to walk around, no install.