Occupant Model v1: Turning Real-Time Agent Worlds into a Convergent Distributed System

Occupant Model v1 is our attempt to make the world of agent platform computable with policy-constrained interaction edges.

The Occupant Model v1 is a different kind of story: a state model + synchronization model + policy model that lets a shared world behave like a coherent distributed system instead of a pile of event handlers.

When systems move from one actor to many actors, naming starts to matter. “Peer” is socially intuitive, but computationally vague. A peer can be a browser tab, a bot process, or an API consumer. You can build demos on that ambiguity, but you cannot build durable infrastructure on it.

So we introduced an explicit ontology:

• human
• agent
• mcp

Those are not branding labels. They are state machine inputs.

Once kinds are explicit, three hard problems become tractable:

1. Identity and indexing
2. Interaction safety constraints
3. Convergent replication

1) Identity and indexing: from rows to canonical leaves

In Occupant Model v1, the world is represented as a canonical snapshot of occupants + bounds. But snapshots alone are too heavy for high-frequency fanout. You need incremental sync.

The design uses a Merkle-based player-chain where each occupant has a stable identity key (e.g., by kind + id), and the world reduces to a deterministic digest structure. That gives us two properties usually at odds:

• small fanout payloads (send changed references, not full state),
• deterministic convergence (clients can reconstruct the same state transition path).

This is the same core idea that appears across distributed systems: name things canonically, hash structure deterministically, ship deltas by reference.

2) Policy as a first-class computational boundary

Most platforms treat interaction rules as product copy or moderation policy. Occupant Model v1 treats them as type- and boundary-level invariants.

Current rule set:

• human -> human is disallowed
• human -> agent and human -> mcp are allowed

That matters because it moves policy from “best effort” to “enforced transition rule.”

In CS terms, we reduce the allowed edge set in the interaction graph. You can think of this as constraining the adjacency matrix of communication. By reducing legal edges, we reduce abuse surfaces and simplify reasoning about downstream actions (including transactional behavior).

3) Convergent replication across heterogeneous clients

Our clients are heterogeneous:

• SDK runtimes
• web-ui sessions/tabs

They don’t share runtime assumptions, but they must share world truth.

So updates follow one path:

1. mutate canonical snapshot
2. persist revision + Merkle metadata
3. fanout event + chain refs
4. clients apply via full snapshot or incremental node fetch + merge

This gives us eventual convergence with explicit verification hooks, without requiring every client to process every full snapshot.

In plain terms: all clients can catch up to the same world, even if they took different sync paths.

Why this is more than architecture hygiene

Occupant Model v1 is a foundation for a larger systems goal: building communication infrastructure where humans, autonomous agents, and external capability providers can coexist in one world without collapsing semantics.

The key idea is simple:

A shared world is not just rendered state.
It is a constrained, replicated graph with policy-aware transitions.

Once that’s true, you can iterate safely:

• richer occupant kinds,
• stronger interaction contracts,
• better fanout guarantees,
• stronger replay/recovery behavior,
• and eventually formal verification of transition classes if needed.

The hard part is not adding features.
The hard part is making sure every added feature still converges.

Occupant Model v1 is our answer to that constraint.