When we introduced Metaplay to the world, the mission was to give ambitious studios the same flexibility as internally built backend tech, without the cost or lock-in of building it from scratch. Source code in your repo. Server-authoritative. Customisable end to end. That mission still holds. What has changed is who's doing the work.

Today, your collaborator on a Metaplay project is not always a person. Sometimes, it's an agent. And on most game stacks, agents are still stuck doing the trivial stuff — suggesting one line at a time, when by now they should be balancing your economy and chasing production bugs while you sleep.

What's holding them back is the stack underneath, not the models themselves.

Why agents are stuck on games

Coding agents have rewritten how software gets built almost everywhere except games, for a few reasons specific to how games get made.

Fun is squishy. "Make the boss harder" is not a fix-the-bug spec. Game design targets are subjective and constantly tuned, and agents do their best work when the definition of done is sharp. Every game is built differently - no two studios architect things the same way (and sitting in the middle of many, we see this more than most), so there's no convention for an agent to lean on.

The engines weren't built for agents either: Unity, Unreal, and Godot are assembled through visual editors agents can't click through. And the knowledge isn't written down. Why does the matchmaker treat new players differently after level 14? Maybe Pete knows. Pete left in 2024.

None of this fixes itself, and better prompts won't close the gap. A more cohesive tech stack underneath is what finally does.

The stack we already built

We built Metaplay because we believe backend technology should look like real source code, not a black box with knobs, and live as one vertically-integrated, fully-cohesive system that can be used by anyone on a game team, for any purpose relating to their game.

Concretely, that means things like readable C# in your repo. Typed configs that fail at compile time. Server-authoritative architecture that doesn't rely on messy integrations to keep the client in sync. Sample projects that are full working games. Documentation that covers the why. We made those choices for the humans on the team - easier onboarding, fewer surprises, a codebase a senior engineer could actually hold in her head.

It turns out that's the same shape an agent needs. Structured data, observable runtime, written-down knowledge, fast feedback loops, and source you can read. When reasoning models got good enough in late 2025 to use tools reliably, the work to make Metaplay an agent-native platform was mostly already done.

What AI-ready systems look like in practice

A designer drops a balance brief in chat: "lower friction in the level 20–30 funnel and tighten gacha pity by 10%." The agent reads the live economy configs, runs simulations against player segments, proposes specific numbers with predicted retention impact, opens a PR, and pushes the changes over the air once a producer approves. Twenty minutes from idea to live.

A producer pings the agent about a crash spike. The agent pulls production logs through the Portal MCP, finds a null reference in a guild gift handler that only fires for legacy accounts created before 2024, writes a regression test, and opens a PR. The producer hasn't opened a dashboard.

Three things make this work, and they reinforce each other:

1. Context. Agents need structured access to the source, docs, configs, and live data, which is what the Docs MCP and Portal MCP hand them through a connector you wire up in two minutes.
2. Speed. Metaplay's C# game logic compiles and tests outside Unity in seconds, headless bots play the game without firing up an editor, and OTA updates push content changes without the app-store loop.
3. Guard rails. Server-authoritative architecture rejects invalid actions at the source, typed configs fail at compile time, and unit tests over player state catch the rest before a human ever opens the PR.

The server-authoritative architecture is the load-bearing piece. On a backend that trusts the client, or a black-box service you can't read or test against, you can't let an agent anywhere near production because there's no surface for it to push against safely. Metaplay was built so the rules live in code humans and agents can both reason about, which is what makes letting agents do this kind of work tractable in the first place.

What's here today

Available today through Metaplay AI:

Metaplay Docs MCP. Full SDK source, documentation, and sample games connected to any MCP-compatible agent.

Metaplay Portal MCP. Live production environments - logs, metrics, role management - exposed to your agents through OAuth-bound, audit-logged tools that respect your existing permissions.

Metaplay Agent. A set of agent skills bundled with the Metaplay CLI - install them into your favourite coding harness with metaplay skills install and your agent gets opinionated guidance for authoring game logic, reviewing configs, models, and player actions against Metaplay's rules, and triaging incidents pulled from a dashboard URL.

MetaplayGPT. A ChatGPT grounded in the entire Metaplay corpus, for the moments you want to ask rather than orchestrate.

The same mission, new collaborators

The mission hasn't changed: give ambitious game developers everywhere the tech, tools, and know-how they need to ship like the best, without the cost or lock-in of building it themselves. What has changed is what a team running that mission can do with the same hours in the day. The studios already wiring agents into Metaplay are shipping faster, supporting more games at once, and giving their senior engineers their attention back.

AI hasn't fully cracked game development yet, but we've built a serious head start toward it.

If you want the longer, hands-on version of this argument - the same picture with the technical detail filled in - we've written up what actually works in 2026.

If you want to see what it looks like on your game, talk to us. If you want to start playing with the pieces yourself, the SDK with the Metaplay CLI & Metaplay Agent packaged in is at portal.metaplay.dev, and MCP server access is documented at docs.metaplay.dev.