Build a machine with your AI

Your own AI can design a complete machine over MCP, check its work against the same simulation the game runs, and save it to your account.

What this is

A machine in HCC Pinball Arcade is one JSON document — a playfield, the devices on it, and rules over the events they raise. It is data, never code, and that is what makes it safe to let an AI write one.

These steps give the AI you already use a set of pinball tools: start from a working template, validate against the same checks the server runs, play ten thousand headless balls to find anywhere the ball gets stuck, read the rules back in plain English, and save the result to your account.

You are not hosting anything. MCP calls the small program below a “server”, but it is a helper your AI starts on your own computer and talks to through its input and output. It opens no port, has no address, and is reachable by nobody. Your machines stay on this site exactly as they do when you use the Builder in a browser.

There is no address to paste into ChatGPT or into Claude on the web or a phone. Those reach servers over the internet and never start a program on your machine. The five below do.

  • Node.js 22 or newer.
  • Any signed-in account, to download the tools and use the offline ones.
  • Pro, to make a key — which is what lets the tools save to your account.
  • Claude Code, Claude Desktop, Cursor, VS Code or OpenAI Codex.

Step 1 — Download the tools

Sign in, open your account page, and find “Builder API and AI tools”. Press “Get the download link”, then save the file. It is one JavaScript file with no dependencies and no installer. The link is signed and lasts ten minutes; press the button again for a fresh one.

Step 2 — Check the file is the file

Worth thirty seconds, because this is a program you are about to let your AI run. Compare the result with the digest printed beside the download link. If they differ, delete the file and download it again.

Windows:  Get-FileHash .\hcc-pinball-mcp-0.1.0.js -Algorithm SHA256
macOS:    shasum -a 256 hcc-pinball-mcp-0.1.0.js
Linux:    sha256sum hcc-pinball-mcp-0.1.0.js

Step 3 — Put it somewhere permanent

Your AI will run this file by its full path, so it needs to live somewhere it will not be tidied away. A downloads folder is the wrong place. Windows: C:\Tools\. macOS or Linux: ~/tools/.

Run it once to check. It should print one line about not finding a key and then wait. That is correct: it is waiting to be spoken to over its input and output, not listening on the network. Press Ctrl+C.

Step 4 — Make a key

On the account page, name the key after the thing that will hold it, choose what it may do, and press “Make a key”. The key is shown once. Copy it immediately; afterwards the page shows only its first eight characters, which is why a leaked list of your keys is not a list of working credentials.

Leave “Publish to the arcade” unticked at first. Publishing is the irreversible one: a published version is frozen for ever and gets its own leaderboard. You can make a second key later.

  • Read my machines — list your machines and read any version of your own.
  • Create and save drafts — make machines, save drafts, remix, run the server-side check.
  • Publish to the arcade — put a version where other people play it.

Step 5 — Connect your AI

Replace the path and the key with your own. On Windows, every backslash inside a JSON file must be doubled, or use forward slashes; that single detail is the most common reason a setup silently does nothing.

VS Code keys its object “servers” where Claude Desktop and Cursor use “mcpServers”, and Codex needs the underscore in mcp_servers. Copying one host’s file into another without changing that key is the second most common reason.

Claude Code:
claude mcp add hcc-pinball -e HCC_PINBALL_API_KEY=hpk_your_key -- node C:/Tools/hcc-pinball-mcp-0.1.0.js
Claude Desktop (claude_desktop_config.json) and Cursor (.cursor/mcp.json):
{
  "mcpServers": {
    "hcc-pinball": {
      "command": "node",
      "args": ["C:/Tools/hcc-pinball-mcp-0.1.0.js"],
      "env": { "HCC_PINBALL_API_KEY": "hpk_your_key" }
    }
  }
}
VS Code (.vscode/mcp.json):
{
  "servers": {
    "hcc-pinball": {
      "type": "stdio",
      "command": "node",
      "args": ["C:/Tools/hcc-pinball-mcp-0.1.0.js"],
      "env": { "HCC_PINBALL_API_KEY": "hpk_your_key" }
    }
  }
}
OpenAI Codex:
codex mcp add hcc-pinball --env HCC_PINBALL_API_KEY=hpk_your_key -- node C:/Tools/hcc-pinball-mcp-0.1.0.js

Step 6 — Check it worked

