Product
Architecture

AUXTA is structured as three connected layers that share a unified data model but operate independently. Understanding how Core, Console, and Match interact is key to a successful integration.

Data Flow

Your backend writes entity state to AUXTA Core on session events. Core stores these as behavioral vectors. At decision time — matchmaking, offer logic, LiveOps rules — Core resolves segment queries in real time.

AUXTA Match then consumes Core candidate queries to fill matchmaking queues, apply match rules, and emit match results back to your session layer.

The AUXTA Console provides observability, configuration, and simulation UI across both Core and Match — allowing LiveOps managers and engineers to debug, adjust, and rollout changes without a backend deploy.

// 1. Your backend writes to Core on session events
core.record("players", {
  id: "player_123",
  dimensions: {
    mmr: 1840,
    consecutiveLosses: 3,
    churnRiskScore: 0.72,
    region: "eu-west"
  }
});

// 2. Core resolves segment query live (<0.2ms)
const candidates = core.query("players", {
  mmr: { gte: 1750, lte: 1950 },
  region: "eu-west"
});

// 3. Match groups candidates into a match
match.evaluate(candidates, queue_rules);

Phase Overview

Quick
Start

Get AUXTA Core running locally and make your first real-time segment query in under 10 minutes.

Step 1 — Start Core Server

# Pull and start AUXTA Core
docker pull auxta/core:latest
docker run -p 7700:7700 \
  -e AUXTA_API_KEY=your_key_here \
  auxta/core:latest

Step 2 — Create an Index

POST /indexes
{
  "name": "players",
  "primaryKey": "id",
  "template": "gaming_player"
}

Step 3 — Write a Record

PUT /indexes/players/records/player_123
{
  "id": "player_123",
  "mmr": 1840,
  "consecutiveLosses": 3,
  "churnRiskScore": 0.72,
  "region": "eu-west",
  "sessionLength": 47
}

Step 4 — Run a Segment Query

POST /indexes/players/query
{
  "filter": {
    "mmr": { "gte": 1750, "lte": 1950 },
    "churnRiskScore": { "gte": 0.6 },
    "region": "eu-west"
  },
  "limit": 100
}

// Response in <0.2ms
{
  "matched": 12,
  "latencyMs": 0.14,
  "records": [...]
}

Core Server
Management

View and manage AUXTA Core servers, environments, regions, status, connection health, storage mode, CPU, memory, disk, QPS, and latency — all from the Console.

Environment
Management

AUXTA supports separate Demo, Staging, Production, and region-specific environments. Environments are isolated — changes in one do not affect others.

Index
Management

Indexes are AUXTA's core abstraction. Each index represents a business object — players, matches, sessions, transactions, offers, guilds, events — stored as behavioral vectors queryable in real time.

Built-in Index Templates

Adding a Dimension Without Reindexing

POST /indexes/players/dimensions
{
  "name": "frustrationScore",
  "type": "computed",
  "expression": "consecutiveLosses * (1 - winRate)"
}

// Available in queries immediately — no reindex required

Dimension
Management

Dimensions are the individual fields inside an index. AUXTA supports three dimension types: static, dynamic, and computed. All are queryable in real time without reindexing.

Record &
Vector Browser

Browse records as vectors, inspect current state, dimensions, matched segments, and recent decisions — all in real time from the Console.

What You See

Query Builder
& Playground

Build and test real-time queries over indexes using Builder Mode (point-and-click) or JSON Mode (direct payload). The Playground shows matched records, latency, payload, and response immediately.

Builder Mode vs JSON Mode

API Keys &
Service Tokens

Manage access credentials for Core, Match, webhooks, and backend services. Scopes control which indexes and operations each key can access.

System
Dashboard

The System Dashboard shows active connections, total requests, failed requests, CPU, memory, disk, and storage mode — all updating in real time.

Latency
Dashboard

Show median, p95, and p99 query latency broken down by index, segment, decision, and queue. Use this view to validate SLA targets and identify slow query paths.

Matchmaking
Dashboard

Monitor active tickets, match rate, average wait time, p95 wait time, and match quality score across all queues — in real time.

Logs &
Audit Trail

AUXTA provides structured logs across every layer: system, query, decision, match, worker, action, and audit. Use them for debugging, compliance, and incident response.

Log Types

Execution
Trace

For any query, decision, or match result — view a step-by-step execution path showing exactly what happened and why. This is AUXTA's primary debugging surface.

Trace Steps

Segment
Builder

Create reusable real-time segments over indexes — for example, Frustrated Competitive Players. Segments are live queries: they update the moment a record's dimensions change.

Segment Preview

Before activating a segment, the Segment Preview shows: matched records, coverage %, sample players, median latency, and p95 latency. This lets you validate coverage and performance before any player is affected.

