A studio building a chain of AI agents for game operations slotted the GameAnalytics MCP Server into their existing stack and used it to answer a question that's hard to answer manually: is each new release actually moving the needle?
Challenge
Zero One ships frequently. Every week, a new build goes out, and every week, the team needs to know the same thing: did this release actually improve the game? Answering that question manually means pulling cohort data by build version, computing per-user metrics, and comparing builds against each other. Done by hand, it's slow. Done by script, it's rigid as every new question (a different date window, a different filter, a different metric) requires editing the script. Zero One wanted this work plugged directly into the AI factory. The data needed to flow into the existing agent chain without a separate scripting layer, and the team needed the flexibility to ask follow-up questions on the spot.
Solution
Zero One built a Cursor skill, internally called Danny (the studio's name for everything analytics-related) that uses the GameAnalytics MCP Server to retrieve cohort data by first install build (first_build). The skill pulls sessions, users, and purchases per cohort over a rolling 180-day window, computes the per-user ratios, and writes the result to a structured JSON file. That JSON file is then picked up by another skill in the AI factory, which combines GameAnalytics data with Firebase data, formats the result, and posts the summary to the team's Slack channel. The whole thing runs on a daily trigger. What makes the setup interesting isn't the individual pieces. It's where the MCP Server sits in the chain: it's one specialized data source in an AI factory that also includes Firebase for analytics, Playfab as a backend on some titles, Gemini for image generation, and Slack for monitoring, plus Zero One's own scripts for the rest, including their interactions with app stores. The MCP Server is the data layer for a specific kind of question: cohort comparison by build, and the rest of the system carries the work onward from there.
About Zero One
Zero One is a mobile game studio based in France building mobile titles that are actively running and updating. For some time, the team has been working on what they call an AI factory, a chain of AI agents that handles the operational side of running and growing live games, from idea generation to monetization optimization.
The goal isn't full automation. It's semi-autonomy. The agents handle the repetitive, time-consuming work so the team can focus on the parts of game development that benefit most from human attention: talking to players, designing better systems, and making good calls on strategy.
The AI factory runs in Cursor, with each agent built as a specialized skill that the master orchestration script can call as needed.
What it tells them
The output is a per-cohort breakdown: every install build over the past 180 days, with sessions, users, purchases, and the derived per-user ratios. Sorted by sessions per user, the top of the table shows the cohorts that engaged most heavily; the bottom shows the cohorts that drifted away or never landed.
That structure answers the question Zero One actually cares about: whether each new release makes the game better for the people who install it.
Once the data is in Cursor, the team can keep asking, filter by platform, pull a different window, or cross-reference against the engagement metrics from the rest of the pipeline. Ask what changed between two specific builds. The MCP Server fetches whatever the agent needs, on the spot.
The verdict comes out in plain language:
It could tell us 'Yes, recent versions have made an impact' or 'You've wasted your time with those new features.' - Quentin Sallat, Zero One
What the MCP Server gave them that scripts couldn't
Zero One already had data flowing into the AI factory before the MCP Server existed in the picture. They had scripts that pulled data, generated static output files, and fed those into the analysis agents.
The MCP Server added something different: a live, queryable data source the agents can use to answer follow-up questions.
With scripts, every new question needs a new script, or an edit to an existing one, and a rerun. A 90-day window instead of 30 means changing the data retrieval step. Filtering by version means changing the data retrieval step. Adding a new filter means changing the data retrieval step.
With the MCP Server, the agent can query whatever it wants, whenever it wants. The data layer becomes part of the conversation, not a static prerequisite.
If I want to gather data on a 90-day window instead of 30, I have to edit the data retrieval script, or the agent's skills. - Quentin, Zero One
How the MCP Server fits into modern AI workflows
The Zero One story matters not because it's a flashy single-agent demo, but because it's the opposite. The MCP Server isn't being asked to be the whole AI workflow. It's being asked to be one trusted data layer in a larger system alongside the other tools Zero One has connected in the AI factory.
That's the use case we're building for. Studios don't need a new AI tool. They need their existing AI stack to act on game data. The MCP Server is what makes that possible.
Plug it into Cursor, into Claude Desktop, into your own custom agent loop. Whichever AI tools your team already uses, the MCP Server is the bridge from a tool to your GameAnalytics data.
It was easy to plug and play this specific MCP. - Quentin Sallat, Zero One
How it works
The GameAnalytics MCP Server, available with PipelineIQ Pro, is an open-source bridge that connects your game data to AI assistants like Claude, ChatGPT, Codex, Gemini, and Cursor. Instead of writing custom scripts to query the GameAnalytics API, you let your agent query your data directly and get the analysis back, structured and ready to act on.
For Zero One, that meant turning a static scripting layer into a live database, giving every agent in the AI factory access to the cohort data that tells them whether their work is paying off.
Watch the GameAnalytics MCP Server introduction video:
