Inspiration
Turn-based tactics games and AI agents have the same problem in common: both live or die on whether the information you're given is worth acting on. A guard cone tells you where not to walk. A tool result should tell an agent the same thing. Once we saw that overlap, the question wasn't whether to build a game with an agent in it — it was why every other WebMCP demo we'd seen hadn't.
What it does
NULLRUN is a turn-based stealth roguelite that can be played two ways: co-op, with a human and an AI agent working the same floor, or agent-solo, with the AI driving the whole infiltration by itself.
In co-op, the human runs the operative through the facility on foot — walking, sprinting, hacking a terminal, grabbing intel, putting a guard down when there's no route around one. The agent never touches those controls. Its job is the building's own systems, worked over WebMCP — pinging the camera network, looping a feed, sealing a door, killing the power, rerouting a patrol. Each side draws from its own resource, action points for the body and bandwidth for the network, so neither role can just muscle in and do the other's job. In agent-solo mode, that same agent drives both halves at once and clears the floor with no human at the table — the tool surface was built so an agent arriving cold can just start acting.
There are five floors, and each one draws its own complication from the run's seed: a skeleton crew that's nothing but hunters, a blackout that's already underway when you arrive, a floor that opens hot, doors locked from the start, loot worth nearly double. Inside a floor, an escalation clock only ever climbs — guard sweeps tighten, then a hunter gets sent in, then the whole building locks down — which means standing still stops being the safe play. Five kinds of guard each counter a different tool: cut the power and a thermal drone doesn't care, throw a distraction and a bolted-down sentry ignores it, but a bloodhound will hear you from twice the usual distance. Fourteen implants carry over between runs, ranging from small conveniences to ones that rewrite a rule outright — one turns every takedown into a discount against the alarm instead of a cost.
Why WebMCP fits this project
NULLRUN runs on a turn clock, and MCP tools don't carry state between calls — which meant every network-layer action could map directly to a single tool invocation with no session leakage or race conditions. The systems the agent interacts with (cameras, doors, patrol routes, power grid) are naturally discrete operations, a one-to-one match for MCP's tool and resource model. A guard's vision cone and a tool response do the same job: they bound what's safe to do next. We built the facility's infrastructure as MCP tools so any agent — not just the one we shipped — could walk in, read the tool manifest, and start acting without setup.
How it improves the experience
Playing co-op, the human never context-switches away from the game — no terminal, no separate dashboard. The agent runs the same facility the player character is inside, through the same protocol layer. Human input covers movement, stealth, and physical interaction; the agent covers camera manipulation, door control, and patrol interference. Separate budgets (action points for the player, bandwidth for the agent) prevent either role from dominating. Two people doing one job from opposite ends, rather than one person driving a script.
What becomes possible with people and agents together
The alternative before MCP was a scheduled automation script — it fires the same calls regardless of what changed on the floor, and it falls apart the instant something goes off-script. NULLRUN's agent consumes the live game state, adapts its next move to the current layout, and spends bandwidth on whatever matters right now. The human says "loop camera on floor 3, seal the east stairwell," and the agent executes both while the human relocates. When nobody's at the keyboard, the agent handles both halves of the infiltration solo. The key design choice: the agent controls things the player character physically cannot (power, patrol routing), so the two roles don't overlap — they interlock.
How WebMCP is wired in
Every building subsystem registers as an MCP tool: loop_camera_feed, seal_door, cut_power, reroute_patrol, ping_camera_network, disable_alarm_zone. On floor load, the agent gets the tool manifest and can enumerate additional resources through the standard MCP discovery flow. The game server is the MCP host — each incoming tool call gets checked against the agent's remaining bandwidth, then applied to the world state. Plain MCP over stdio, nothing custom. Identical tool surface whether a human is in the loop or the agent runs the whole floor.
Log in or sign up for Devpost to join the conversation.