SimNet: A Persistent World Model for Embodied Intelligence

A Distributed Simulation Substrate for Continuous, Collective Robot Learning

Abstract

Contemporary robot learning treats simulation as a disposable artifact: an episodic sandbox that is instantiated, sampled, and destroyed. This design discards three assets that are central to intelligence — persistence of state, accumulation of shared experience, and continuity between the simulated and physical worlds. We present SimNet, a distributed simulation substrate in which thousands to millions of robots, humans, environments, and software agents coexist inside a single, persistent, sharded virtual world. SimNet is organized as five coupled layers: (1) a persistent world state layer that maintains a hybrid explicit/neural representation of environments with temporal replay and branching timelines; (2) an agent layer hosting heterogeneous embodiments, each with its own world model, task memory, and skill library; (3) an interaction graph that records all agent–agent and agent–environment couplings as a typed, temporal hypergraph; (4) a distributed simulation engine providing parallel physics, optimistic/conservative hybrid time synchronization, checkpointing, and elastic scaling across geographically distributed clusters; and (5) a knowledge layer that turns local experience into globally reusable skills via conflict-free replicated skill libraries, cross-embodiment policy distillation, and federated aggregation. We formalize the persistent world as a partially observable stochastic game with an evolving population and give ε-bounded consistency guarantees for cross-shard divergence. We derive throughput and scaling models for the engine, propose a continuous real↔sim synchronization loop that treats system identification as amortized posterior inference over a digital-twin prior, and specify an evaluation suite spanning persistence, transfer, consistency, and collective-learning metrics. We position SimNet against GPU-batched simulators (Isaac Gym/Lab, Brax), learned world models (Dreamer, Genie, UniSim), and cross-embodiment data efforts (Open X-Embodiment, DROID), arguing that the missing ingredient in each is persistence as infrastructure: simulation not as a tool, but as the operating environment of robotic intelligence.

1. Introduction

1.1 The episodic bottleneck

The dominant abstraction in robot learning is the episode: an environment is reset to an initial state distribution ρ₀, an agent interacts for T steps, a return is recorded, and the world is discarded. This abstraction is convenient for reinforcement learning theory, but it imposes structural costs that compound at scale:

State amnesia. Wear, clutter accumulation, tool displacement, and long-horizon side effects — precisely the phenomena that dominate real deployments — cannot exist in a world that is reborn every 500 steps.
Experience fragmentation. Each lab, each robot, and each training run maintains a private replay buffer. Knowledge does not compound across the ecosystem. The Open X-Embodiment effort demonstrated that pooling ~1M trajectories from 22 embodiments yields large positive transfer (≈50% average improvement for RT-1-X across partner labs) [1], but it did so by pooling static datasets, not live experience.
Sim-real discontinuity. Sim-to-real is treated as a one-shot compilation step (train, randomize, deploy) rather than a continuous synchronization process. Once deployed, the robot's stream of real observations rarely flows back to improve the simulator that trained it.

GPU-batched simulators such as Isaac Gym showed that running tens of thousands of environments on a single accelerator collapses RL wall-clock time by 2–3 orders of magnitude [4]; Isaac Lab and Brax extended this to multi-modal sensing and TPU-scale rigid-body dynamics [5, 6]. But these systems parallelize copies of the same amnesiac episode. They scale sampling, not memory.

1.2 Simulation as an operating environment

SimNet inverts the abstraction. Instead of "simulation as a tool invoked by a training job," SimNet treats simulation as always-on infrastructure — analogous to the internet for information or the cloud for computation — inside which robotic intelligence lives, accumulates, and evolves:

Thesis. When robot populations scale from thousands to millions, the binding constraint on embodied intelligence shifts from per-robot sample efficiency to ecosystem-level knowledge circulation. The correct computational substrate is a persistent, distributed, bidirectionally synchronized world model.

Concretely, SimNet is a persistent world W that (i) never resets globally, (ii) is sharded across geographically distributed clusters yet exposes a single logical timeline with bounded divergence, (iii) ingests state reconstructions from deployed fleets and emits validated policies back to them, and (iv) maintains a global, conflict-free knowledge base of skills, semantic maps, failure cases, and recovery behaviors that any agent can query.

1.3 Contributions

This paper makes the following contributions:

Formalization of a persistent embodied world as an open-population partially observable stochastic game (OP-POSG) with explicit persistence, branching, and population-evolution operators (§3).
Architecture of the five-layer SimNet stack, including a hybrid explicit/neural world-state representation with interest management and spatial sharding (§4).
Synchronization theory: a hybrid conservative/optimistic distributed time model with ε-bounded cross-shard state divergence, CRDT-based knowledge replication, and rollback-safe checkpointing (§5).
Knowledge layer mechanisms for cross-embodiment skill transfer: embodiment-conditioned skill embeddings, policy distillation into shared latent action spaces, and federated aggregation with validation gating (§6).
Continuous learning loop that casts real-to-sim state reconstruction and system identification as amortized Bayesian inference over digital-twin priors, closing the sim↔real loop bidirectionally (§7).
Autonomous curriculum: open-world task generation combining LLM program synthesis (GenSim/Eureka-style) with regret-based unsupervised environment design over the persistent world (§8).
Scaling analysis of throughput, communication, and knowledge-diffusion dynamics, including an epidemic model of skill propagation across fleets (§9).
Evaluation benchmarks for persistence, consistency, transfer, and collective learning (§10).

