World Model

Two distinct things go by the name "world model" today. Understanding the difference clarifies what each layer is for.

The two definitions#

Neural world model — a neural network trained to simulate how the world evolves under actions. Given an observation and an action, it predicts the next state. Action-conditioned, generative, trained on petabytes of sensor data. Architecturally: a Vision model compresses observations into latent space, a Memory model (RSSM / MDN-RNN) predicts how latents evolve given actions, a Controller selects actions. These systems simulate possible futures — they are generative engines, not databases.

Operational world model — a persistent, queryable store of actual world state. What entities exist, where they are, how they relate to each other, how confident we are in each fact, what the world looked like at any previous moment. This is ArcFlow. It records. Neural model outputs land here as they arrive (_observation_class: 'predicted'), alongside sensor-confirmed observations and inferred facts, all versioned and spatially indexed.

These two layers are distinct but complementary. Neural world models generate possible futures → their outputs land in ArcFlow as queryable predicted state. ArcFlow's grounded observations feed back as the actual world state the neural model learns to predict from. One simulates, one records.

ArcFlow is the operational world model layer.

The operational questions ArcFlow is built to answer:

MATCH (s:Sensor)-[d:DETECTED]->(r:Robot)-[:OCCUPIES]->(z:Zone)
WHERE d.confidence >= 0.90 AND z.hazard > 0.15 AND r.battery < 30
RETURN r.name, z.name, avg(s.reliability * d.confidence) AS trust

This runs in ~0.1ms. Deterministically. Against exact sensor history.

A robot navigating a warehouse. A camera network tracking 22 players at 60fps. An AI agent coordinating with other agents across sessions. A digital twin mirroring a physical facility. All of these need the same underlying infrastructure: a continuously updated, spatially grounded, temporally aware, confidence-scored store of what is actually happening.

ArcFlow is built to be that store.

What makes a world model different from a database#

Most databases store facts. A world model stores facts plus the spatial context, temporal history, confidence level, and provenance of each fact. This isn't a feature extension — it's an architectural difference.

These aren't checkboxes. They're the minimum requirements for a system that needs to reason about the world.

Observed, inferred, predicted#

The world model distinguishes three epistemic states for every fact:

Observed — directly measured by a sensor, confirmed by an event, or received from a trusted source. The highest confidence class. A player's position from a calibrated camera feed. A confirmed transaction. A verified identity link.

Inferred — derived through reasoning over observed facts. A trajectory extrapolated from position history. A relationship type concluded from behavioral patterns. Medium confidence — the logic may be sound, but the source data has its own uncertainty.

Predicted — model output, statistical projection, or estimated future state. A contact detected by radar at low confidence. An entity's likely position in three frames. Lowest trust — useful for planning, not for ground truth.

-- Only act on high-confidence observed facts
MATCH (e:Entity)
WHERE e._observation_class = 'observed'
  AND e._confidence > 0.9
RETURN e.name, e.x, e.y, e.z
 
-- Flag predictions for follow-up verification
MATCH (e:Entity)-[r:DETECTS]->(contact:Entity)
WHERE contact._observation_class = 'predicted'
  AND r._confidence < 0.5
RETURN e.name, contact.name, r.sensor, r._confidence
ORDER BY r._confidence ASC

This distinction is what makes world model queries trustworthy, not just fast.

Spatial-temporal as a first-class dimension#

Space and time are not columns in ArcFlow — they are native dimensions.

Spatial: point({x, y, z}) values are indexed by the ArcFlow Spatial Index. Nearest-neighbor queries, radius queries, bounding boxes, frustum queries, and line-of-sight calculations are built in — not implemented in application code.

Temporal: every mutation is versioned. The graph at any previous point in time is fully queryable. Not from an audit log or a separate history table — from the same graph, the same queries, just AS OF seq N.

-- Where were all entities at a recent checkpoint?
MATCH (e:Entity) AS OF seq 500
RETURN e.name, e.x, e.y, e.z
 
-- K-nearest entities to a point (ArcFlow Spatial Index backed)
CALL algo.nearestNodes(point({x: 40.0, y: 60.0}), 'Entity', 10)
YIELD node, distance
RETURN node.name, distance
 
-- Frustum query — what is visible from this camera?
CALL arcflow.scene.frustumQuery(0, 0, 15, 0, 1, 0, 90, 1, 200)
YIELD node_id, label, x, y, z

Graph structure for relational reasoning#

Physical reality is relational. Entities belong to groups, communicate through channels, are detected by sensors, occupy zones, and interact along paths. A world model that stores only entity properties misses the structure that makes reasoning possible.

ArcFlow stores relationships as first-class objects with their own properties, direction, and confidence. The network of relationships — formation membership, communication links, detection edges, zone occupancy — is queryable with the same pattern syntax as entity properties.

-- Entities within 30m of the origin AND in the Alpha formation
CALL algo.nearestNodes(point({x: 0, y: 0}), 'Entity', 20)
YIELD node AS e, distance
WHERE distance < 30
MATCH (e)-[:MEMBER_OF]->(f:Formation {name: 'Alpha'})
RETURN e.name, distance, f.pattern
 
-- Shortest communication path between two entities
MATCH p = shortestPath(
  (a:Entity {name: 'Drone-01'}),
  (b:Entity {name: 'Rover-03'})
)
RETURN p, length(p)

