Sequel to Pearls Now Supports RO-Crate via Open Package Assembly Language

Today we’re releasing the PATWU Protocol.

PATWU is a simple protocol for representing and exchanging changes to shared knowledge.

It consists of two parts:

• ROTE defines what may exist: Relation, Occurrence, Type, and Entity.

• MC³ defines how those things evolve: Match, Compose, Connect, and Conclude.

Everything else is built on top.

Using PATWU

Every PATWU interaction follows the same pattern.

Start by matching the part of the world you already know:

• Match Person(“Alice”)
• Match Organization(“Acme”)

Compose anything that does not yet exist:

• Compose Employment

Connect it into the existing graph:

• Connect Employment.employee -> Alice
• Connect Employment.employer -> Acme

When the relationship reaches its natural end:

• Conclude Employment

That’s an employment system. Marriage, publishing, and clinical trials work the exact same way. The protocol never changes—only the schema changes.

Rites & Schemas

A rite is a named MC³ program over a ROTE graph. For example, a hiring rite:

• Match Person
• Match Organization
• Compose Employment
• Connect employee
• Connect employer
• Connect role
• Connect startDate

PATWU does not standardize domain models. Instead, domains publish schemas (e.g., Employment, Publication, Invoice, SupplyChain) that define:

• the ROTE objects they introduce

• the constraints they satisfy

• the rites that evolve them

Two organizations with different schemas can still exchange rites because they share the same protocol.

Why This Matters

PATWU separates three concerns that are usually intertwined:

• ROTE defines the ontology.

• MC³ defines the protocol.

• Schemas define the domain.

This separation lets organizations innovate independently without inventing a new change protocol every time they model a new process.

What’s Next

This release includes:

• the PATWU specification

• the MC³ protocol

• the core ROTE ontology

• reference schemas and implementations

The protocol itself is intentionally finished. If you can express your domain in terms of Relations, Occurrences, Types, and Entities—and evolve them with Match, Compose, Connect, and Conclude—you’re speaking PATWU.

Appendix I: A Civilizational Protocol

Civilization was built on writing. Writing allowed knowledge, laws, and science to outlive memory. But writing made a profound simplification: it treated civilization as if its primary artifacts were static documents.

Increasingly, they aren’t. Organizations, supply chains, scientific collaborations, and software systems are not documents. They are living networks of relationships that continuously evolve through recognized acts.

In the age of AI, agents don’t simply read records—they participate in institutions.

From Writing to Rites

Every functioning institution depends on legitimate transformations: a marriage begins, a person is hired, a dataset is published, a company acquires another. These are not edits; they are rites—occurrences that a community agrees have consequences, authority, and evidence. Most importantly, a rite changes the world without destroying its integrity.

Instead of asking “What documents exist?”, PATWU asks “What legitimate rites have evolved this shared reality?”

ROTE & MC³ as Architecture

Most information systems begin with isolated objects. ROTE begins with relationships: Relation, Occurrence, Type, and Entity. Reality is an evolving web of connections; entities are simply participants within it.

If ROTE defines what exists, MC³ defines how it legitimately changes through four minimal primitives:

• Match — Find what already exists.

• Compose — Instantiate what does not yet exist.

• Connect — Establish relationships.

• Conclude — Bring a relationship to its natural end.

Like machine instructions, this instruction set remains tiny while the applications become unbounded. Every institutional act becomes a typed MC³ program operating over a ROTE graph.

Beyond CRUD: Evolving Integrity

Civilization advanced because we wrote. The next stage is to right what writing alone could never capture:

• Writing records facts; rites evolve relationships.

• Writing preserves memory; rites preserve legitimacy.

• Writing tells us what was; rites determine what now is.

Traditional software revolves around CRUD (Create, Read, Update, Delete). But CRUD manipulates static records by quietly overwriting past states.

CRUD asks: “What changed?” MC³ asks: “How did the integrity of the shared world evolve?”

Writing gave civilization memory. PATWU gives civilization a protocol for evolving integrity.

Appendix II: How We Got Here

Or: We accidentally stopped thinking in CRUD.

When we started building Opal, we thought we were solving a provenance problem, then a graph problem, then a protocol problem. Eventually, we realized we were mostly deleting things—conceptually.

Every time a system issues an Update, it pretends the previous world never existed. Every time an employee leaves, we overwrite or delete the record. But the real world doesn’t work that way. Nothing that ever happened unhappens. Relationships begin, evolve, and conclude, but they never become untrue.

So we stopped asking how to synchronize databases and asked: How does reality actually change?

The Discovery of ROTE and MC³

The answer wasn’t transactions or events; it was rites. Civilizations have always recognized that only specific, agreed-upon actions change the social world.

When we modeled these actions, the nouns collapsed into four concepts: Relations, Occurrences, Types, and Entities. We called them ROTE, realizing only later that civilization itself had largely been built by rote.

The verbs collapsed into four operations: Match, Compose, Connect, and Conclude (MC³). No updates, no deletes, no magical mutations.

Then came the epiphany: MC³ is the rites for ROTE. ROTE describes what exists. MC³ describes how it may legitimately change. Complex domain acts—hiring, publishing, certifying, trading—are not primitive database operations. They are typed rites built from MC³ operating over ROTE.

Why It Matters for AI

We didn’t set out to invent a new data model or replace CRUD. We were trying to answer a practical question:

> How can autonomous agents participate in organizations without slowly corrupting them?

The answer isn’t bigger databases or smarter models. It is giving agents what civilizations have always relied on: recognized rites that evolve shared reality without destroying its integrity.

That’s PATWU. The rest is just building civilizations with it.

Appendix III: Pearls All the Way Up

Or: Why we named it PATWU.

We get asked about the name a lot.

PATWU stands for Pearls All the Way Up.

It started as an internal joke, but like most good jokes in computer science, it turned out to be the accurate metaphor.

How a Pearl Forms

A pearl does not begin with grand design. It begins with an irritant—a foreign grain of sand entering an oyster.

The oyster cannot delete the grain. It cannot undo the intrusion.

Instead, it responds through a rite of encapsulation. It secretes layer after layer of nacre around the irritant. Each layer preserves the reality of what came before while restoring balance to the whole.

The pearl is not a static object. It is a continuous, immutable history of responses to an evolving world.

Strung Together

A single pearl is an occurrence.

When you connect pearls together with intentional structure, you get a strand.

A strand is a protocol.

When different communities weave their strands according to shared schemas, you get an institution.

And when institutions nest within institutions—from individual contracts to supply chains to global governance—you don’t get a giant, monolithic database.

You get Pearls All the Way Up.

The Metaphor as Protocol

This is why PATWU rejects CRUD:

• CRUD treats information like whiteboards—erasing the past to record the present.
• PATWU treats information like pearls—encapsulating every transformation without ever destroying what was.

Every Occurrence in ROTE is an irritant or an event in the world.

Every MC³ program is the nacre—the legitimate rite that safely wraps that occurrence and connects it to the existing graph.

You don’t edit reality. You enclose it. You layer it. You build on top of it.

It’s pearls, all the way down to the ontology, and Pearls All the Way Up to civilization.