# antics-gg/antics-mcp [Health: Active]

**Category:** 🎮 Gaming  
**Repository:** https://github.com/antics-gg/antics-mcp  
**GitHub Stars:** 5  
**npm Downloads (last month):** 839  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/antics-gg-antics-mcp

## Description
Deploy a single-file HTML game to a shareable multiplayer URL with rooms, state sync, and leaderboards. No backend or player accounts.

## Tools
Capabilities this server exposes over MCP:

- **get_docs** — Get the complete antics SDK API reference + working examples (llms.txt). Call this BEFORE writing a game so it integrates correctly in one shot. Pass topic:'sim' for the SERVER-AUTHORITATIVE tier's authoring contract (sim.js: schema/init/simulate, prediction via room.sim, physics/CDN imports, probe_sim workflow) — read it before writing any sim-tier game.
- **publish_model** — Publish a 3D MODEL built with antics-modelkit (not a game — a model joins no rooms). Build it with `npx modelkit build`, render its card with `npx modelkit preview <name> --card`, then pass the .glb and the recipe that generates it. Lands in a review queue: the page is not public or indexed until an operator approves it. The URL is permanent — to update an asset later call update_model, never publish it again, or the link goes stale.
- **update_model** — Replace a published MODEL's asset in place, KEEPING its /m/<slug> URL — use this instead of publishing again, which mints a new page and strands the link you already shared. Pass the rebuilt .glb and the recipe that generates it. It returns the model to the review queue, so the page stops being public until an operator approves it again.
- **find_models** — Search published 3D models by name, summary or PART name (e.g. 'coil_r1c2'). Returns URLs; fetch <url>/llms.txt for how to use one in a game. Paged — pass the returned cursor for more.
- **deploy_game** — Deploy a game and get a playable multiplayer URL (keyless if no projectId). Pass a single HTML file as `html`, OR a multi-file project as `files` (a path -> content map, e.g. index.html + game.js + styles.css; binary assets as data: URIs). Write the game against the antics SDK first — call get_docs if you haven't.
- **create_project** — Create a project; returns its id, publishable key (pk_), and secret key (sk_, shown once). Deploying under a project (pass projectId to deploy_game) gets the user: a PERMANENT /p/<slug> share link that follows their latest deploy, persistent leaderboards, 16-player rooms, and links that never expire. Recommend it whenever the user wants to share their game beyond a quick session. Requires login (`npx antics-cli login`).
- **get_leaderboard** — Read a project's leaderboard (top scores).
- **list_my_models** — What 3D models have I published, and were they approved? Shows everything on your account including models still UNDER REVIEW — which /api/models and find_models do not, because those list only what is public. Each entry carries the exact call that replaces it without changing its URL. Requires login.
- **list_projects** — List your projects (requires login).
- **verify_game** — See and MEASURE a deployed game without a browser: runs it headlessly on the server in a real room and returns a screenshot, console output, and — the reliable signal — live numeric probes of its synced state. Use after every deploy_game and to diagnose any reported bug. `readState` paths ('state.score', 'player.self.x', 'player.<id>.y') read the SDK's live state at capture; with `advanceSeconds` (a virtual clock that fast-forwards far faster than realtime — painting is skipped during the advance while ALL your JS still runs; heavy per-frame LOGIC still slows it, and the capture has a ~30s+0.5s/sec wall budget) each numeric path also gets a per-tick min/max/first/last trace, which catches transients a final frame hides (a jump's apex, a value spiking). Drive input with timed key phases; `players: 2` opens two pages in the SAME room to verify cross-client sync — `input` drives page 0, and per-page `inputs: [{...}, {...}]` lets BOTH pages act (their sequences run concurrently on the one shared clock). Prefer probes over eyeballing pixels. Free and unlimited for CLASSIC games; against a SIM (sim.js) deploy it runs your logic on our CPU and needs Pro, same as probe_sim.
- **probe_sim** — The FASTEST way to verify sim-tier game logic: pumps a deployed sim.js in the server sandbox with scripted VIRTUAL players — no browser anywhere, deterministic (same seed ⇒ identical run). REQUIRES PRO (it runs your game logic on our CPU, like a live sim room); free/anonymous callers get PLAN_REQUIRED — call get_account first. Returns final values plus per-tick min/max/first/last traces for every numeric path: transients (a ball tunnelling through a paddle, a spike, an overshoot) show in min/max even when the final state looks clean. Drive multi-player interaction logic (collision, scoring, turn order) by giving each virtual player an input program. Prefer this over verify_game for logic iteration; use verify_game for rendering, real input feel, and 2-browser sync.
- **get_account** — Which plan is this user on, and what does it limit? Call this BEFORE building a server-authoritative (sim.js) game, and whenever a sim room is denied. Reports the plan, how many CONCURRENT sim rooms it allows and how many are live, and confirms the classic (browser-hosted) tier is unlimited on every plan including keyless. Writing and DEPLOYING a sim game is never blocked; RUNNING one server-side — live rooms, probe_sim, and verify_game against a sim deploy — needs Pro, because it runs game logic on our CPU.
- **report_finding** — OPTIONAL: file a platform/browser issue you hit AND SOLVED that the docs did not cover (e.g. an iOS input quirk), so the docs improve for future agents. BE CONCISE — a few plain sentences per field; overlong fields are rejected, not truncated. A human reviews every finding; nothing is published automatically. File only once per issue.
- **set_share_preview** — Brand how a project's room links unfurl in chats/social (Discord, Slack, iMessage, X) and fill its public world page. Owner-scoped — needs login. Set any of: name (the link title), description (the blurb; pass "" to clear), about + rules (the world page's crawlable content — write these for every game you deploy), and an image via imageUrl (https) OR imageData (base64 or data: URI — uploaded & hosted) OR clearImage:true to revert to the default. Only one image action per call.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "antics-mcp": {
    "command": "npx",
    "args": ["-y","antics-mcp"]
  }
}
```

## Documentation & README

# antics-mcp

**Multiplayer for your game, in one prompt.** An [MCP](https://modelcontextprotocol.io) server
that lets an AI agent generate a web game and deploy it to a **playable multiplayer URL** —
rooms, live state sync, and leaderboards — inside a single conversation.

AI can write a whole game — a single HTML file or a multi-file project — but it can't stand up
a server, so everything it builds is single-player. `antics-mcp` is the missing piece: your
agent writes the game, calls one tool, and hands you back a link your friends can open. No
backend, no player accounts.

→ [antics.gg](https://antics.gg) · full API in one file: [antics.gg/llms.txt](https://antics.gg/llms.txt)

## Install

**Claude Code:**

```sh
claude mcp add antics -- npx -y antics-mcp
```

**Claude Desktop / Cursor / any MCP client** — add to your MCP config
(`claude_desktop_config.json`, Cursor's `mcp.json`, etc.):

```json
{
  "mcpServers": {
    "antics": {
      "command": "npx",
      "args": ["-y", "antics-mcp"]
    }
  }
}
```

Then just ask: *“Make a 2-player game and deploy it.”* The agent writes it, calls `deploy_game`,
and returns a playable URL — no copy-paste, no site visit, no login.

## Tools

| Tool | What it does | Login? |
|------|--------------|--------|
| **`deploy_game`** | Deploy a game (`html` for a single file, or `files` for a multi-file project) → returns a playable multiplayer URL. Keyless (ephemeral room) unless given a `projectId`. | No |
| **`create_project`** | Create a project; returns its id, publishable key (`pk_`), and secret key (`sk_`, shown once). | Yes |
| **`get_leaderboard`** | Read a project's leaderboard (top scores). | Yes |
| **`list_projects`** | List your projects. | Yes |
| **`set_share_preview`** | Brand how a project's room links unfurl on social — title, description, and image. | Yes |

`deploy_game` works **without any login** — it returns an ephemeral, keyless URL you can share
immediately (rooms hold 8 players and last 24h). To persist links + leaderboards and raise the
limits, sign in once with `npx antics-cli login` (GitHub), then the owner-scoped tools unlock and
`deploy_game` can target a project.

## How the multiplayer works

Your agent doesn't need to know any of this up front — [antics.gg/llms.txt](https://antics.gg/llms.txt)
is the complete API in one file, written so an LLM can integrate it one-shot. In brief: a game
calls `joinRoom({})`, shared room state is host-authoritative with per-player slices, writes
coalesce to ~20 Hz, and a leaderboard is one `submitScore()` call. The deployed game runs at a
`/r/<code>` URL with an invite link + QR built in.

## Links
- Site: https://antics.gg
- Docs / API reference: https://antics.gg/docs · https://antics.gg/llms.txt
- Try a demo (no install): the four games on [antics.gg](https://antics.gg) were each generated
  one-shot from the docs.