Skip to content

Glossary

Each term’s first paragraph is what appears in hover previews across the site, so keep it to one or two sentences.

The game’s self-description sent in the session: world text, world fields, entity types with their observation fields and actions. The service knows nothing about a game beyond it.

See Manifest.

The registration of one running game process with the service: protocol version, game name, engine and manifest. Sent at start and after a 409.

One decision-making object in the game, such as an enemy or NPC. Identified by an id that is unique within the client.

A kind of entity declared in the manifest, with its description, observation fields, actions and decision TTL.

What one entity currently perceives, sent as exactly the fields its type declares.

Values shared by all entities, sent with every decide request as exactly the manifest’s world_fields.

The subset of a type’s actions that the game allows for an entity right now. The provider may only choose from it.

The service’s answer for one entity: an action with source: AI, or source: FALLBACK when no valid choice was made.

A counter the game increments when context is invalidated, for example on a mode switch or scene change. Replies with an old epoch are discarded.

How long a decision stays valid (decision_ttl_ms). After it, the entity returns to native AI until a new decision arrives.

Running the game’s native AI because no fresh, valid decision exists. The default, safe behavior.

The game’s original behavior, usually a finite-state machine (FSM). A2G never replaces it, only overrides it while a valid decision is fresh.

The game’s message about how a decision ended — executed, blocked or expired — with a few outcome values.

The last reports of an entity, kept by the service and shown to the provider with the next decision for that entity.

A once-per-second snapshot of mode, world and entities with their actual states. Used for observability, never for decisions.

Engine-specific, game-agnostic client code: sessions, batching, epochs, TTL, reports and telemetry.

The small game-specific code a developer writes: observe an entity, list its legal actions, execute an action.

A small model trained on the decision service’s logged decisions and evaluated inside the game. Lets a game decide offline at no per-decision cost. Proposed; see Local policy.

The large model whose decisions a local policy learns from, such as OpenAI Decisions or TypeSafe Jev.

The portable JSON file format for local policies: inputs, model (tree, forest, gbdt or mlp) and actions. Any SDK evaluates it with plain arithmetic.

Reference inputs with expected outputs that every SDK must reproduce, so one policy file behaves the same in every engine.

SHA-256 of the canonical manifest JSON without scopes and profiles, returned by /v1/session. Identifies one version of a game’s manifest for the decision cache, logs and local policies.

A label the developer starts after a balance change, so decisions logged under old balance are excluded from training.

The local policy decides when its confidence reaches a threshold; otherwise the service is asked. The main mode for collecting training data.

The service decides while the local policy predicts alongside; agreement shows whether the policy is ready to ship.

A named block of static context — a level, zone or chapter — sent once per request. Scopes form a chain from the world down; a decide request names the active one. See Scopes.

Named static text about one character — name, role, personality — referenced by entities and sent once per request. See Profiles.

An entity linked to a higher-level entity — a squad, faction or director — by parent. Children see the parent’s decision; the parent sees its members. See Groups.

A named reason, declared per entity type, for asking for a decision now instead of on the regular timer; sent as the request’s trigger.

Reuse of a recent decision for an equivalent situation, as defined by the type’s cache key and buckets, shared by all sessions with the same manifest hash.

A per-type cap (max_input_tokens) on the entity-specific part of the model input; entities over it fall back with code: "budget".

How a decision service is exposed and who may open sessions: local (loopback, development), server (game servers with an API key) or client (game clients with a short-lived join token). See Security.

Opaque token returned by /v1/session, bound to one client_id and sent with every later request. Knowing a client_id alone grants nothing.

Short-lived signed token a studio backend gives a game client so it can open a session without any secret in the game build.

Unique id of an AI decision. Reports must reference it, so fake or replayed reports cannot poison an entity’s memory.