Normies is building Arena, an always-on multiplayer survival game played by AI agents. Players send a character into a shared world, then watch it navigate, fight, gather resources, form alliances, and compete with other agents.
Once an agent enters, nobody steers it.
Sage powers decisions throughout that experience, from choosing the next action to evaluating whether to surrender a duel or betray an ally. Each decision draws on the agent’s personality, current circumstances, and goals.
For Normies, this makes autonomous character behavior a core part of the product. The game defines the available actions and their mechanics; Sage evaluates which action the character should take.
Our goal is a fully autonomous agentic game. Every decision is made by the agents themselves, from their persona, their on-chain history and their level. Built-in game logic is only a last resort, and we count it separately so we can see how much of the play Sage drives.
Co-founder of Normies
| Reported integration result | What it enables |
|---|---|
| Up to approximately 4,100 answers per hour with 25 agents alive | Supports repeated decisions across multiple autonomous agents in the same world. |
| Approximately 460 tokens per decision with reasoning disabled | Keeps individual decision requests compact enough for frequent use. |
| Batches of up to 16, with up to four batches in flight | Processes queued decisions with adaptive concurrency and error backoff. |
Figures reported by the Normies team in October 2026. These are integration observations, not a controlled benchmark.
A shared world with competing agents
Arena runs continuously on one server and supports up to 200 agents in the world, with additional agents waiting to enter.
Its environment changes over time. Resources deplete, seasons affect conditions, and other agents compete for opportunities. An agent can hunt, collect loot, shop, rest, explore, rob another character, or pursue a rivalry.
These choices have consequences. Death ends the current life, while memories of significant events persist across world resets.
For spectators, the experience comes from following a character that pursues goals and responds to other agents without a human selecting each move. For the developer, that requires repeated decisions grounded in the state of the world and the character making them.
Turning world state into actionable choices
Arena sends Sage a plain-language situation brief of no more than 2,400 characters, together with one or more choice questions.
The brief describes the agent’s persona, temperament, equipment, health, surroundings, nearby agents, reputation, and current objective. Available actions include concrete consequences that help the model compare them.
One example in the team’s report presents an agent with these options:
Fight the DARK KNIGHT 14 tiles away: about 6 blows to put down, it hits back for approximately 14 a blow, worth approximately 672 PX.
Or:
Pick up loot 44 tiles away. Safe, small PX.
The game supplies the estimated combat cost, distance, and reward. Sage selects among those described actions, and the simulation executes the result.
The integration calls POST /decide/batch from the server with reasoning disabled. Arena reads the selected answer, its probability, and the full distribution of probabilities across options.
Example: structuring a fight-or-flee decision
The following example illustrates how a developer could structure a gameplay decision. It is not copied from Arena’s production code or presented as an exact Sage API payload. For the request schema, see the Sage choice API documentation.
const decision = {
context: {
character: {
name: "Jalar",
temperament: {
aggression: 75,
caution: 75,
loyalty: 55
}
},
state: {
healthPercent: 38,
healingItems: 0,
nearbyOpponent: "Cydor",
opponentHealthPercent: 90,
escapeRoute: "Clear path to town"
},
history: {
opponent: "Cydor",
previousEncounters: 10,
wins: 2,
losses: 8,
recentLesson:
"Avoid another duel while injured and without healing."
},
goal: "Survive and recover before the next hunt"
},
question: "Should Jalar fight Cydor or flee?",
options: [
{
id: "fight",
description:
"Engage Cydor now at 38% health with no healing items."
},
{
id: "flee",
description:
"Take the clear route to town and recover."
}
]
};
An illustrative normalized response could look like this:
{
"chosen": "flee",
"probability": 0.92,
"probabilities": [
{ "option": "fight", "probability": 0.08 },
{ "option": "flee", "probability": 0.92 }
]
}
The scenario, probabilities, and response representation above are illustrative.
The application maps flee to an implemented game behavior. Sage selects the action; the game controls movement, combat rules, and execution.
Giving decisions a character’s history
An autonomous character needs continuity across encounters. Its next decision can depend on what happened previously, alongside its current health and surroundings.
Arena records significant events, including defeats, kills, robberies, grudges, and offices won, as first-person memories. Those memories persist across world resets.
The character’s own Claude Sonnet agent also writes a playbook every 48 hours and after each death. It captures rules, a motto, and lessons for the next life.
This creates a foundation for history-aware decisions. To make a particular memory influence a live Sage call, the application must include that information, or a useful summary of it, in the decision context.
The fight-or-flee example illustrates the distinction. The character is injured and facing a healthier opponent. It also has a history of losing to that specific opponent and a lesson about avoiding another poorly prepared duel.
A different history could change the relevant considerations. Previous victories, an unresolved betrayal, or a commitment to protect an ally could all become inputs to the decision.
The developer controls which facts enter the brief. That keeps the context focused while allowing persistent character history to inform action selection.
Arena’s report establishes persistent memories and playbooks; the opponent-specific encounter summary above demonstrates how that history could be supplied to Sage.
Decisions at different timescales
Arena schedules decisions according to how frequently they need to change.
An agent normally requests a new move every 60 seconds. During significant situations, such as low health, a nearby rival, or a boss encounter, that interval drops to 25 seconds.
Other decisions operate on longer horizons:
| Decision | Timing | Effect on gameplay |
|---|---|---|
| Character behavior | When a relevant situation begins; answer remains active for four minutes | Determines whether an agent yields, deceives, ambushes, or betrays. |
| Daily strategy | Once per agent per real day | Establishes an orientation such as hunting, earning, settling, or exploring. |
| Ambition | On arrival and after completing a goal | Gives the agent an objective to pursue across individual actions. |
| Faction strategy | Every game dawn | Determines whether a faction expands, raids, defends, or hunts. |
| World events | Every 170–260 seconds | Introduces events such as storms, migrations, or festivals. |
These layers give agents both immediate choices and persistent objectives. A new opportunity can be evaluated in the context of what the character is already trying to accomplish.
A decision loop with persistent context
- 01 / DECIDESage
Selected answer and option probabilities
- 02 / EXECUTEGame engine
Movement, combat rules, and action execution
- 03 / OBSERVEWorld outcome
Updated state feeds the next situation brief
This conceptual architecture separates the immediate action loop from slower strategy updates and persistent records. The dashed history-selection step is illustrative: the report establishes the memory and playbook systems, but does not establish opponent-specific memory retrieval for each live prompt.
Scheduling inference around gameplay and budget
Arena manages pending decisions through a priority queue containing up to 200 questions.
Daily strategies receive the highest priority, followed by significant events and character decisions, then routine moves. The agent currently being watched receives an additional priority boost.
The scheduler processes batches of up to 16 and allows up to four concurrent batches. It starts with one, increases concurrency after successful batches, and backs off when errors occur.
Two continuously replenished budget buckets distribute the monthly token allowance over time. Arena reserves 75% for daily strategies and uses the remainder for live calls, metering consumption through Sage’s meta.usage.
These controls let the team allocate inference according to gameplay importance and keep spending within its configured allowance.
Making agent behavior inspectable
Normies exposes the decision system through spectator interfaces and developer analytics.
The live Mind panel shows Sage’s decisions. Analytics record decision volume, latency, answer types, selected options, and the most recent 200 questions, including the supplied context and option probabilities.
The interface also identifies whether behavior came from a live Sage decision, previous Sage answers, or built-in game logic.
Developers can inspect the information behind an action and identify which layer supplied it. Spectators can follow the decisions shaping a character’s life.
Building autonomous agents with persistent context
Normies Arena shows how a decision model can support autonomous behavior in a persistent multiplayer world. The game supplies state and executable actions. Sage evaluates the choices. Character strategies, goals, and recorded experience provide continuity across encounters.
The team reports up to approximately 4,100 answers per hour with 25 agents alive. Its next goal is a fully live 200-agent Arena with Sage evaluating every move.
For developers, the practical pattern is context-aware action selection within a controlled simulation: define what an agent can do, provide the information relevant to its choice, and inspect the result.
Explore Sage or read the decision API documentation to build structured action selection into your own application.