Segment Versioning

AUXTA keeps a full version history of every segment. You can roll back to a previous definition if a change produces unexpected coverage shifts or decision behavior.

Example Segment

{
  "name": "frustrated_competitive_players",
  "index": "players",
  "filter": {
    "consecutiveLosses": { "gte": 3 },
    "mmr": { "gte": 1600 },
    "sessionLength": { "gte": 30 },
    "churnRiskScore": { "gte": 0.55 }
  }
}

Decision
Builder

Define trigger → segment → conditions → action → guardrails → metrics. Decisions fire in real time when a player record satisfies a segment while the configured conditions are met.

Decision Structure

Available Actions

Guardrails
& Safety

Guardrails prevent decisions from firing too frequently, targeting excluded groups, or circumventing fraud protection. They are configured per-decision and evaluated before any action is triggered.

Decision
Simulator

Test how a player vector is evaluated against segments, decisions, and guardrails — without touching production data. See exactly which segment matches, which decision fires, and which action would trigger.

Simulator Inputs

{
  "playerVector": {
    "mmr": 1840,
    "consecutiveLosses": 4,
    "churnRiskScore": 0.71,
    "region": "eu-west"
  },
  "trigger": "session_start",
  "decisions": ["frustrated_player_recovery"]
}

// Simulator output:
// ✓ Segment matched: frustrated_competitive_players
// ✓ Guardrails passed: no cooldown active
// → Action: route to recovery_queue + issue_soft_reward

Experiments
& Insights

Create A/B tests across rewards, offers, matchmaking routing, and progression tuning. Measure outcomes: next session rate, retry rate, reward claim rate, conversion uplift, fraud prevented.

Insights Metrics

Match
Services

View and manage deployed AUXTA Match services by region, environment, connected Core server, status, queues, and workers. Match is a separate runtime from Core — it connects to Core for candidate queries.

Queue
Configuration

Configure matchmaking queues such as ranked_4v4_queue, casual_2v2_queue, and new_player_protection_queue. Each queue has its own rules, ticket schema, candidate query, and expansion policy.

Queue Parameters

Candidate Query

The Candidate Query configures how Match uses AUXTA Core to find eligible players for each ticket. This is AUXTA's core differentiator: candidate search is powered by live player vector queries, not static pools.

{
  "candidateQuery": {
    "index": "players",
    "filter": {
      "region": "$ticket.region",
      "mmr": { "gte": "$ticket.mmr - 150",
               "lte": "$ticket.mmr + 150" },
      "status": "online"
    },
    "limit": 500
  }
}

Match
Rules

Configure team size, skill delta, max latency, region match, party size, platform, and toxicity exclusion. Match Rules control which candidate combinations produce a valid match.

Expansion
Rules

Define how match constraints relax over time as a ticket waits in queue. Expansion rules balance match quality against wait time by progressively widening acceptance criteria.

{
  "expansionRules": [
    {
      "step": 1,
      "afterSeconds": 10,
      "skillDelta": { "increase": 50 }
    },
    {
      "step": 2,
      "afterSeconds": 25,
      "skillDelta": { "increase": 100 },
      "latencyMax": { "increase": 20 }
    },
    {
      "step": 3,
      "afterSeconds": 45,
      "region": { "relax": true },
      "maxWait": 60
    }
  ]
}

Tickets
& Match Results

View live tickets, inspect their lifecycle, and review completed match results. The Ticket Inspector shows the full candidate query trace and rejection reasons — making debugging queue issues fast.

Ticket Lifecycle

Match Quality Score

Every completed match receives a Match Quality Score — a composite metric computed from skill balance, latency average, region fit, party fit, and toxicity risk. Use this score to monitor player experience impact over time.

Match
Simulator

Test a ticket payload through candidate query, match rules, expansion steps, and match result — before any player touches the queue. Validate configuration with confidence.

AUXTA vs
PubNub Illuminate

PubNub Illuminate provides real-time decisioning over Business Objects. AUXTA extends this pattern with gaming-native indexes, self-hosted deployment, and a matchmaking layer powered by the same index infrastructure.

AUXTA vs
PlayFab

PlayFab is a full backend-as-a-service platform. AUXTA targets the decisioning and matchmaking layer specifically — with stronger real-time performance, self-hosting, and execution trace transparency.

AUXTA vs
AWS FlexMatch

AWS FlexMatch is deeply integrated with the GameLift hosting layer. AUXTA offers comparable matchmaking logic as a self-hosted, backend-agnostic service with richer observability and Core-powered candidate search.

AUXTA vs
Unity Matchmaker

Unity Matchmaker integrates natively with Unity Game Services hosting. AUXTA is hosting-agnostic and extends the matchmaking model with live player vector queries from Core.