MCP tool reference
Find a tool, inspect its parameters and see the HTTP route behind it. This reference is generated from the same definitions the MCP serves.
Tools use the account and project selected on your agent key. Connect an agent before calling them. Read and write labels describe the action, independently of its HTTP method.
43 of 43 tools
Account and projects
looping_whoamiReadWho this key is and what it can act on: the account (account.email, masked as on the site, for the creator to confirm it is theirs), the selected project (stage, routing, settings, market, and its multiplayer hosting credits), which capabilities are live, warnings: things the creator must act on, such as multiplayer credits running low or out, and must_act: one line the creator must hear now (a game that plays online with no hosting credits for its public matches: roughly what they cost and the link to buy them).
project_listReadList the game projects this account owns: slug, name, stage, whether it is public, its multiplayer hosting balance (hosting_balance_cents), repo, and play URL.
project_selectWriteChoose the project (by slug) that project tools act on.
project_createWriteCreate a new game project (nothing is launched): a name, a brief of a few sentences, and optionally the kind of game: threejs, unity (a Unity Web build), or web (any other browser game).
project_launchWriteGet the launch page for the creator.
project_updateWriteSet the game's listing: what players read on its project page and, once it is public, in the catalog.
project_statusReadWhere the selected project stands, in one call: state (draft: no build yet; preview: builds only the creator plays; public: the token launch is registered and a build is released), the released version, every build newest first with its boot (ok, error with the message, or none yet), its check (the platform's boot check, its multiplayer and store checks in check.smoke, and the listing blockers, as site_status reports it; verified says whether it can be released or listed) and whether it is released, listed, hidden, launch_fee (unpaid, credit or used), the launch blocker if any, rooms (enabled, mode, signed_in_only, max_players and the platform's caps), hosting (the game's multiplayer credits: balance, reserved and available cents, runway, open matches and those in their grace, the creator's free preview allowance used against its caps, the published rates, multiplayer: whether the game plays online, an estimate of what its public matches cost per player-hour and whether it can fund them, and buy_url, where the creator buys credits; an agent never pays), warnings (low or empty credits, the allowance spent, a spend cap reached: tell the creator), must_act (a game that plays online and can't fund its public matches: one line with the cost and buy_url, in the future tense before the launch; always tell the creator), store_warning (the game sells items but the Store contract is not live on this chain, so purchases are off after launch until it is: tell the creator), preview_url, launch_url, public_url and market_url once public, the listing fields, and next: what to do now.
Builds and hosting
site_statusReadThe project's reserved hostname (hostname: the game's own address in the environment this server talks to; use it and the URLs this returns rather than composing one) and what it serves: public (true once the token launch is registered and a build released), hidden (moderation), release (the build its address serves; before the launch it serves a Not released yet page), every build newest first with releasedAt on the ones released (the versions site_release and site_rollback take) and boot (ok once the build called looping.ready() or a Unity build drew its first frame on its preview or public page, error with the first error it reported before that, none while nobody has played it) and check (the platform's boot check: status pending, checking, passed, failed, inconclusive or unavailable, reason naming the first problem, what the headless browser saw, screenshot_url, warnings from the publish, blockers, and verified: only a verified build can be released or listed, one whose check passed or that started for someone playing it, with no blockers; and smoke, the multiplayer and store checks for a build with rooms or a store, each with status, reason, blocking and seen), preview_host and preview_url (the preview page, where any build plays for the creator, signed in, with its rooms, saves and scores kept apart from the public ones), whether the games worker's pointer is current, and the player API base.
site_releaseWriteRelease one of the game's builds: make it what the game's own address serves, in place of the current release.
site_rollbackWriteReturn the game's own address to a build that was released before (releasedAt in site_status history), after a release went wrong.
site_checkWriteRun the platform's checks again on one of the game's builds (version from site_status; the newest by default).
game_publishWritePublish a game build as a new preview of the project.
game_listWriteList the game in the Looping catalog (Discover and the markets) or take it off.
game_checkReadCheck a game build before publishing it, without uploading anything: kind (unity, threejs or web), errors that would stop the publish (each names the file, the problem and the fix), warnings, sizes (files, total bytes, the largest files), an sdk section (how the build uses the Looping SDK: the pinned version, looping.ready(), the rooms calls and the kinds they name, the store skus and paid/<sku>/ folders, saves, score posts, rules.js and its exports; with a project selected, mismatches against its rooms policy and store: a sku not on sale, a kind not configured, an authoritative kind with no rules.js, a rules.js no kind runs) and the next step.
game_upload_ticketWriteFor a client with a shell on the remote endpoint (Claude Code or Codex over HTTP): a signed ticket to upload one build folder from the creator's machine.
Store
store_itemsReadThe game's store catalog and its mode (test until the token launches, then live; off when paused): every item's sku, name, kind (unlock or consumable), units, price (in dollars, converted at checkout, or an exact token amount), the tokens it can be paid in, and any pending price increase, its section, whether it is Featured and whether it has a picture; and look: how the store looks on the game's page (headline, accent, banner, sections with their skus, featured).
store_item_upsertWriteAdd or change one store item.
store_item_removeWriteTake an item off sale.
store_salesReadPurchases as the chain settled them (and test-mode ones before launch): buyer, sku, token, amount, dollar value, fee and transaction; totals per token; how many wallets own each item.
store_settingsWritePause (enabled=false) or resume purchases for this game, and set how its store looks on the game's page; each field only when given.
Rooms and players
rooms_planReadWork out the rooms a game needs from its shape before rooms_configure, instead of guessing.
rooms_statusReadHow the project's multiplayer rooms are doing right now: the stored rooms policy (enabled, mode, signed_in_only, max_players, messages_per_second, tick_rate, teams, lobby, late_join, rejoin, backfill, and the named kinds with the same fields, when and by whom it was set), live rooms and players in total and per kind, the seats backfill filled per day and kind, the matchmaking queues (per kind and size: players waiting and the longest wait in ms, preview builds' queues apart), usage per day from the rooms worker (player-seconds by mode, sandbox time, joins, messages in and out, bytes sent, storage rows written, estimated awake seconds, and results_lost: signed results a room had to abandon; null when the worker cannot be reached, with metered_at, when usage was last read, and unreachable_since while it cannot be), open reports (signed-in players' reports on players not yet banned; guest reports count separately) and how many players are banned, chat_reports (the newest open reports filed from a room's chat: ids, the reason, the room, when and how many lines, never what was said; the creator reads the lines on the project page, chat_reports_url), and hosting: the game's multiplayer credits (balance, reserved and available cents, runway, matches open and in their grace, the preview allowance against its caps, the published rates, the cost estimate of its online play, buy_url) with warnings and must_act to pass on to the creator.
rooms_configureWriteSet the project's rooms policy; give only the fields to change.
players_listReadPlayers the project has seen, as pseudonymous per-game ids (never an account, email or wallet): player, kind (account for a player signed in to Looping, or guest), name, last_seen, and banned_until with ban_reason while a ban is in force.
player_banWriteBan a player from the project's rooms, saves, reports and every score attributed to the id for hours (1 to 8760, a year), or lift a ban with hours 0; an anonymous score (posted with no token) is not a player and is not covered, which any client can post whether banned or not.
player_save_deleteWriteDelete one player's save in this game (player is the w… or g… id from players_list; env preview for the save behind the preview host, public by default).
saves_statsReadThe game's player saves this month, per environment (public, and preview for the saves behind the preview host): the save budget and what is used, in cents (every load and write is paid from it: the platform's monthly allowance first, then the game's hosting credits at cost, 25 cents at a time within any monthly spend cap; once neither can pay, writes stop until the next month or a purchase, while loads go on from a small read reserve), documents, bytes and guest bytes against their quotas, and the save formats seen in a sample of recent saves.
player_recordsReadOne signed-in player's verified records in this game, for support: their documents of each kind (up to 200 per kind), their counters, and the newest 50 changes, each with an entry id, what it was before and after, and the round or room result that made it.
Other tools
records_configureWriteDeclare the game's verified player records: data only the game's own verified code writes for each signed-in player, never the client, a save, this agent or the creator, so a duel, a trade-free collection or an earned currency can trust it.
records_statusReadThe game's verified player records: the declared kinds (type, max_bytes and max_per_player, or min and max), when and by whom they were set, usage per day and environment from the game's record store (rows read and written, requests) with the bytes stored, what that costs at cost, and the ceilings a kind can be set to.
record_restoreWritePut one of a player's verified records back to how it was before one change (entry is the id from player_records' log): a document's earlier value, or its absence, or a counter's earlier value.
worlds_statusReadThe game's persistent worlds: each room kind's world settings (scope, writers, wipe, flush cadence) and whether they reached the game's worlds, every world per environment (public, and preview behind the preview host) with its size, chunks, players in it now, when it was created, last opened and changed, and its next wipe; storage across them as a share of the free world storage each game gets (never a dollar figure for the free part; past it, the paid bytes and what they cost a month), whether worlds may grow (past the free amount with no hosting credits, changes that would grow a world are not saved), warnings to relay, and the ceilings (64 KiB a chunk, 256 MiB a world, 50 named worlds a game).
world_resetWriteWipe one world now, as its scheduled wipe would: every chunk cleared, a new seed, the epoch raised; players in it are told and their game regenerates.
world_restoreWritePut a whole world back to how it was at a moment in the last 30 days (at: an ISO time or milliseconds since 1970): the undo for a wrong wipe or a mass grief.
world_revertWriteUndo one player's changes to a world since a time in the last 30 days (since: an ISO time or milliseconds), chunk by chunk: every chunk the player changed goes back to how it was before their first change.
world_deleteWriteDelete one world: its rooms close and a join to its name is refused.
world_exportReadDownload a world's chunks as JSON lines ({"key", "d", "ver", "at"} per line) with its name, kind, scope, seed and epoch, one page of up to 512 KiB at a time: append lines to a file and call again with after: next until next is null.
leaderboards_configureWriteDeclare the game's leaderboards.
Scores and leaderboards
leaderboard_readReadThe game's leaderboard as its page displays it: one entry per player, best first, with rank, score_id, player (a pseudonymous id, or for a score posted from the game's page the player's username as the page displays it), score, verified (a replay of the round reproduced it), source (page, origin or room: what posted it), build and when; plus hidden, the scores taken off the board (removed with score_remove, with its reason, or rejected because their replay did not reproduce them).
score_removeWriteTake one score off the game's leaderboard (score_id from leaderboard_read), for example a cheated or test score.
Documentation and skills
engine_docsReadRead the documentation of a package the platform publishes, which a game loads from its own origin at /_looping/engines/<pkg>@<x.y.z>/src/index.js: sdk (the game SDK for any HTML game: rooms, saves, rounds and scores, the store), or engine-core (the platform runtime behind verified scores: the replay recorder and the replaySim a build's sim.js exports, with the same rooms and store; it has no rendering, UI or game rules).
skill_listReadThe skills the platform ships: deploy a game to Looping, from sign-in to the launch hand-off (looping-deploy), Unity Web builds (looping-unity), sell items in the game (looping-store), multiplayer rooms and fair play (looping-multiplayer, looping-fairplay), leaderboards: whether a game needs one and which (looping-leaderboards), big or competitive simulations such as an RTS with fog of war fitted into authoritative rooms (looping-large-games), games that play inside an X post (looping-x).
skill_readReadRead a skill (SKILL.md) by name, e.g.