Join the waitlist

How it works

How Gamestage works for game creators.

This page follows one play through a deployed game, then describes the parts that take part in it.

One play

In a game with a correct answer, a fan taps a choice in the game. The browser sends that choice to the Engine. The Engine checks it against the answer it holds, records the attempt and returns the outcome and the committed score. The browser shows what the Engine returned.

The answer and marking sit on the server, not in the page. This is designed to stop a player reading the answer from the page or editing their score.

Most arcade games rely on gameplay in the browser. There is no correct answer to hold back, so the Arcade Engine makes the game more secure by starting and timing runs on its own clock, issuing a seed, accepting one score per run, refusing reused runs and scores without runs, and checking scores against the run's length and configured limits. Daily run limits can be set, limits stay fixed for an edition, and moderators can void runs. A fair-looking score inside the limits is accepted. Use a checked board without prizes until planned server replay ships. See Arcade for the settings.

Monterosa makes reasonable efforts to prevent common forms of cheating, gives no guarantee, and the terms apply.

The parts

Gamestage has six parts.

The creator's web app or page: your HTML, CSS and JavaScript. It draws the game, takes the fan's input and renders whatever the Engine returns. Gamestage does not edit this for you. Its tooling advises your agent what to write.

The CLI, gamestage: a local tool that inspects a project, scaffolds a new one, writes the browser client and validates the App Manifest, all with no account. Playing the game against the deployed Engine (dev) and checking the migration (verify) each need you signed in and online. Deploying needs that account approved.

The Engine: the server that applies the game's rules, records attempts and accepted scores, and serves the leaderboard. For games with a correct answer, it marks against private material. Arcade checks scores calculated in the browser against run limits. Different Engines support different formats.

Backstage: the API that knows about workspaces, games, plans, limits and deploys. The CLI signs in to it.

Monterosa Interaction Cloud: the platform underneath live games. A Gamestage game is a project on it, a named run of the game is an event, and one go at the game is an element.

Every deployed game is provisioned into Interaction Cloud, Starter included: a deploy always creates its project, event and containers on the platform. Above Starter, your organisation gets a Studio space of its own, and you get Studio access for content and live operations and routing of analytics to your own destinations. A game lands in your space on its first deploy after that. A game you had already deployed stays where it was, so to edit that one in Studio, create it again and deploy the new one. Provisioning happens on every plan.

Monterosa Studio: the platform's own CMS and live operations UI, and where content is managed above Starter. A producer working in Studio can change a game's styling and copy, for example. Gamestage has no content editor of its own.

The request path

FAN'S BROWSER                    ENGINE                        BACKSTAGE
  page + gamestage.js
      │ GET  /play/v1/games/{game}/rounds/current
      │────────────────────────────►│  public part of the round only
      │◄────────────────────────────│  board, labels, prompt. no answers
      │
      │ POST /play/v1/games/{game}/rounds/{round}/plays
      │────────────────────────────►│  marks against the private material
      │◄────────────────────────────│  outcome, feedback, committed score
                                     │
CREATOR'S TERMINAL                   │
  gamestage deploy ──────────────────┴──────────────►│  plan, limits, publish

A fan's browser reaches only /play/v1. The creator's own commands go to a different prefix and use a different credential, which is designed to keep a fan's play requests separate from creator operations.

Why the answers live in the backend

Anything the browser holds, the fan holds. Once the page reaches the fan's machine, the fan can read, change and replay its source, its bundles and every JSON file beside it. If the page works out a score, anybody can send a better one. A limit of three goes kept in device storage can be removed with one line in a developer console.

The page owns what the game looks like and what the fan touches. For games with a correct answer, the Engine marks plays and holds scores, attempts and opening times. Arcade checks the browser's submitted score against a server-timed run.

Move private answers into Studio content or a private dataset. The control plane reads that content and provisions the Engine. The manifest describes the game and holds no round; every command refuses a manifest round. For local practice, gamestage dev reads practice/round.yaml, which a deploy does not upload.

The journey, in one pass

The route has five steps, and each ends in something the next step uses. The journey breaks the same route into finer steps, most with their own command.

Inspect the game. gamestage inspect . reads the source without changing it and reports what the browser owns that it should not: answers, scoring, limits, clocks and locks, each with the file and line. You get an inspection report and a proposed App Manifest.

Move authority. The agent edits the manifest and page, moves private material into Studio content or a private dataset, and changes the page to render the Engine's result. For local practice, put a round in practice/round.yaml, not gamestage.yaml.

Run the rules locally. gamestage dev needs you signed in, then serves your own container through the same rule set the hosted Engine runs, so the game is playable against a real Engine on your own machine.

Verify the result. gamestage verify runs checks against your manifest and the published bundle (the round is the game's own, the attempt cap was chosen rather than defaulted, scanned files in the publish set contain no known answers, the page reads every setting a producer can change, the client is present and is the only door to Monterosa, a deadline comes from the server's clock). It also runs checks that need a real browser playing the game: the screen shows what the server decided, and the page notices the connection going and coming back. Each check ends as verified, open (something is wrong) or skipped (it cannot be checked from here, which is different from failing). The result counts as verified only if nothing is open and nothing is skipped. The leak scan does not inspect binaries or very large files. Assurance records are what the creator recorded, not checks Monterosa made. A passing result covers the checks run, not every possible leak or cheat.

Publish. gamestage deploy <game-id> --dir . publishes a snapshot and uses Studio content for live rounds. A person approves identity and GitHub first, and the account itself has to be approved before a deploy goes through.

The detail of each step is in Build and deploy.

Where a human takes over

The agent does the migration, and a person owns identity, commercial decisions and anything that changes what a live audience can touch. An agent that reaches one of these should stop, say why, and hand over the exact command.

Two commands need a browser and therefore a person:

gamestage login
gamestage link github

login starts a device login flow. The command prints a code and a URL, waits for approval, and creates an account when none exists. The creator token is stored in the macOS keychain, for example, or in an owner-only file outside the project. It is never stored in game code. link github is a second device flow. The first hosted deploy is refused until you complete it. It gives a deployed game a route back to its creator and makes account farming expensive.

Three commands change what fans can reach, so a person decides:

gamestage suspend <game-id>
gamestage wake <game-id>
gamestage archive <game-id>

Suspend takes a game off the air and frees its live slot. Wake puts it back when a slot is available. Archive takes it off the air for good while keeping its record, its claimed id and its files. Delete exists only for a game that was archived without ever deploying: gamestage prune clears those games. Nothing removes a game that went live.

Some inputs cannot be inferred from code. If no existing game format fits the mechanic, a person decides whether it needs a new format or bespoke customer work. Age gates, consent, privacy and promotion rules depend on facts outside the repository. A person also confirms ownership, supplier licences and allowed use, and the operating model: who changes content, who watches a live game and what service level is needed. Record what a person decided as human_decision provenance; an agent's proposal stays proposed.

Only a person can mark a manifest section approved, and the named owner should check the linked evidence rather than the prose. Particular checks: confirm the identity issuer, keys and token lifetime; confirm the minimum age and the basis for it; supply promotion terms, jurisdictions and either a free entry route or the legal basis for a skill competition; and play the final build at phone and desktop widths, because a skipped browser check is not approval. Build stage does not measure accessibility, so a high stage is not evidence of WCAG compliance.

Moving to a paid plan is a conversation with Monterosa. Support creates the Monterosa account and org that a paid customer needs. The service account cannot create an org itself. See Plans and limits.