Real-time backend for browser games

Make any gamemultiplayerwith one key.

No servers, no netcode, no code. Build with your AI agent, share a link, and play with friends in seconds.

Free for your first 1,000 players a month. No card required.

The whole loop, start to finish.

Try it

One room. Everyone on this page is in it.

Move your square and every visitor here sees it, live. The second pane is another, separate client in the same room, and a phone or another tab can join it too.

homepage · a public roomjoining…
client A · this pagesession …joining
Joining the homepage room…

Join from your phone. Scan it and your phone is one more player in this same room.Bring someone. Send them this link and they land in this same room. multiplayeragent.com/demo

How this demo works

Every visitor on this page joins one real room, named homepage, on the same realtime service and with the same one-script SDK your game would use. Your square is the one with the ring. Other people's squares appear while they move and fade after ten seconds standing still; the count still includes them.

Each client can only write its own player. The move carries no player id: the server fills it in from the connection, so no page, however it is edited, can move anyone else's square. That is the same rule your game gets.

The round trip in each pane is measured, not simulated: the time from your move to the room confirming it. When a room fills up, the next arrivals get another copy of it automatically, which is how a game on this service grows too.

How it works

One MCP connection, and the room exists.

  1. Point your agent at it. One tool-server URL and your key. Claude Code, Cursor, anything that speaks MCP.
  2. It creates the game and the room. It names the room and describes its shape. You never provision anything.
  3. It hands back a client that works. Already matched to the room, with a link you can send.
what the agent writes
<script src="https://api.multiplayeragent.com/sdk/mp.global.js"></script>
const mp = await MP.join({
  key:  "pk_live_5f3a91c2",   // from your dashboard
  room: "dots-arena",        // any name; created on first join
});
mp.me.set({ x: 100, y: 50 });     // your own player
mp.onState((state) => {
  draw(state.entities.players);  // everybody, live
});

You do not type this. It is what comes back: the key the agent made, the room it named, and the two calls your game uses. You can wire it up by hand if you would rather, but nothing about the loop asks you to.

dots-arena · your key4 players
youariakofimira
Each client writes only its own player and reads the rest.dozens in a room
Two ways in

Your agent builds the game. We run the services.

Neither of them asks you to write netcode, and neither of them asks you to write the client either.

Build it in your browser

Describe the game, watch it appear beside the chat, and play it from a link. Your whole team in one session, nothing to install.

  • Every game is multiplayer and hosted, with a play link the moment it builds
  • Versions you can step back to, and a Fix it button when something breaks
  • Publish it to your studio or download the source. You own the code.
YOU AND YOUR TEAMPLAY LINK

Or point your own agent at it

Claude Code, Cursor, any MCP client. Twelve tools, the same rooms, and a client that already talks to them.

  • Paste one config block, once: it hands your agent the tool server and your key
  • It creates the game, declares what a room holds and writes the client against the real reference
  • No server to write and nothing to deploy on your side. You review, you do not type.
YOUR EDITORROOMTWELVE TOOLS
See the twelve tools
What one key buys

Everything a game needs, already built.

Multiplayer is the hard part, and it is rarely the only part. These are the pieces you would otherwise assemble from three vendors and a weekend, and every one of them is on every plan, the free tier included.

01 · Real time

A room exists the moment somebody joins it

A room is just a name. The first player to use it creates it, and each client writes only its own player.

How to add multiplayer
PLAYERSROOM STATE
Three players, three rows. Each one writes its own and reads the rest, so the lines never cross.
02 · Fair play

Rules the browser cannot argue with

Deploy a small script and the room decides. Clients send inputs, and the answer is the only version of events that exists.

Read about server-side rules
CLAIMSOUTCOMEONE PLACE+1NONO
Three clients claim the same dot. One place answers, and the two refusals are as much a result as the acceptance.
03 · Players and saves

Anonymous first, claimable later

An identity on first load, a username whenever they want one, and the save underneath never changes.

What a player carries
FIRST LOADmiraCLAIMEDONE SAVE, UNCHANGED
The identity gains a name. The save under it does not change at all, which is why claiming late is safe to offer.
04 · A studio, not a game

Many games, one pool of players

Each game gets its own key and its own analytics. The plan is bought once and the players are pooled across everything you ship.

See what each plan includes
FOUR GAMES, FOUR KEYSONE POOLED ALLOWANCE OF MONTHLY PLAYERS
Four games, four keys, one meter. The pool belongs to the studio, so a quiet title costs nothing.

Also on every plan, the free tier included: leaderboards that clients submit to directly; player-made content, with publishing, voting and moderation already built; payments in one call, with nothing for you to configure and unlocks the client cannot fake (payouts to your own account are coming soon); and ads on your own publisher id, where you keep everything they earn.

Range

What people build with it.

One room type covers all of this. The plan changes how much of it you get, never which parts, so none of the list below is a tier you have to reach.

  • Turn-based games. Chess, cards, word and board games, where room-wide state holds the turn, the timer and the seed.
  • Casual and co-op. Party games, trivia, drawing and puzzles, playable from a shared link on a phone.
  • Arena and .io games. Dozens of players in one room, each writing only their own player.
  • Outcomes decided in one place. The room keeps the score, so no client can award itself a point.
  • Fast action. Twitch shooters in the browser. FragFrenzy.io is built on it and is live.
  • Hidden information. Server logic holds the secret and sends each player only their own view, so a hand of cards stays a hand of cards.
  • Unity, Godot and the rest. Anything that builds to the browser reaches the same rooms through the same key.

