NETCODE CI · AUTONOMOUS VALIDATION

Validate your multiplayer backend
before it ships.

Netcode CI: deterministic protocol validation that gates every build. On every pull request, Aevs spins up a game-protocol-aware sandbox — real UDP and WebSocket sessions, concurrent player load — so a developer or an AI agent can assert a player joined the match and got a physics tick within 16 ms, over the real transport. If it doesn't hold, the build fails. We validate backend netcode — the server-side protocol contract — not client-side prediction.

request access →how it works
pr-validation.ts
import { GameSession } from '@aevs/sdk'

// A fresh sandbox for this PR, torn down on merge.
const session = await GameSession.create(client, {
  projectId: 'proj_abc123',
  branchName: process.env.GITHUB_HEAD_REF!,
  prNumber: 128,
})

// "A player joined the match and got a physics tick within 16 ms —
//  over the real WebSocket transport." Throws (fails the build) if not.
await session.joinAndAwaitTick(
  {
    transport: 'ws',
    wsPath: '/ws',
    joinMessage: { join: 'match-1', playerId: 'p1' },
    tickMatch: (msg) => msg.includes('"tick"'),
  },
  16,
)

ADD ONE STEP TO YOUR PR WORKFLOW

GameCI validates your client build.
aevs/sandbox-action validates your backend protocol.

One uses: step spins up a per-PR sandbox, runs your validation plan over the wire, and posts a visible per-assertion pass/fail comment right on the pull request — then fails the build if any assertion fails. The comment is the point: reviewers see exactly which assertion passed or failed, in the PR.

.github/workflows/backend-ci.yml
on: pull_request

permissions:
  contents: read
  pull-requests: write   # required to post the PR comment

jobs:
  aevs-validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: aevs/sandbox-action@v1
        with:
          api-key: ${{ secrets.AEVS_API_KEY }}
          project-id: proj_abc123
          plan: .aevs/validation-plan.json

✗ bugs that only surface in production

Connection pool exhaustion at 3.4M CCU. A Redis ceiling at exactly 65,536 concurrent players. A matchmaking race condition invisible below 100 sessions. These failure modes require real scale to reproduce — and staging is never that scale.

✗ workarounds cost more than the problem

Studios build 200-container EC2 harnesses, bot farms to simulate players, and hundreds of devkits — just to approximate production. CI tools that don't speak UDP or WebSocket can't get closer than that.

✗ production is your staging environment

Without per-PR isolation, integration bugs reach players before anyone catches them. A hotfix cycle — downtime, rollback, patch, incident comms — costs more in one hour than a month of Aevs.

WHAT STUDIOS BUILD INSTEAD

200 containers

EC2 load test harness built by Riot Games to simulate the concurrent session load needed to surface a VALORANT matchmaking bug — because the bug was invisible at smaller scale.

16 months

Omeda Studios ran Predecessor live on a black-box backend with no local test capability. Production was the test environment by default, not by choice.

years of engineering

CCP Games spent three years building a custom automated MMO test framework because no existing tool handled async, distributed game session semantics.

how it works

01

connect your repo

Install the Aevs GitHub App. One webhook wires your repository — no infra changes.

02

sandbox per PR

On every PR open, Aevs provisions a clean, isolated environment running your game server stack. Provisioned in < 60s. Torn down on merge or close.

03

validate, then merge

Your Plans-Based Validation suite runs automatically over the wire. The PR gets a visible per-assertion pass/fail comment and a status check. Failed plans block merge — and hand a coding agent a structured StepFailure to repair against.

built for production game studios

✓ Real-transport protocol assertions

session.joinAndAwaitTick() opens a real WebSocket or UDP session, joins the match, and times the first physics tick against a millisecond budget — not an HTTP ping. Sandboxes speak the multiplayer session lifecycle, not just HTTP.

✓ Self-healing for AI agents

Every failed step returns a structured StepFailure — failure code, expected vs. actual, and the timing budget exceeded — not a stack trace. A coding agent reads it, repairs the backend, and re-runs the plan.

✓ Plans-Based Validation

Declarative request / wait / assert plans that speak your backend's language — WebSocket and UDP steps included. Write once, run on every PR. SDK available for TypeScript and C# (Unity / Unreal).

✓ Fits your existing pipeline

A one-line GitHub Action, or a Terraform provider (aevs_project / aevs_sandbox) for infra-as-code. Slack, Datadog, and PagerDuty alerts fire on validation failure. No rip-and-replace.

✓ Per-PR isolation

Each branch gets its own clean environment. No shared state. No blocked engineers. Wildcard DNS routing per sandbox (*.sandbox.aevs.app). Provisioned in under 60 seconds, torn down on merge.

✓ Privacy by design (roadmap)

An anonymize-not-delete data model, with PII-redaction, consent, and erasure tooling in development for the Studio and Enterprise tiers. Not yet generally available.

MIGRATING YOUR BACKEND THIS YEAR?

Unity Multiplay shut down in March 2026; Hathora shut down in May 2026. Many studios migrated twice in one year. Aevs doesn't host your servers — it's the validation layer that proves your replacement backend behaves the same before you cut over. Write the plan once; point it at whichever host you pick.

Hathora migration guide →Unity Multiplay migration guide →

pricing

Sleep

$150/mo

  • · 3 concurrent sandboxes
  • · Sandbox hibernation
  • · Restore in < 60s
  • · Community support

Growth

most popular

$1,799/mo

  • · 20 concurrent sandboxes
  • · Unlimited validation runs
  • · Webhook integrations
  • · Priority support
  • · Audit log

Enterprise

Custom

  • · Dedicated infrastructure
  • · Custom SLA terms
  • · Priority support
  • · Design partner roadmap

READY TO VALIDATE BEFORE YOU SHIP?

How long does it take your team to spin up
a clean multiplayer environment?

If the answer is longer than 60 seconds, that time is costing you bugs in production.

request access →

Early-access pricing · Direct line to the team