Automated regression QA for games

Every patch gets played before your players play it.

QuestCover turns each commit into a targeted playtest. An LLM reads the diff, works out which gameplay changed, and steers game-playing agents through exactly those code paths. Regressions surface in CI before a single player sees them.

Join the waitlist See how it works

Unity first. Unreal and Godot on the roadmap.

Assets/Scripts/DashAbility.cs · commit 4f2a9c1 +2 −1
@@ -41,9 +41,10 @@ public class DashAbility : MonoBehaviour
void TryDash(Vector2 dir) {
- if (stamina < DASH_COST) return;
+ if (stamina < DashCost(surface)) return;
+ cooldown = surface == Surface.Ice ? 0.4f : 0.8f;
rb.AddForce(dir * dashPower, ForceMode2D.Impulse);
}
questcover run
questcover / playtest · 4f2a9c1 1 failing check
intent dash cost now depends on surface; new ice cooldown
plan 6 behaviors to exercise · 12 agents · 3 levels
PASS dash on ground, low stamina, denied correctly
PASS dash on ice, cooldown 0.4s observed
FAIL dash on ice into wall: agent stuck 9.3s (frame 2841)
replay + coverage map attached to build #482

Illustrative example of a QuestCover run

Weekly patches. Zero re-test coverage.

Live-service and frequently patched games ship changes faster than any human QA process can re-play them. The result is predictable.

- patch cadence

You ship every week

Balance tweaks, new quests, engine upgrades. Each patch touches systems that interact in ways no changelog captures.

- qa headcount

Nobody re-plays the game

Indie and mid-size studios rarely have dedicated QA. Even when they do, replaying every affected quest line for every commit is impossible.

- player trust

Regressions reach players first

Broken quests and soft-locks get found in reviews and refund requests, where they cost far more than they would in CI.

From commit diff to regression report

QuestCover runs as a CI step. Push a commit, get back a playtest of what that commit changed.

step 01

Read the diff

Every commit's diff and touched game scripts are ingested straight from your repository.

git push → trigger
step 02

Extract changed behaviors

An LLM turns the diff into a structured spec of the gameplay behaviors that changed and where they live.

diff → behavior spec
step 03

Play the affected content

Parallel headless game instances spin up in the cloud, and agents are steered through the spec'd behaviors.

n agents, in parallel
step 04

Report into CI

Crashes, stuck states, broken logic, and a coverage map of the changed code land in your pipeline before merge.

pass / fail / replay

Built like a dev tool, aimed at gameplay

Everything lands where your team already works: the engine, the repository, and the CI pipeline.

## questcoverpatch notes · what ships in the first version

  • Coverage maps of changed code

    See exactly which branches of the modified code the agents reached, so a green build means the change was actually exercised.

  • Crash and stuck-state detection

    Hard crashes, soft-locks, unreachable objectives, and physics traps are flagged with replays and frame references.

  • Unity plugin

    Drop the package into your project, tag your entry points, and QuestCover handles headless builds.

  • CI integration

    Reports post as build checks in GitHub Actions, GitLab CI, or Jenkins. Gate merges on playtest results like any other test suite.

  • Unreal & Godot supportroadmap

    The same diff-to-playtest pipeline for the other two major engines, in the order early-access studios ask for them.

Built on published research

QuestCover productizes SMART, a published method in which an LLM reads a patch diff, extracts intent, and shapes a reinforcement-learning agent's reward so it plays through the changed content. We are turning that proven recipe into a CI step for game engines, starting with Unity.

@method{smart,
  result  = {>94% branch coverage of modified code},
  setting = {research evaluation, not our product metrics},
  role    = {the recipe QuestCover turns into a CI step}
}
In development

Early access for indie studios

QuestCover is being built now. We are looking for a small group of Unity studios shipping frequent patches to shape the first version with us. Tell us about your game and your patch cadence.

Join the waitlist

FAQ

How is this different from unit tests or scripted UI tests?
Unit tests check functions in isolation and scripted tests replay fixed input sequences that break whenever the game changes. QuestCover agents play the game through its real controls, guided by what the current commit actually changed, so the tests adapt to each patch instead of being rewritten for it.
Which engines are supported?
Unity is first, distributed as a plugin. Unreal and Godot support are on the roadmap. If you are on another engine and interested, email us; it helps us prioritize.
What shows up in the regression report?
Crashes with stack traces, stuck states with replays, behaviors the agents could not complete, and a branch-coverage map of the code the commit modified, posted as a check on the build.
Does my game code leave my infrastructure?
Playtests run on headless builds in QuestCover's cloud. The LLM sees commit diffs and the game scripts they touch. Self-hosted execution for studios with stricter requirements is planned.
What does it cost?
Pricing is not final. The plan is per-seat SaaS plus metered playtest compute, with a free tier for open-source and student game projects. Early access studios help us set it.
How do I join the waitlist?
Email founder@questcover.xyz with a line about your game, engine, and how often you ship. We reply to every message.