Continuous and always-current#

A world model that requires polling is not continuous. Standing queries mean the model is always current — what you declared you care about is maintained continuously, without polling, without batch jobs, without scheduler latency.

const db = open('./data/world-model')
 
// Standing pattern: fires when a new entity enters proximity
const monitor = db.subscribe(
  `MATCH (a:Entity)-[:DETECTS]->(b:Entity)
   WHERE b._observation_class = 'predicted'
   RETURN a.name, b.name, b.x, b.y`,
  (event) => {
    for (const row of event.added) {
      // A new predicted contact has been detected
      scheduleVerification(row.get('b.name'))
    }
  }
)

ArcFlow in the AI infrastructure stack#

The AI infrastructure stack now has three tiers:

Neural world models are the prediction tier — extraordinary at simulating possible futures given an observation and an action. They are not designed to remember that Robot-04 entered Zone-B at 14:23:07 with confidence 0.91, or that the ball crossed the goal line 200ms before the keeper moved. Their outputs are ephemeral: video frames, latent tensors, predicted detections.

ArcFlow is the persistence tier — the layer that receives those outputs, stores them as queryable facts (_observation_class: 'predicted'), and maintains the full history alongside observed and inferred facts. When the neural model needs ground truth for its next inference, it reads from ArcFlow.

An autonomous vehicle fleet needs to know where every vehicle is, where it was, and what confidence level its sensor data carries — not approximated by vector similarity, not generated by a language model, but tracked precisely in a spatial-temporal graph. A multi-agent AI system needs persistent shared state that every agent reads from and writes to, with full provenance of who changed what and when.

That is ArcFlow: the operational world model layer that neural world models, foundation models, agent frameworks, and reasoning systems build on top of.

Why OZ built ArcFlow#

OZ builds operational AI infrastructure for physical environments — sports venues, industrial facilities, autonomous fleets. Every system OZ runs needs the same thing at its core: a continuous, spatial-temporal record of what is happening, where, and how reliably we know it.

That record did not exist as a database product. The landscape had two failure modes:

General-purpose databases treat coordinates as numeric columns, timestamps as metadata, and confidence as something you implement yourself. Spatial queries require extensions. Temporal history requires separate audit tables. Confidence scoring is entirely application logic. The result is a stack of five systems doing the work of one — each with its own consistency model, each requiring its own maintenance, each introducing its own latency.

Neural world models are extraordinary at simulating possible futures — action-predicated prediction trained on petabytes of sensor data. They are not designed as a queryable store of what actually happened. They do not give you AS OF seq N access to ground truth, nor do they maintain the graph of which sensor produced which detection at what confidence.

The world model era is real. But it has two layers, not one. Generative prediction at the top. Operational persistence underneath. AI systems that navigate physical environments, coordinate autonomous fleets, or make decisions with real consequences need both.

The in-process architecture is not a convenience — it is an architectural requirement. Neural world models require GPU inference clusters and return in 100–1000ms. A real-time control loop — robotics, autonomous vehicles, live multi-agent coordination — cannot tolerate a network hop on every state query. ArcFlow runs co-located with the agent, at microsecond latency, with zero serialization overhead. There is no production alternative.

The multi-agent case is almost entirely unaddressed by the neural WFM literature, which focuses on single-agent simulation. ArcFlow's architecture is built for it natively: multiple agents write into and read from the same persistent graph simultaneously, with full provenance of who changed what and when. A shared world model is what makes a fleet a fleet rather than a collection of isolated agents.

OZ built ArcFlow because the persistence layer did not exist. It runs in-process (no server, no round-trip), in the browser (any device, zero install), or as a lightweight server — with the same query language, the same temporal guarantees, the same confidence model everywhere.

Not a research prototype. Production infrastructure — deployed, operating, and under continuous load.

Calibrated uncertainty — a solved problem here#

The research community is publishing papers about calibrated uncertainty in neural world models ("World Models That Know When They Don't Know" — WorldScore benchmark, 2025). For neural WFMs, knowing when they're uncertain is a frontier research problem.

ArcFlow has had _confidence and _observation_class as first-class properties on every node and edge since day one. Not a feature — the data model. Every neural model output that lands in ArcFlow is tagged with how confident the source was. Every sensor reading carries its reliability. Queries filter on it natively:

-- Only act on facts the system is sure about
MATCH (e:Entity)
WHERE e._observation_class = 'observed' AND e._confidence > 0.9
RETURN e.name, e.x, e.y
 
-- Surface everything the system is uncertain about
MATCH (e:Entity)-[r]->(contact:Entity)
WHERE contact._observation_class = 'predicted' AND r._confidence < 0.6
RETURN e.name, contact.name, r._confidence, r._source
ORDER BY r._confidence ASC

The research community wants calibrated uncertainty in their neural models. It already exists in the persistence layer.

See Also#

• Building a World Model — step-by-step guide with 20 entities, spatial queries, temporal memory, and algorithm overlay
• Grounded Neural Objects — lifting neural world model outputs into persistent ArcFlow entities
• Autonomous Systems — the two-layer stack applied to robot fleets and UAV coordination
• Confidence & Provenance — scoring and tracing every fact
• Observations & Evidence — the observation model in detail
• Spatial Queries — spatial primitives deep dive
• Temporal Queries — querying past states
• Live Queries — standing queries and live views