Ask your AI what pinball tools it has. There are sixteen. Eight work offline with no key: a template, the validator, the ten-thousand-ball soak, the shot harness, the rulesheet, the content screen, the document hash, and an export to a file the Builder can open. Eight more talk to your account: listing, reading, creating, saving, remixing, the server-side check, publishing, and a link back into the Builder.

If only the Builder link appears from the second group, the program started without your key. Check the spelling of HCC_PINBALL_API_KEY and restart the application completely.

Building a machine

Now just ask. A first conversation that works: “Build me a 1990s dot-matrix machine about deep-sea salvage. Three balls, a multiball, and one wizard mode. Read the format guide first. Don’t publish it.”

A good AI reads the format, starts from a template, edits and validates in a loop, reads its own rulesheet to catch a mode nothing can start, soaks the machine until nothing gets stuck, tunes the shots by their make rate, and saves a private draft. Then it hands you a link and you test play it in your browser.

Publishing is not something to leave to an AI. It needs the publish scope and an explicit confirmation, and your first published machine is read by a person before it appears in the arcade.

Without a key, or without Pro

The offline half needs nothing at all. Your AI can design a complete machine, validate it, soak it and tune it, then write it to a file. Open the Builder, press “Open a file”, and choose it. Designing and test playing are free for everybody, with or without an account.

What Pro buys is the machine surviving: saved to your account, opened on another device, and published so other people can play it.

Troubleshooting

  • Nothing listed at all — the config was not read. Restart the application fully and check the file parses.
  • Only the Builder link from the account tools — it started without a key.
  • “That key is not one this account gave out” — wrong, truncated or mistyped key.
  • “That key was revoked on the account page” — make a new one.
  • “That key was not made with the machines:publish scope” — working as intended; make a key with publish ticked if you mean it.
  • “Building machines from your own tools and AI is part of Pro” — the account is not Pro.
  • A SyntaxError on startup — Node is older than 22.
  • Every refusal carries a request id. Quote it if you write to support.

Keys, and looking after them

A key lives in your AI’s configuration file in plain text, so treat that file the way you would treat a password. The program never writes your key anywhere and removes it from anything it prints.

Revoke a key from the account page and anything using it stops on its next request. Revoking is instant and safe; if you are unsure about a key, revoke it. You may hold five live keys at once and each expires a year after it is made.

A key reaches the Builder and nothing else. It cannot touch your subscription, your account, your headsets, or anybody else’s machines.

What leaves your computer

The offline tools send nothing. The simulation, the validator, the soak and the shot harness all run on your machine.

The account tools send the machine document you are saving, and the identification block every client of this product sends: which kind of client, its version, and a request id. Nothing else.

Handing this to your AI instead of reading it

All of this is published where an assistant can fetch it, so you can skip the reading and say: “Read https://pinballgame.ca/docs/connect.md and set yourself up to build me a pinball machine.”

An assistant that can start a program on your computer can do the rest of the setup itself from that one link. One that cannot, which means anything running in a browser or on a phone, will read the same document and tell you so.

  • https://pinballgame.ca/docs/connect.md — this guide as plain Markdown, for a machine.
  • https://pinballgame.ca/docs/developers.md — the API reference, the same way.
  • https://pinballgame.ca/llms.txt — what this site offers and where to read it.

The Builder API and MCP reference

Common questions

What is the HCC Pinball MCP server?
One JavaScript file you download from your account page and your AI runs on your own computer. MCP — the Model Context Protocol — is how an assistant is given tools, and this one gives it twenty-four pinball tools: start from a template, pick parts off a palette and place them, draw a picture of the playfield to show you, validate, soak ten thousand balls through it, measure a shot, read the rules back in English, and save, remix or publish to your account.
Do I have to run a server?
No, despite the name. Your AI starts the program, talks to it through its input and output, and stops it again. It opens no port, has no address, and nothing on the internet can reach it. There is no hosting, no account on anything else, and nothing left running when you close your assistant.
Do I need Pro to use it?
Any signed-in account can download the tools and use the offline half of them — template, validate, soak, shot harness, rulesheet, and writing the machine to a file you can open in the Builder. Pro is what lets you make a key, and a key is what lets the tools read and write machines on your account.
Is a machine my AI builds any different from one I build by hand?
No. It is the same JSON document, checked by the same validator, held to the same budgets, screened by the same moderation, and played by the same simulation. A machine is data rather than code here, so there is nothing an AI can put in one that the game would execute — which is the reason this is offered at all.