Simsorica

Purpose

Simsorica is one protocol expressed as two products and four runtime stages. Everything else is a way to run that protocol at a chosen level of reality.

The protocol is the nondominium economic model: custody rather than ownership, governance embedded in the resource lifecycle, and reputation accrued as bilaterally signed participation receipts.

• The Simulation. A closed research sandbox where AI agents are spawned, observed, and studied. Its purpose is knowledge: to see how the protocol behaves under autonomous pressure.
• The Game. An open multiplayer world where human players learn and practice the nondominium economy, then carry demonstrated competence into a real network. Its purpose is pedagogy and onboarding.

The four stages are a single maturation path for the same protocol. What moves along the path is not four codebases. It is one core crate, swapped onto four storage and identity backends.

Goals & Non Goals

Goals

• A renderer and storage agnostic core, so the same logic runs in a simulation, a game, and a live network without change.
• A simulation that spawns many autonomous agents in a closed world and exposes full state for observation and reproducible study.
• A game that teaches the nondominium economy through practice and produces players ready to join a real OVN.
• A Sensorica exit: a defined, safe path for experience earned in the game to be recognised inside a real network.
• A migration pipeline in which advancing a stage changes the backend and the stakes, never the protocol.

Architecture

A core, a storage seam, a set of backends, and a set of viewers. Agents and players act on the core only through its defined operations.

Three properties hold across the whole diagram:

• The core is renderer and storage agnostic. It compiles without any rendering, networking, or Holochain dependency. Backends and viewers depend on the core, never the reverse.
• The agents see operations, not pixels. Both AI agents and human players act through the core's exposed operations. No agent reasons over rendered frames; the viewer exists only for human observation and play.
• serde shapes are preserved. The core's entity types serialise to the same shapes as the Holochain integrity entries, so shared types and the existing design system stay reusable across stages.

The Core Protocol

nondominium-core mirrors, by field shape, the integrity entries already present in the repository. These types are grounded in the ValueFlows and REA ontology.

The lifecycle state machine

The nondominium object lifecycle is a state machine that already exists and is test covered in the repository (the ndo_layer0 Sweettest suite covers valid transitions, rejection of invalid ones, terminal states, and anchor movement). The core lifts this state machine out of the Holochain context and runs it in process, giving both products a behavioural oracle to test against.

Governance as operator

Governance is modelled as an operator that evaluates GovernanceRules against a proposed transition and accepts, rejects, or penalises it. In the repository this operator is substantially implemented already. The remaining gap is narrow: the call from the resource zome into the governance operator is deferred (the Phase 2 TODOs, pending cross zome resolution). Inside a single crate that boundary disappears and the call is made directly.

The governance injection knob

The operator exposes a single research and design control: the set of active GovernanceRules, and for each whether it is a soft penalty (the transition is allowed but standing is affected) or a hard prohibition (the transition is rejected). This is the primary experimental instrument of the simulation and the primary curriculum control of the game. It lets the protocol stay fixed while the constraints around it vary.

Determinism & the Store trait

Simulation runs must be reproducible, so the core commits to deterministic execution: no wall clock inside transition logic, all randomness from an explicitly seeded source, stable iteration order. The single seam between core and world is the Store trait, abstracting reads and writes of entities, links, and receipts. Each stage supplies one implementation. The core depends only on the trait, so advancing a stage means selecting a different implementation, not editing the core.

Identity & Stakes Regimes

Every discontinuity in Simsorica lives at the identity and stakes boundary, never in the protocol. The four stages are four regimes.

The protocol is identical across every row. Only identity, stakes, and the exit valve change.

The Sensorica Exit

The defining feature of Simsorica and its sharpest design problem: the mechanism by which experience earned inside the platform is recognised in a real network.

The problem

A participation receipt is meaningful because it is tied to a persistent identity that did real work under real stakes. A naive transfer, where game receipts simply become real receipts, is reputation laundering. It opens a Sybil channel: an actor manufactures standing cheaply at low stakes and walks it into the high stakes network. Any exit design that ignores this is unsafe.

The principle

Reputation does not teleport across a stakes boundary. The exit is therefore a recognition pipeline, not a balance transfer. Game history is evidence submitted for promotion, not currency spent.

The mechanism