2. Related Work

GPU-parallel and distributed simulation. Isaac Gym established the GPU-native pipeline — PhysX dynamics, observations, rewards, and policy updates co-resident in GPU memory, eliminating CPU–GPU transfer bottlenecks and enabling thousands of concurrent environments per device [4]. Isaac Lab generalizes this to multi-modal sensing (RTX-rendered tiled cameras, contact/force sensing) on Isaac Sim [5]; Brax demonstrated hundreds of millions of physics steps per second on TPU pods via JAX-compiled rigid-body dynamics [6]; Madrona provides a batch-ECS game-engine substrate for custom high-throughput environments [7]; MJX brought MuJoCo [8] to accelerators. Rudin et al. showed minutes-scale training of legged locomotion with massively parallel on-GPU RL [9]. All of these systems are episodic and world-amnesiac: parallelism multiplies identical resettable microcosms. Classical parallel discrete-event simulation (PDES) contributes the missing time machinery: conservative synchronization (Chandy–Misra–Bryant null messages) and optimistic execution with rollback (Jefferson's Time Warp / virtual time) [10, 11], standardized for interoperable federations in the HLA (IEEE 1516) [12]. SimNet fuses the two lineages: GPU-batched physics within shards, PDES-style synchronization between shards.

Learned world models. Ha & Schmidhuber demonstrated policy training inside a learned generative "dream" [13]; PlaNet introduced the recurrent state-space model (RSSM) mixing deterministic and stochastic latents for long-horizon latent prediction [14]; DreamerV3 scaled imagination-based actor–critic learning across 150+ domains with fixed hyperparameters, learning categorical latent world models and optimizing policies entirely in imagination [15]. Genie learned latent-action interactive 2D worlds from unlabeled video; Genie 2 extended this to persistent-memory, action-controllable 3D worlds generated from single images; Genie 3 reached real-time text-prompted 3D worlds at 720p/24FPS [16, 17]. UniSim learns an action-conditioned real-world video simulator from heterogeneous datasets [18]; GAIA-1 does the same for driving [19]. These models supply neural dynamics priors and generative environment authoring, but none maintains a shared, persistent, multi-tenant world with transactional semantics. SimNet embeds learned world models as (a) per-agent predictive models, (b) neural fallback dynamics for phenomena outside analytic physics, and (c) generative environment authoring tools feeding the persistent state.

Cross-embodiment learning and robot foundation models. Open X-Embodiment pooled 60 datasets / 22 embodiments / 1M+ trajectories and showed positive transfer for high-capacity models (RT-2-X ≈3× improvement on emergent skills) [1, 2]; DROID [20] and BridgeData V2 [21] broadened scene diversity; GR00T-style and π0-style vision-language-action models [22, 23] treat action generation as flow-matching/token prediction atop VLM backbones. Embodiment scaling analyses suggest that diversity of embodiments can matter more than trajectory count per embodiment [3]. These efforts validate SimNet's central premise — experience transfers across bodies — but operate on offline corpora. SimNet's knowledge layer is the online, streaming generalization: a continuously written, continuously distilled cross-embodiment corpus with provenance and validation.

Fleet learning, cloud robotics, digital twins. Cloud robotics surveys established offloading of data, memory, and computation to shared infrastructure [24]; Interactive Fleet Learning formalizes allocation of scarce human supervision over robot fleets [25]; OpenBot-Fleet demonstrated collective navigation learning across 72 physical robots with cloud aggregation [26]; QT-Opt showed scalable off-policy learning from pooled real grasping experience across robot farms [27]. Industrial digital twins synchronize live sensor streams with virtual replicas for prediction and fleet-wide propagation of fixes [28]. SimNet subsumes the digital twin: each deployed robot's twin is an agent inside the persistent world, not a standalone mirror.

Sim-to-real and real-to-sim. Domain randomization [29] and dynamics randomization [30] remain the workhorses of zero-shot transfer, scaled dramatically in DeXtreme [31]. LLM-in-the-loop approaches automate the human-intensive components: Eureka synthesizes reward functions as code [32], DrEureka jointly proposes rewards and DR distributions from reward-aware physics priors [33], GenSim/GenSim2 synthesize entire task programs and demonstrations [34, 35], RoboGen composes generative pipelines for skill acquisition [36]. Real-to-sim reconstruction (RialTo-style real→sim→real loops [37], neural scene reconstruction) inverts the pipeline. SimNet organizes all of these as operators on a persistent substrate: DR becomes branching-timeline perturbation; real-to-sim becomes continuous state assimilation; task generation becomes curriculum service.

Continual and lifelong learning. Catastrophic forgetting and the stability–plasticity dilemma [38], progressive networks and policy distillation [39, 40], and federated averaging [41] supply the algorithmic toolkit for SimNet's knowledge layer, which must integrate non-stationary, non-IID experience streams from millions of writers without degrading validated capabilities.

3. Problem Formulation

3.1 The persistent world as an open-population POSG

We model SimNet as an open-population partially observable stochastic game

𝒲 = ⟨𝒮, {𝒜ᵢ}, {Ωᵢ}, 𝒯, {𝒪ᵢ}, {Rᵢ}, 𝒫, Λ⟩

where 𝒮 is the (unbounded, structured) world-state space; agent i ∈ 𝒫(t) has action space 𝒜ᵢ and observation space Ωᵢ determined by its embodiment eᵢ ∈ ℰ; 𝒯 : 𝒮 × ∏𝒜ᵢ → Δ(𝒮) is the joint transition kernel; 𝒪ᵢ are embodiment-conditioned observation kernels; Rᵢ are (possibly task-conditioned, possibly generated) reward functionals; 𝒫(t) is the time-varying agent population (agents join, leave, are cloned, or migrate between real and simulated instantiation); and Λ is the persistence operator — the defining departure from episodic RL:

No global reset. There is no ρ₀ resampling of 𝒮; the state trajectory s(t) is a single semi-infinite path. Local, scoped resets exist only as sandboxed branches (below).
Branching. Λ supports fork(s, t) → 𝒲′, producing a child timeline sharing history up to t. Branches are the mechanism for counterfactual rollouts, domain randomization, policy validation, and A/B world experiments. A branch may be merged (its knowledge artifacts, never its raw state, flow back through the knowledge layer) or garbage-collected.
Replay. Λ supports replay(t₁, t₂) via the checkpoint + event-log machinery of §5, enabling post-hoc counterfactual analysis ("what if agent j had yielded?") as deterministic re-execution with intervention.

3.2 State factorization

𝒮 factorizes into a typed scene hypergraph and neural residuals:

s = ( G = (V, E, X), Z )

V: entities (rigid/articulated bodies, deformables, terrains, agents, fixtures) with typed attribute vectors X(v): pose ∈ SE(3), twist, inertial parameters θ_dyn, material/contact parameters θ_mat, semantic labels, ownership/provenance.
E: relations — kinematic joints, contacts, attachments, containment, task bindings, and interaction edges (§4.3).
Z: neural residual state — latent fields (e.g., learned deformation, granular media, appearance NeRF/3DGS layers) attached to entities or regions, evolved by learned operators where analytic physics is absent or too expensive.

This hybrid representation is deliberate. Explicit graphs give transactional semantics, exact conservation where it matters (contacts, articulations), interpretability, and cheap interest management; neural residuals give coverage of the long tail (cloth, fluids, appearance, human behavior) and a natural interface to learned world models (§6.4).

3.3 Consistency objective

Because 𝒲 is sharded across clusters (§5), the physically realized system maintains per-shard states s_k(t) rather than one s(t). Define the divergence functional for entities in the overlap/ghost region 𝒢_{k,l} between shards k, l:

D_{k,l}(t) = sup_{v ∈ 𝒢_{k,l}} d( X_k(v, t), X_l(v, t) )

with d a task-relevant metric (e.g., weighted SE(3) geodesic + twist error). SimNet's engine guarantees ε-bounded eventual consistency: for all t, D_{k,l}(t) ≤ ε(Δ_sync, L_dyn) where the bound is a function of synchronization interval Δ_sync and the local Lipschitz constant L_dyn of the dynamics (§5.4), and D_{k,l} → 0 whenever the entity's interaction set stabilizes within one shard.

3.4 The collective learning objective

Let Π = {π_θᵢ} be the population's policies and K(t) the shared knowledge base. SimNet's ecosystem objective is not a single expected return but a knowledge-production functional:

J(t) = 𝔼_{tasks τ ~ 𝒞(t), embodiments e ~ ℰ} [ V^{π(K(t), e)}(τ) ] − λ · Regret_new(t)

i.e., the expected competence of a policy instantiated from the knowledge base on tasks drawn from the (autonomously generated, §8) curriculum 𝒞(t), regularized by the regret of the population on novel tasks (forcing exploration of the frontier). The unit of progress is K(t), not any individual π. This reframing is what makes intelligence a network property: an agent's competence is dominated by what the network has learned, amortized through K.

4. System Architecture

SimNet's five layers map onto a concrete systems stack (Figure 1).

┌──────────────────────────────────────────────────────────────────┐
│ L5  KNOWLEDGE LAYER      CRDT skill libraries · distillation ·   │
│                          semantic map service · failure corpus   │
├──────────────────────────────────────────────────────────────────┤
│ L4  DISTRIBUTED ENGINE   shard scheduler · hybrid time sync ·    │
│                          checkpoint/event-log · elastic scaling  │
├──────────────────────────────────────────────────────────────────┤
│ L3  INTERACTION GRAPH    typed temporal hypergraph · interest    │
│                          management · provenance                 │
├──────────────────────────────────────────────────────────────────┤
│ L2  AGENT LAYER          embodiment runtimes · per-agent world   │
│                          model, task memory, skill cache         │
├──────────────────────────────────────────────────────────────────┤
│ L1  PERSISTENT WORLD     scene hypergraph + neural residuals ·   │
│     STATE                branching timelines · temporal replay   │
└──────────────────────────────────────────────────────────────────┘
        ▲ real→sim state assimilation      policy deployment ▼
┌──────────────────────────────────────────────────────────────────┐
│              PHYSICAL FLEETS (digital-twin agents)               │
└──────────────────────────────────────────────────────────────────┘

4.1 L1 — Persistent world state

Storage model. World state is held in a log-structured, versioned entity store. Every mutation is an event (t_virtual, entity_id, δ, provenance) appended to a shard-local log; periodic fuzzy checkpoints snapshot the materialized state without stopping simulation (copy-on-write pages over the entity store). The pair (checkpoint, log suffix) makes any past state reconstructible in O(log length) — this single mechanism serves crash recovery, optimistic rollback (§5.2), temporal replay, and timeline branching (a fork is a checkpoint reference plus a new log).

Dynamics tiering. Entities carry a fidelity level ℓ ∈ {analytic-full, analytic-reduced, learned-surrogate, frozen}. A region with no nearby agents decays to reduced or frozen dynamics (with scheduled "aging" processes — battery drain, thermal drift, dust accumulation — applied lazily on next access as closed-form or learned time-skip operators: X(t+Δ) = F_age(X(t), Δ)). This is the key trick that makes a million-entity persistent world affordable: full physics is spent only where the interaction graph is hot, in the spirit of interest management from large-scale distributed virtual environments, while persistence is preserved everywhere.

Neural residual fields. Appearance and geometry are maintained as 3D Gaussian-splat / neural field layers updated by real-to-sim assimilation (§7); non-analytic dynamics (cloth, granular flows, human crowds) run learned operators (graph-network simulators or latent RSSM blocks [14, 15]) whose states live in Z and are checkpointed with everything else.

4.2 L2 — Agent layer

Each agent is a containerized runtime with a standardized contract:

Embodiment descriptor e: URDF/MJCF morphology, actuator and sensor models, θ_dyn priors (used for cross-embodiment retrieval keys, §6.1).
Per-agent world model ŵᵢ: an RSSM/transformer latent dynamics model trained on the agent's own observation stream, used for local planning-by-imagination [15], anomaly detection (surprise = model NLL spikes trigger knowledge-layer failure logging), and prediction markets for validation (§7.3).
Task memory: episodic store of (goal, trajectory, outcome, context) tuples with vector-indexed retrieval.
Skill cache: locally materialized subset of the global skill library, subscribed by embodiment-similarity and task-frequency keys.

Humans participate through teleoperation and VR embodiments; software agents (task generators, adversaries, evaluators, LLM planners) participate through the same contract with null physics bodies. Critically, digital twins of deployed robots are ordinary agents whose observation stream is the assimilated real sensor stream rather than the simulated one.

4.3 L3 — Interaction graph

All couplings are recorded as a typed temporal hypergraph H = (V, E_H, T): hyperedges connect the participants of an interaction (robot–human handover, three-robot cooperative lift, robot–environment contact episode) with type, interval, and outcome annotations. H serves four functions:

Interest management / sharding oracle. The engine partitions the world to minimize expected cut of future interaction edges (predicted by a link-prediction model over H), because cut edges are precisely what forces cross-shard synchronization.
Credit assignment across agents. Multi-agent returns are decomposed along H (e.g., counterfactual/Shapley-style attribution over hyperedge participants), enabling cooperative learning signals without global value factorization.
Emergence analytics. Motif mining over H detects emergent conventions (right-of-way norms in corridors, queuing at chargers) which are then promoted into the knowledge layer as explicit social skills.
Provenance. Every knowledge artifact links back to the sub-hypergraph that generated it, making skills auditable and revocable (essential when a skill is later found unsafe).

4.4 L4 — Distributed simulation engine

Detailed in §5. In brief: the world is spatially and logically sharded; each shard is a GPU-batched island (Isaac-Lab/Brax-class throughput within the shard [4–6]) advancing on its own virtual clock; shards federate through a hybrid conservative/optimistic protocol with ghost-entity replication; the whole federation is elastically rescheduled as the interaction graph's hot set moves.

4.5 L5 — Knowledge layer

Detailed in §6. It is the only channel through which branches, shards, agents, and real fleets exchange learned content — raw state never crosses trust boundaries, which simplifies both consistency and safety review.

5. Distributed Synchronization

5.1 Time model

Each shard k maintains virtual time LVT_k. Entities wholly interior to a shard advance at full physics rate (e.g., 1–4 kHz contact-rich substeps batched across thousands of scenes). Cross-shard influence flows through ghost entities: read-mostly replicas of boundary entities refreshed at interval Δ_sync with dead-reckoned extrapolation between refreshes, as in large-scale distributed interactive simulation.

SimNet uses a hybrid protocol:

Conservative core (Chandy–Misra–Bryant-style lookahead [10]) for safety-critical couplings: a shard may not advance an entity past the guaranteed-safe horizon implied by its neighbors' lower time bounds plus physical lookahead (minimum signal propagation: a robot 10 m from the shard boundary cannot affect the neighbor shard for ≥ 10/v_max seconds of virtual time). Physical locality gives robotics federations much better lookahead than typical PDES workloads.
Optimistic periphery (Time Warp [11]) for loose couplings: shards speculate past Δ_sync and roll back via the checkpoint/event-log of §4.1 when a straggler message (e.g., an unexpected object thrown across the boundary) violates causality. Anti-messages cancel downstream speculation. Global virtual time (GVT) is computed by standard asynchronous GVT algorithms and bounds log truncation.

5.2 Rollback with learned dynamics

Rollback requires deterministic re-execution. Analytic physics is made deterministic per-shard (fixed reduction orders, seeded contact solvers). Learned operators are deterministic given (weights_version, seed, inputs); weights are versioned content-addressably so replay across weight updates re-binds the historical version. Agents' policies are similarly versioned; a rollback therefore replays exactly, then re-diverges only at the injected correction — this is what makes branch-based counterfactuals well-defined.

5.3 Knowledge replication

The knowledge layer must accept concurrent writes from millions of producers across partitions. SimNet uses CRDTs [42]: skill libraries are observed-remove sets keyed by content hash; semantic maps are grow-only + tombstone lattices with per-cell last-writer-wins registers ordered by (confidence, hybrid logical clock); counters of skill usage/success are PN-counters. CRDT semantics give convergence without coordination; quality control is layered on top by validation gating (§6.3) — an artifact replicates freely but only activates for deployment once its validation certificate replicates too.

5.4 Divergence bound

For a boundary entity with locally Lipschitz dynamics ‖f(x) − f(y)‖ ≤ L‖x − y‖ and dead-reckoning error at refresh bounded by δ₀ (measurement/serialization error), the inter-refresh divergence obeys the Grönwall bound

D(t) ≤ ( δ₀ + Δ_sync · sup‖f − f̂_DR‖ ) · e^{L Δ_sync},

so ε-consistency (§3.3) is enforced by adapting Δ_sync per-entity to Δ_sync ≤ (1/L) · ln( ε / (δ₀ + c) ). In practice L is estimated online from the shard's own physics Jacobians; contact-rich entities (large L) get tight sync or shard co-location, free-flying ones get sparse sync. When the bound cannot be met (e.g., two contact-rich agents interacting across a boundary), the engine performs entity migration — transactional handoff of ownership — or shard fusion for the duration of the interaction. The interaction-graph link predictor (§4.3) exists precisely to make such migrations pre-emptive rather than reactive.

5.5 Elastic scaling and fault tolerance

Shards are the unit of scheduling: they split along low-cut graph partitions when hot, fuse when cold, and migrate between clusters for locality to real fleets (assimilation latency, §7.1). Fuzzy checkpoints + logs give exactly-once recovery semantics; a lost shard is replayed from its last checkpoint against its neighbors' retained message logs (standard PDES fossil-collection discipline governs log retention up to GVT).

6. The Knowledge Layer: Experience Generated Anywhere, Reusable Everywhere

6.1 Skill representation

A skill is a tuple σ = (π_φ, pre, post, e-scope, certs, provenance):

π_φ: a policy — either parameters of a small network, a LoRA/adapter delta on a shared foundation policy [22, 23], or a program (LLM-synthesized code as in GenSim [34]).
pre/post: learned preimage (initiation set classifier) and effect model, giving skills option semantics for hierarchical planning.
e-scope: an embodiment embedding region — skills are indexed in a learned embodiment space ψ(e) ∈ ℝ^d trained so that transfer success is monotone in embedding distance. Retrieval for a new robot is a nearest-neighbor query ψ(e_new); the empirical finding that embodiment diversity drives generalization more than per-embodiment data volume [3] motivates deliberately training ψ on wide morphology coverage.
certs: validation certificates (§6.3) — signed records of branch-based evaluation results.
provenance: pointer into the interaction hypergraph (§4.3).

6.2 Cross-embodiment transfer mechanisms

SimNet composes three mechanisms, ordered by decreasing structural assumption:

Shared latent action space. A cross-embodiment encoder/decoder pair maps embodiment-specific actions into a common latent action manifold (in the spirit of latent-action learning in Genie [16] and unified action tokenizations in RT-X/π0 [1, 23]); skills expressed in latent actions transfer by re-decoding through the target embodiment's decoder, fine-tuned in a SimNet branch.
Policy distillation into foundation policies. Per-task specialist policies trained anywhere in the world are distilled [40] into a shared vision-language-action backbone on schedule; the backbone is then the default π(K, e) of §3.4. Distillation batches are sampled non-uniformly: failure-adjacent and frontier experience is upweighted, replay from certified skills combats forgetting [38].
Sim-to-sim transfer before sim-to-real. Before a skill's e-scope is expanded to a new embodiment or environment class, it is exercised in branched replicas of the relevant world regions under randomized θ_dyn — domain randomization [29, 30] reinterpreted as cheap timeline branching (§3.1). Only skills that pass sim-to-sim generalization graduate to real-fleet deployment candidates.

6.3 Validation gating

Every artifact must earn certificates before activation: (i) branch evaluation — N branched rollouts across randomized conditions with success/robustness statistics; (ii) adversarial probing — software red-team agents (§8) search for failure preimages; (iii) safety envelope check — reachability or control-barrier analysis where applicable; (iv) for real deployment, shadow-mode prediction: the digital twin runs the candidate in parallel with the incumbent on assimilated real streams, and activation requires the candidate's predicted-outcome distribution to stochastically dominate the incumbent's. Certificates are content-addressed and replicate with the artifact through the CRDT layer (§5.3).

6.4 Learned world models as knowledge

Per-agent world models ŵᵢ (§4.2) are themselves knowledge artifacts. SimNet aggregates them two ways: (a) federated averaging / distillation [41] of dynamics models within an embodiment class, producing priors that make new agents' models converge in hours instead of weeks; (b) model disagreement as curriculum signal — regions of the persistent world where the population's models disagree most are, by definition, the epistemic frontier, and are fed to the task generator (§8). Generative world models of the Genie/UniSim class [16–18] additionally serve as environment authors: text/image-prompted scene proposals are compiled (via inverse-rendering + physical-plausibility optimization) into explicit L1 state, so the persistent world's diversity grows generatively rather than only by manual authoring.

7. The Continuous Learning Loop

Real fleets ──sensor streams──► State assimilation ──► Persistent world (twins)
     ▲                                                        │
     │                                              branch: exploration,
 policy deployment                                  DR, counterfactuals
     │                                                        ▼
Validation gate ◄── distillation ◄── policy optimization ◄── massively
(shadow mode, certs)      ▲                                parallel rollouts
                          └────────── knowledge layer ◄───────┘

7.1 Real-to-sim state assimilation

Each deployed robot streams observations o_real(t). Assimilation maintains the twin's state estimate by filtering in the hybrid representation: explicit entities via factor-graph SLAM/object-level pose estimation; neural residuals via online 3DGS/NeRF updates; contact and dynamics events via learned event detectors. The result is that the persistent world contains a rolling, probabilistic reconstruction of every deployment site — the substrate for counterfactual replay of real incidents ("branch 10 s before the failure, sweep 200 interventions").

7.2 System identification as amortized posterior inference

Rather than one-shot SysID, SimNet maintains a posterior p(θ_dyn | o_real,₁:t) per twin. An amortized inference network q_χ(θ_dyn | features(o_real)) — trained in simulation on (θ, trajectory) pairs, i.e., simulation-based inference — provides fast updates; the posterior is the domain-randomization distribution for that twin's training branches. This subsumes and grounds DR: instead of hand-tuned or LLM-proposed ranges [33], randomization ranges are the actual epistemic uncertainty about that robot's world, shrinking as evidence accumulates and re-widening when surprise (model NLL) spikes — e.g., after mechanical wear, which the persistence layer models explicitly (§4.1 aging operators).

7.3 Predict-then-verify deployment

Before any real actuation of a new policy, SimNet issues a prediction: distribution over outcomes from twin branches. After real execution, realized outcomes score the prediction (CRPS/log-score). This produces a continuously updated calibration ledger per (site, embodiment, task family) — a quantitative answer to "how much should we trust simulation here?" — which in turn gates how aggressively branch-trained policies may be deployed (well-calibrated regions get autonomous rollout; poorly calibrated ones require human supervision, allocated by interactive-fleet-learning policies [25]).

8. Autonomous Curriculum and Open-World Task Generation

SimNet's curriculum service 𝒞(t) composes:

LLM program synthesis of tasks, rewards, and success metrics over the world's semantic API (GenSim/GenSim2-style task code generation [34, 35], Eureka-style reward synthesis [32]), grounded by the fact that generated tasks bind to real persistent state — "tidy the actually-messy warehouse aisle 7," not a procedurally reset toy scene.
Unsupervised environment design with regret objectives (PAIRED/POET lineage [43, 44]): adversary agents perturb branches — object placements, θ_dyn, human behavior models — to maximize protagonist regret subject to solvability certificates, yielding an auto-curriculum at the frontier of competence.
Frontier sampling from model disagreement (§6.4) and from the failure corpus: every real or simulated failure spawns a task family of counterfactual variants; curricula therefore concentrate exactly where the ecosystem is weakest.
Emergent-behavior promotion: motifs mined from the interaction hypergraph (§4.3) that correlate with cooperative success are converted into explicit multi-agent training tasks.

Because tasks are artifacts in the knowledge layer, the curriculum itself is shared, versioned, and evaluated — closing the loop in which the world generates the problems that improve the agents that enrich the world.

9. Scaling Analysis

9.1 Throughput model

Let a shard batch B scenes with per-step physics cost c_p(B) (sublinear in B on GPUs until memory bound [4]), rendering cost c_r, learned-operator cost c_z, and cross-shard sync cost c_s = (β · |ghosts|)/Δ_sync amortized per step. Effective experience throughput per shard:

X_shard = B / ( c_p + c_r + c_z + c_s ) [env-steps/s]

Federation throughput is N_shards · X_shard · U, where utilization U < 1 captures synchronization stalls. Under the conservative core, U is governed by lookahead: U ≈ LA / (LA + λ_straggler · t_rollback + t_blocked). Physical locality gives robotics large LA (§5.1), and the interest-managed sharding minimizes |ghosts|; the design target is that cross-shard costs stay below ~10% of step time, so the persistent federation retains ≥90% of the embarrassingly-parallel throughput of episodic GPU simulators while adding persistence.

9.2 Fidelity–persistence budget

With fidelity tiering (§4.1), total cost is Σ_ℓ n_ℓ c_ℓ with n_frozen ≫ n_full. If the hot set (entities within h hops of agents in H) is a fraction ρ of the world, persistent-world overhead versus an episodic simulator hosting the same hot set is (1 + (1−ρ)·c_cold/c_hot) ≈ 1 + O(ε) for lazy aging operators — persistence is nearly free in compute, paid mostly in storage (logs/checkpoints), which is cheap and prunable to GVT.

9.3 Knowledge diffusion dynamics

Model skill propagation across a fleet of M robots as an epidemic on the knowledge layer: a validated skill spreads at rate governed by replication (fast, CRDT) but activates at rate γ set by validation throughput. If per-skill validation requires ν branch-rollouts and the federation dedicates fraction κ of throughput to validation,

γ = κ · N_shards · X_shard / ν,

so ecosystem-level learning rate is validation-bound, not experience-bound — a qualitative prediction distinguishing SimNet from dataset-pooling approaches, and an argument for investing compute in cheap certification (amortized adversarial probes, surrogate safety models). Combined with the empirical embodiment-diversity scaling results [3], the expected macro-law is that collective competence scales with (embodiment diversity) × (validated-skill flux), rather than raw trajectory count.

9.4 Communication lower bounds

Cross-cluster WAN sync is bounded by geography (~30–150 ms RTT). SimNet therefore never places tightly coupled interactions across WAN shards; WAN links carry only (a) CRDT knowledge deltas (latency-insensitive), (b) twin assimilation streams (bounded staleness acceptable; the twin is a filter, not a lockstep mirror), and (c) migration/checkpoint transfers (bulk, schedulable). This is the architectural sense in which SimNet resembles the internet: strong consistency is local; global coherence is eventual and semantic.

10. Evaluation Benchmarks

We propose SimNet-Bench, four suites with quantitative metrics:

Persistence suite. Long-horizon state integrity: conservation drift over 10⁷–10⁹ virtual seconds; correctness of lazy aging operators vs. full-rate ground truth; replay determinism (bit-exactness rate of counterfactual re-execution).
Consistency suite. Measured D_{k,l}(t) vs. the Grönwall bound under adversarial boundary traffic; rollback frequency/depth distributions; entity-migration latency; throughput retention U vs. episodic baseline (Isaac Lab [5]) on identical hot sets.
Transfer suite. Cross-embodiment: skill success vs. embodiment-embedding distance; sim-to-sim graduation rate as predictor of sim-to-real success; calibration ledger scores (CRPS) of predict-then-verify vs. realized outcomes across sites.
Collective-learning suite. Knowledge-diffusion half-life (time from first validation to 50% fleet activation); marginal value of an additional agent d J/d M (network-effect curvature); forgetting rate of certified skills under continual distillation; frontier-regret trajectory of the auto-curriculum.

Baselines: episodic GPU RL (Isaac Lab, Brax [5, 6]), offline dataset pooling (OXE-style co-training [1]), per-robot lifelong learning without sharing, and digital-twin mirroring without a shared world.

11. Safety, Governance, and Limitations

Safety. The knowledge layer is the single choke point for capability flow, enabling mandatory certification, provenance-based revocation (a skill implicated in a real incident is deactivated fleet-wide via CRDT tombstone within replication latency), and staged deployment gated by the calibration ledger. Branch sandboxing ensures exploration never mutates canonical state.

Governance. Multi-tenant persistence raises questions episodic simulation never faced: who owns world regions, experience, and derived skills; how human participants' data is scoped (twins of human-occupied spaces demand strict access partitioning); how adversarial writers are excluded (signed provenance, stake-weighted validation).

Limitations. (i) The Grönwall analysis assumes local Lipschitz dynamics; contact impulses violate this and force conservative co-location, capping shard granularity in dense multi-robot contact scenes. (ii) Neural residual dynamics lack the determinism guarantees of analytic solvers across hardware, complicating cross-cluster replay. (iii) The validation-bound learning-rate result assumes certification quality is stationary; adversarially distributed shifts in the real world can silently degrade certificates. (iv) The economics of always-on simulation depend on fidelity tiering holding in practice for heterogeneous workloads. (v) Emergent multi-agent conventions may encode undesirable norms; motif promotion (§8) therefore requires human review.

12. Conclusion

SimNet reframes simulation from an episodic tool into persistent infrastructure: a single, sharded, always-on world with bounded-divergence synchronization, a CRDT knowledge fabric, bidirectional real↔sim assimilation, and an autonomous curriculum. The individual ingredients have strong precedents — GPU-batched physics [4–6], learned and generative world models [13–18], cross-embodiment corpora [1, 20, 21], LLM-driven task and reward synthesis [32–35], PDES synchronization theory [10–12], and fleet/cloud robotics [24–27]. SimNet's claim is architectural: composing them around persistence converts robot learning from a set of isolated optimization runs into a compounding, network-level process, in which the marginal robot makes every other robot better. The research agenda this opens — ε-consistent embodied federations, validation-bound collective learning, embodiment-space geometry, calibration-gated autonomy — is, we argue, the systems agenda of the coming decade of robotics.

References

[1] Open X-Embodiment Collaboration. Open X-Embodiment: Robotic Learning Datasets and RT-X Models. ICRA 2024. arXiv:2310.08864.

[2] A. Brohan et al. RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control. CoRL 2023. arXiv:2307.15818.

[3] B. Ai et al. Towards Embodiment Scaling Laws in Robot Locomotion. arXiv:2505.05753, 2025.

[4] V. Makoviychuk et al. Isaac Gym: High Performance GPU-Based Physics Simulation for Robot Learning. NeurIPS Datasets & Benchmarks 2021. arXiv:2108.10470.

[5] M. Mittal et al. Orbit / Isaac Lab: A GPU-Accelerated Simulation Framework for Multi-Modal Robot Learning. IEEE RA-L 2023; NVIDIA 2025 whitepaper. arXiv:2301.04195 / 2511.04831.

[6] C. D. Freeman et al. Brax — A Differentiable Physics Engine for Large Scale Rigid Body Simulation. NeurIPS Datasets & Benchmarks 2021. arXiv:2106.13281.

[7] B. Shacklett et al. An Extensible, Data-Oriented Architecture for High-Performance, Many-World Simulation (Madrona). SIGGRAPH 2023.

[8] E. Todorov, T. Erez, Y. Tassa. MuJoCo: A Physics Engine for Model-Based Control. IROS 2012.

[9] N. Rudin et al. Learning to Walk in Minutes Using Massively Parallel Deep Reinforcement Learning. CoRL 2022. arXiv:2109.11978.

[10] K. M. Chandy, J. Misra. Distributed Simulation: A Case Study in Design and Verification of Distributed Programs. IEEE TSE 1979.

[11] D. R. Jefferson. Virtual Time. ACM TOPLAS 7(3), 1985.

[12] IEEE Std 1516-2010. High Level Architecture (HLA) — Framework and Rules.

[13] D. Ha, J. Schmidhuber. World Models. NeurIPS 2018. arXiv:1803.10122.

[14] D. Hafner et al. Learning Latent Dynamics for Planning from Pixels (PlaNet). ICML 2019. arXiv:1811.04551.

[15] D. Hafner, J. Pasukonis, J. Ba, T. Lillicrap. Mastering Diverse Control Tasks through World Models (DreamerV3). Nature, 2025. arXiv:2301.04104.

[16] J. Bruce et al. Genie: Generative Interactive Environments. ICML 2024. arXiv:2402.15391.

[17] J. Parker-Holder et al. Genie 2: A Large-Scale Foundation World Model. Google DeepMind, 2024.

[18] M. Yang et al. Learning Interactive Real-World Simulators (UniSim). ICLR 2024. arXiv:2310.06114.

[19] A. Hu et al. GAIA-1: A Generative World Model for Autonomous Driving. arXiv:2309.17080, 2023.

[20] A. Khazatsky et al. DROID: A Large-Scale In-the-Wild Robot Manipulation Dataset. RSS 2024. arXiv:2403.12945.

[21] H. Walke et al. BridgeData V2: A Dataset for Robot Learning at Scale. CoRL 2023.

[22] NVIDIA. GR00T N1: An Open Foundation Model for Generalist Humanoid Robots. arXiv:2503.14734, 2025.

[23] K. Black et al. π0: A Vision-Language-Action Flow Model for General Robot Control. arXiv:2410.24164, 2024.

[24] B. Kehoe, S. Patil, P. Abbeel, K. Goldberg. A Survey of Research on Cloud Robotics and Automation. IEEE T-ASE 12(2), 2015.

[25] R. Hoque et al. Fleet-DAgger: Interactive Robot Fleet Learning with Scalable Human Supervision. CoRL 2022; BAIR blog 2023.

[26] M. Müller et al. OpenBot-Fleet: A System for Collective Learning with Real Robots. ICRA 2024. arXiv:2405.07515.

[27] D. Kalashnikov et al. QT-Opt: Scalable Deep Reinforcement Learning for Vision-Based Robotic Manipulation. CoRL 2018. arXiv:1806.10293.

[28] F. Tao et al. Digital Twin in Industry: State-of-the-Art. IEEE TII 15(4), 2019.

[29] J. Tobin et al. Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World. IROS 2017.

[30] X. B. Peng et al. Sim-to-Real Transfer of Robotic Control with Dynamics Randomization. ICRA 2018.

[31] A. Handa et al. DeXtreme: Transfer of Agile In-Hand Manipulation from Simulation to Reality. ICRA 2023.

[32] Y. J. Ma et al. Eureka: Human-Level Reward Design via Coding Large Language Models. ICLR 2024. arXiv:2310.12931.

[33] Y. J. Ma et al. DrEureka: Language Model Guided Sim-to-Real Transfer. RSS 2024. arXiv:2406.01967.

[34] L. Wang et al. GenSim: Generating Robotic Simulation Tasks via Large Language Models. ICLR 2024. arXiv:2310.01361.

[35] P. Hua et al. GenSim2: Scaling Robot Data Generation with Multi-modal and Reasoning LLMs. CoRL 2024.

[36] Y. Wang et al. RoboGen: Towards Unleashing Infinite Data for Automated Robot Learning via Generative Simulation. ICML 2024.

[37] M. Torne et al. Reconciling Reality through Simulation: A Real-to-Sim-to-Real Approach for Robust Manipulation (RialTo). RSS 2024.

[38] G. I. Parisi et al. Continual Lifelong Learning with Neural Networks: A Review. Neural Networks 113, 2019.

[39] A. Rusu et al. Progressive Neural Networks. arXiv:1606.04671, 2016.

[40] A. Rusu et al. Policy Distillation. ICLR 2016.

[41] B. McMahan et al. Communication-Efficient Learning of Deep Networks from Decentralized Data (FedAvg). AISTATS 2017.

[42] M. Shapiro, N. Preguiça, C. Baquero, M. Zawirski. Conflict-Free Replicated Data Types. SSS 2011.

[43] M. Dennis et al. Emergent Complexity and Zero-Shot Transfer via Unsupervised Environment Design (PAIRED). NeurIPS 2020.

[44] R. Wang et al. Paired Open-Ended Trailblazer (POET): Endlessly Generating Increasingly Complex and Diverse Learning Environments and Their Solutions. arXiv:1901.01753, 2019.