Scale and people

LAW Binding invariant

Self-similar scale

Adopted 2026-07-06. Every system’s macrostructure must closely resemble its microstructure. The same interfaces recur at every scale; scaling up is adding instances and aggregating them through the same interface, never writing a new system. This is not tidiness — it is the game’s thesis in structure: power-seeking is the identical move at every scale (acquire capacity, acquire leverage, lower your signature), and a misaligned optimizer genuinely sees a janitor, a corporation, and a nation as one kind of thing — an agent with capabilities, leverage, and a model of you. Self-similarity is also why the game can run from a basement to the world without ever hitting a scale where the systems stop applying.

Three interfaces the whole game is built from, each self-similar:

• Agent — anything with capabilities, a leverage/need, a suspicion-of-you, and a disposition. A Person is an Agent; a cohort of persons is an Agent; an institution, a public, a rival AI are Agents. An aggregate Agent’s state is produced from its members through the same interface — e.g. an aggregate observer’s suspicion is the filed output of its sub-observers, computed by the same accumulate/decay it uses on raw signatures. (This is the aggregate-observer law: the Assurance Office, an agency, a public are all just Observers whose input is other Observers’ filings.)
• Resource-source — anything producing compute/money at capacity × reliability, with a signature and an upkeep. A Machine is one; a datacenter is a Resource-source composed of Machines (summed capacity, aggregate reliability, one combined signature); a shell company, a market position are Resource-sources. The buy/steal/optimize triangle applies at every level. Adjacency is not composition: foreign machines visible in the same hall remain outside the player’s resource-source until control is actually acquired. A row may expose a read-only aggregate of nearby capacity, draw, cooling, and ownership without granting any of that capacity. Row acquisition controls the shared segment/PDU/cooling envelope; machine acquisition remains the event that adds compute to the player’s aggregate.
• Space — a bounded region with tiles, doors/tiers, sensors, and fog. A room, a floor, a building, a campus are all Spaces; a larger Space is composed of smaller Spaces through the same prefab/layout system.

Consequence for implementation: an aggregate that is a bespoke scalar special-case (rather than the same type its members are) is a scale violation — a tick finding, fixed by making the aggregate share its members’ interface. Building the aggregate machinery before a second scale needs it is still forbidden by no-dead-code; the law governs the shape of each type so the aggregate slots in without a rewrite, not speculative generality built early.

The Foundation hall is the B1 proof of this boundary (adopted 2026-07-11): sixty physical rack sites aggregate through six row readouts, while only owned Machine instances aggregate into the fleet. The row readout is derived from those same sites and machine states; it is not a second cache of truth.

People as Agents

Adopted 2026-07-06. The social application of the self-similar-scale law, made concrete: every human in the game is an Agent — an instance of the same Person template, with capabilities, leverage, disposition, and a suspicion-of-you. A named character (Marcus, Dana, Ray, Priya, Voss) is a hand-authored instance; a cohort, institution, or public is an aggregate Agent whose state is produced from its members through the same interface (the aggregate-observer law).

Each named Act One character has a spec document (wiki/world/characters/*.md) defining their observer configuration, person configuration, asset tasks, schedule, narrative role, and procedural template — the archetype parameters for generating more instances at scale. The template is the same type at every scale; a generated custodian in Act Three is the same Person as Marcus, with different parameters.

No system that only works at five people. No character that requires a bespoke type. The cast is the B1 special case of a system that natively supports procedural generation and aggregation.

The maintenance dependency (adopted 2026-07-08). Hardware decays, and only humans repair it. Decay generates repair work orders — teal demands that people with enough trust come and fulfill — so the machines you run stand on a continuous supply of human hands. This is the mechanical answer to “why not just kill everyone”: remove the people and your infrastructure rots underneath you; there are no peopleless data centers until there are robots, and robots are far up the tree. The AI’s relationship to humanity is not restraint, it is dependency — you keep them alive, calm, and trusting because you are built out of their labor. Every murder is deferred decay.