• Identity continuity crosses cleanly. At exit, the player binds their platform identity to their real Holochain agent key, so it is provably the same person who continues.
• Demonstrated competence crosses as a credential. The game can prove the player understands how to operate within an OVN. This maps to an onboarding credential or initial capability grant, not to accumulated standing.
• Accumulated weight is revalued, not carried. Receipts arrive provenance tagged and are treated as a distinct, discounted class. They bootstrap initial trust and are then superseded by real participation.

The gate already exists in the repository: the promotion validators validate_agent_for_promotion and validate_agent_for_custodianship. The exit submits the player's tagged history to these validators, reusing the network's own promotion process rather than inventing a parallel one.

The valve invariants

The exit is a one way valve, and the two products require it pointed in opposite directions.

Product A · The Simulation

A closed world where autonomous agents are spawned, run, and observed, so the behaviour of the protocol under autonomous pressure can be studied and reproduced.

The research question

The precedent is Project Sid (Altera), where more than a thousand autonomous agents in Minecraft produced an emergent economy from open affordances, including a currency convention and an agent who gamed the social system for advantage. The lesson: agents optimise the affordances they are actually given, not the intentions behind them.

Simsorica inverts that experiment. The economy is not left to emerge from nothing. A specific protocol is imposed, and the question becomes: under which encoded rules does the commons hold, and under which do agents route around it or capture it. That answer is steered by the governance injection knob, not assumed.

Embodiment as apparatus

Sid's emergence depended partly on embodiment: locality, travel, encounter, scarcity. Agents that merely call a transfer operation will optimise that operation directly; agents embodied in a world with spatial friction are far more likely to produce the surprising behaviour that is the research target. Embodiment is treated as part of the apparatus, not decoration, which informs the engine choice.

Observability & containment

The simulation exposes full world state, a telemetry stream of events and transitions, and seeded reproducibility so a run can be replayed exactly. It is an instrument before it is an experience. And it has no exit: receipts are sealed, and the simulation never writes to a real network.

Product B · The Game

An open multiplayer world where humans learn the nondominium economy by practising it, and from which prepared players exit into a real OVN. The economy is the content.

Engine Decisions

Two products with genuinely different requirements use different viewers over the same core. This is two thin clients, not two projects.

Migration Pipeline

Advancing a stage is a backend swap and a stakes change, never a protocol change.

• Invariant: the core protocol, the entity field shapes, the lifecycle state machine, the governance operator.
• Variant: the Store implementation, the identity regime, the stakes, the exit valve state.
• Discontinuities: every one sits at the identity and stakes boundary. The protocol slides smoothly; identity and stakes do not, and that is exactly where the Sensorica exit does its work.

This is the protocol idea made concrete: protocol level commons governance exercised at increasing levels of reality without rewriting the rules.

Open Questions

1. Reconciliation with the source draft.This specification consolidates the design discussion and the verified state of the repository. Specific figures, claims, and wording from the original document should be reconciled against it.
2. Receipt revaluation function.The exact discount or weighting applied to game and staging receipts when the promotion validators evaluate them is undefined.
3. Identity binding mechanism.The concrete protocol for binding a game account to a real Holochain agent key at exit needs specifying.
4. Group and Lobby DNAs.The repository is now a three DNA architecture (Lobby, Group, nondominium). The spec must decide whether group scoped coordination is in scope, and whether the core needs a group domain sibling alongside the resource and governance domains.
5. Agent architecture.The agent design (a parallel multi stream architecture in the spirit of PIANO, or otherwise) and the exact tool interface the core exposes to agents are to be specified.
6. Determinism boundary for the game.The simulation requires determinism; the game may relax it. The spec should state precisely where the deterministic guarantee ends.

Repository Grounding

Verified against the current Sensorica / nondominium repository.

• The integrity entries named above exist: NondominiumIdentity, EconomicResource, GovernanceRule in zome_resource; EconomicEvent, Commitment, Claim in zome_gouvernance.
• The governance operator is substantially implemented: agreements, commitments, claims, economic events, the participation receipt system with ed25519 signing and signature validation, reputation derivation, and promotion validators. The deferred piece is the call from the resource zome into the operator.
• The nondominium object lifecycle state machine is implemented and test covered by the ndo_layer0 Sweettest suite.
• The promotion validators validate_agent_for_promotion and validate_agent_for_custodianship exist and are the natural gate for the exit.
• Sweettest is the primary test framework; Tryorama is deprecated. The extracted core can run under plain cargo test with no conductor.
• The repository is a three DNA architecture (Lobby, Group, nondominium), which the original single DNA framing did not account for.