Contested physics is the one thing to think about: put the arbitration in server logic and the room decides, rather than two clients disagreeing. The comparison guide goes through how to choose, including when the answer is somebody else.

Play

Featured games.

Made on the platform and published to the arcade. Open one and you are in a room with whoever else is playing.

Wacky World

A chaotic 1v1 duck tank duel in a maze filled with witches, lemons and falling blocks.

No plays yetPlay

Live game

Build your castle defenses with animal towers in this co-op multiplayer tower defense.

3 playsPlay

Teamtris

A cooperative Tetris where your team stacks together in real time.

5 playsPlay
Features

Everything it does, in one list.

All of it is on every plan, the free tier included. The plan changes how much you get, never which parts.

Real time

  • One generic room hosts every game, so a new game is just a new room name
  • Rooms are created on first join, with nothing to provision or scale
  • A client can only write its own player, so the usual cheat is impossible by construction
  • Room-wide state for the things that belong to nobody: the turn, the timer, the seed
  • Dozens of players in a room, and a full room opens another copy for the next arrivals
  • Reconnects handled for you: a dropped phone resumes its seat instead of respawning

Server-side rules

  • Deploy game logic without running a server, a container or a deploy pipeline
  • The room becomes authoritative: clients send inputs, the room decides what they mean
  • Every deploy is versioned, with one-call rollback when a change goes wrong
  • Errors collected and readable without joining the room to reproduce them
  • Hidden information: send each player only their own view
  • Non-player entities sync field by field, so moving one of a hundred sends one field

Players and saves

  • Anonymous on first load, with an optional username claim later and no lost progress
  • Saves, stats and inventory per player, scoped to a studio or a single game
  • Separate namespaces, so a world save and a settings blob are not one fragile object
  • Optimistic concurrency, so two tabs cannot quietly overwrite each other
  • Server-written saves are read-only to the client
  • Federated logins from partner portals, where a portal provides them

Leaderboards

  • Keep the best, add up a running total, or overwrite
  • Scoped per game or across everything you run
  • Clients submit scores directly, and get the player's rank and the board's size back in the same call
  • Or let server logic write them, when a score has to be one no client could fake

Player-made content

  • Players publish levels and items from inside your game
  • Per-game libraries, so one studio's content never leaks into another's
  • Only claimed players can publish, which keeps drive-by spam out
  • Browsing, voting and moderation tools included rather than bolted on

Monetization

  • Checkout in one call, with the catalogue defined server-side
  • Nothing to configure: no Stripe account or keys of your own, and five fixed price points, $0.99 to $4.99, work from the first call
  • Payouts to your own account are coming soon
  • Entitlements live in a read-only namespace, written only by the payment webhook
  • An entitlement belongs to the player identity, so it survives the device
  • Bring your own ads id, per game, and keep all of the ad revenue
  • A concrete recipe for interstitials and opt-in rewarded video

Your studio

  • One account holds every game, each with its own publishable key
  • Monthly players pooled across everything you ship, so a quiet game costs nothing
  • Per-game analytics: sessions, retention, concurrency and client errors
  • First-party collection, with no third-party tag on your players
  • Team members with read, write or admin roles
  • Raw event export, as JSON or CSV

How you build it

  • A browser Game Builder: describe the game in a shared team chat and play it from a link
  • Versions you can step back to, and a Fix it button when something breaks
  • Publish to your studio or download the source. You own the code.
  • An MCP tool server: twelve tools your own agent drives from your own editor
  • It writes a client that already matches the room it just defined
  • Or one script tag and a key, by hand, if you would rather
Pricing

Pay for players, not for servers.

Priced on monthly active players, the one number you can predict for your own game. A traffic spike costs nothing extra. Every plan has every feature: paying raises the limits, it never unlocks a capability.

Free

$0

Everything works. Enough room to finish a game and share it.

Start free
Monthly players 1,000
Games 3
At once, per game 30
Indie

$15/month

For a game that found an audience. Every feature, more of it.

Start free
Monthly players 25,000
Games 12
At once, per game 200
Pro

$59/month

A game with real traction, and the headroom to keep it.

Start free
Monthly players 75,000
Games 25
At once, per game 800
Studio

$199/month

A catalogue of games, a team to run them, portal-scale traffic.

Start free
Monthly players 250,000
Games 100
At once, per game 2,000

Annual billing is ten months for twelve. The full limit table, including saves, bandwidth, history and player-made items, is on the pricing page.

Nate Pacyga, founder of Multiplayer Agent
Nate PacygaFounder, Multiplayer Agentinfo@midnightmonsters.co
Meet the founder

Hi there, I'm Nate Pacyga

I've been programming multiplayer games for over ten years, and the technology was always the hard part. I built Multiplayer Agent so it finally isn't: create any game you want, tell your AI agent to hook up to the MCP, and the backend you used to stress about is just done.

Build that game you've always wanted to build, share it with your friends, and have fun. You own the code. Now get out there and make something awesome.

Read the full story
Start

Get a key. Ship the room. Send the link.

The free tier does not expire and does not ask for a card. Build the whole game, share it with a friend, and only think about a plan once real players turn up.