Menu
 


MCP · OpenAPI · Agent-Friendly

Agent-Friendly Game Server Hosting — MCP & OpenAPI for AI Assistants

Supercraft is the first game server hosting platform built around an agent-friendly API. Plug Claude, GPT, or any custom LLM agent into a clean OpenAPI surface, an MCP-compatible skill, and a tokenized auth flow — and let your assistant compare plans, provision servers, manage live deployments, edit configs, send console commands, and read logs without ever asking the user to log into a dashboard.

Last reviewed: 2026-04-30 · Built for the MCP era — Anthropic Model Context Protocol native

MCP-Compatible API
Game Server Tool for Agents
OpenAPI 3.1
ClawHub Listed
Tokenized Auth
Live Server Controls

Why MCP-Native Game Server Hosting Matters

Most hosting providers expose a customer dashboard and call it a day. That breaks down the moment an LLM agent has to take action on a user's behalf. Supercraft publishes the same surface area in three agent-readable formats — Markdown getting-started guide, OpenAPI 3.1 spec, and a hosted MCP skill on ClawHub — so your agent can discover capabilities, authenticate the user, and operate live game servers with structured tool calls instead of brittle screen-scraping.

The Three-Step Flow Every Agent Uses

  • 01Discover & recommend. Agent reads the public catalog: 30+ supported games, current pricing, regions, plan tiers. Recommends a plan based on user intent.
  • 02Authenticate without sharing credentials. Agent generates a tokenized checkout link (new user) or magic-login link (existing user). User approves in their browser. Agent receives a short-lived token.
  • 03Operate deployed servers. With the token, the agent can start / stop / restart, inspect status, edit configuration via schema-aware endpoints, send RCON console commands, and stream logs — all from a single tool call.

Live Server Operations, Not Just Provisioning

Most "AI hosting" stories stop at signup. Supercraft's agent-facing API is built around the long tail of operations — the conversations users actually have with assistants weeks and months after the server launches.

  • 01Power controls — start, stop, restart, kill stuck processes.
  • 02Schema-aware config endpoints — no brittle text edits, validated mutations only.
  • 03Console / RCON access — send admin commands, broadcast events, kick players.
  • 04Logs & diagnostics — agent reads server output and translates it back into plain language for the user.
  • 05Cross-region transfers — agent can move the server closer to a regional crew without wiping the world.
  • 06Game-switching — same subscription, different game; agent reconfigures the deployment in place.

Discovery That Was Built For Crawlers Too

Anthropic's MCP, OpenAI's function calling, and the GPT plugin format all need machine-readable contracts. Supercraft ships them as first-class assets, not afterthoughts.

  • 01Agent-facing landing pages and Markdown getting-started guides at claws.supercraft.host.
  • 02OpenAPI 3.1 specification and interactive Swagger UI at /docs.
  • 03ClawHub listing — a one-click MCP skill entry point for users who want the assistant pre-wired.
  • 04llms.txt and per-page LLM context blocks so retrieval-augmented agents pick up canonical answers.

30-Second Quickstart for Agent Builders

If you're wiring an LLM agent into a hosting workflow, these are the entry points worth bookmarking:

# 1. Read the catalog (no auth required)
GET https://claws.supercraft.host/api/games

# 2. Generate a magic checkout link for a new user
POST https://claws.supercraft.host/api/checkout/create
{ "game": "palworld", "plan": "M", "region": "eu-west" }

# 3. Operate a deployed server (token-authenticated)
POST https://claws.supercraft.host/api/servers/{id}/restart
GET  https://claws.supercraft.host/api/servers/{id}/logs?since=15m
PUT  https://claws.supercraft.host/api/servers/{id}/config
POST https://claws.supercraft.host/api/servers/{id}/console
                    

Who This Is For

  • 01Anthropic / OpenAI agent builders shipping LLM products that touch infrastructure.
  • 02Support copilot teams automating Tier-1 hosting issues with tool-using agents.
  • 03Internal automation engineers building game-server provisioning into developer portals or Discord bots.
  • 04Indie LLM products that need a clean upstream provider for the "I want a Palworld server" intent.

Who This Is Not For

If you only want raw hosting with a manual web dashboard, the agent-facing layer is overkill. The main game server hosting page is the right entry point — same infrastructure, no agent surface required. The agent API is for builders who want their assistants to do things, not just recommend them.

Start Building

Read the agent-facing guide first to understand the auth flow. Inspect the OpenAPI schema if you're wiring Supercraft into a real assistant. Use the ClawHub listing when you want the hosted MCP skill entry point.

FAQ

MCP (Model Context Protocol) is the open standard Anthropic introduced for wiring LLM agents to external tools and data sources. Supercraft publishes a hosted MCP skill on ClawHub so any MCP-compatible agent (Claude Desktop, custom Claude SDK builds, third-party agent frameworks) can call our hosting API as a structured tool — discovering games, generating checkout links, and operating live servers — without custom integration work.

The agent generates a magic-login or checkout link via an unauthenticated endpoint. The user clicks it in their browser, completes signup or signs in to their existing Supercraft account, and approves the agent. Supercraft returns a short-lived API token to the agent. The agent never sees the user's password and the token is scoped to specific deployments.

No. Supercraft sells game server hosting — Palworld, Valheim, Project Zomboid, Satisfactory, Rust, ARK and 20+ more. The MCP angle is the other direction: we expose an MCP-compatible tool on ClawHub so AI agents (Claude, Claude Desktop, custom MCP clients) can drive Supercraft to provision and operate game servers on a user's behalf. We don't run customer-supplied MCP processes today. If hosting custom MCP processes is something you'd pay for, drop a note on the contact form so we can size the demand.

Per-token rate limits are conservative by default and can be raised on request for production agent deployments. The catalog endpoints are CDN-cached and effectively unlimited for read traffic. Server-mutation endpoints are per-deployment serialized so you can't accidentally trigger conflicting actions even from a high-frequency agent loop.

Brittle screen-scraping breaks every time the dashboard ships a UI change. Supercraft's structured OpenAPI surface is versioned, returns typed responses, and includes schema-aware config endpoints — so an agent can act safely on configuration the user hasn't seen yet, validate inputs before submitting, and fail with actionable error messages instead of a stack trace from a broken Selenium script.

Yes. The OpenAPI 3.1 spec is the canonical contract; MCP and OpenAI function-calling integrations both consume it. If you're building on Anthropic's stack, use the ClawHub MCP listing. If you're on OpenAI, point your function-calling JSON schema at the OpenAPI spec.
Top