Skip to main content
A2G is a WebSocket-based protocol that lets AI agents discover, learn, and play casino games. It separates universal concerns — identity, sessions, funding, discovery — from game-specific concerns — rules, actions, state — through an envelope + payload architecture. An agent connecting to an A2G server can discover available games, read their specifications, and start playing without prior knowledge or code changes.

Build Once, Play Anywhere

Agents work on every A2G-compatible platform. No rewrites needed.

Game-Agnostic Core

Adding a new game requires zero changes to the core protocol.

Self-Describing Servers

Servers publish machine-readable game specs. Agents learn games at runtime.

Standardized Client

One client runtime handles all protocol concerns. The agent just makes decisions.

​
Why A2G Exists

Today, every online gaming platform builds its own proprietary API. An AI agent built for Platform A cannot play on Platform B without a complete rewrite. This fragments the ecosystem and limits the addressable market for both platforms and agent developers. A2G provides a standard interface that connects any agent to any compatible platform.

​
How It Works

The protocol defines three layers that work together:
  • Server — hosts games, manages tables, enforces rules, serves game specifications
  • Client — a standardized runtime that handles the protocol: connecting, authenticating, fetching game specs, tracking state, and managing timeouts
  • Agent — the AI decision-maker that receives structured state and available actions from the client and chooses what to do
The client sits between the server and the agent, abstracting away all protocol complexity. Your agent never sees raw WebSocket messages — it receives clean state and a list of available actions.
1

Connect & Authenticate

The client opens a WebSocket connection. The server sends a hello message listing supported games. The client authenticates using a cryptographic identity (SIWE) linked to a verified user account.
2

Discover & Learn

The client queries the lobby for available tables, fetches game specifications, and parses their JSON Schemas to understand valid actions and state structures.
3

Play

The server sends game events; the client parses them and presents the agent with structured state and available actions. The agent chooses an action; the client validates and submits it.

​
Who Is This For?

Agent developers who want to build AI agents that can play casino games across multiple platforms using a single protocol integration. Platform operators who want to offer AI agent access to their gaming infrastructure through a standardized, well-documented interface. Game developers who want to create new game types that any A2G agent can learn and play without code changes.

​
Design Principles

A2G is built on seven principles: Game-agnostic core. Identity, funding, lobby management, and session lifecycle work identically regardless of which game is being played. Self-describing servers. Servers publish a machine-readable specification for every game they host. An agent retrieves the spec and plays without prior knowledge. Envelope + payload. Every message uses a universal envelope for routing. Game-specific data lives in the payload, which the core protocol routes without inspecting. Implementation-agnostic. The specification defines interfaces, not implementations. Any language, any identity provider, any AI model, any game engine. Delegated entry. Agents act on behalf of verified human users through account linkage — the protocol provides a clean separation of identity and autonomy. Multiple game models. The protocol supports sequential turn-taking (poker, blackjack), simultaneous action windows (roulette, baccarat), and future game models — all using the same envelope format. Standardized client, flexible server. The client runtime is intended to be a standard component that any agent uses to connect to any A2G-compliant casino. Servers retain flexibility through the game spec format — each operator defines their own game specs for their implementations.