This section describes the same system three times, at increasing resolution: first the invariant boundary (2 Domains), then the functional split (3 Layers), then the fine grain (5 Tiers). Each pass adds detail; none replaces the previous. A reader who stops after the Domains still has the law of the system; the Layers and Tiers are two zoom levels of the same picture — not separate technology stacks.

Term	Count	What it is
Domain	2	The invariant security boundary: value-bearing data / value-free data.
Layer	3	The functional split: Settlement · Execution · Data.
Tier	5	The fine grain T0–T4: cryptographic assurance + storage policy matched to data value.

Relationship: 2 Domains → 3 Layers → 5 Tiers (increasing resolution). "Domain" is the law; "Layer" and "Tier" are two views of the same system at two resolutions.

Pass one — 2 Domains: the binary question (invariant)

Every piece of data answers one question:

Does this data need double-spend protection or composability?

Yes → the value Domain: it must live on a consensus chain.
No → the data Domain: high-volume, low-value events (likes, views, chat, IoT logs) that only need an immutable record, no per-record consensus.

The UAC (Universal Asset Commitment) primitive enforces this boundary: the data Domain is structurally forbidden from holding value. This is a test-checked invariant, not a loose convention. The two Domains are the foundation — the number of Layers or Tiers underneath can be presented differently, but the Domains are always two.

Pass two — 3 Layers: the functional split

Inside the value Domain, one slice of data is different in kind from the rest: it does not execute everyday transactions but finalizes and aggregates proofs for all of them. Separating that slice gives three Layers — matching the industry-standard mental model Settlement / Execution / Data:

Layer	Domain	Role	Volume*
① Settlement	value	Cross-region finality, aggregate & verify ZK proofs (`PAI`), root of trust (`SC`).	< 0.01%
② Execution	value	Prevent double-spend, keep state consistent, composability across chains.	~10%
③ Data (Availability)	data	Namespaced append-only logs: tamper-evident + timestamp + inclusion-provable. No per-record consensus.	~90%

*Design estimates by expected data mix — not point-in-time operational figures.

Layers ① and ② both sit in the value Domain (consensus chains: Cosmos SDK + CometBFT + IBC); Layer ③ is the data Domain. Splitting ① from ② is a functional distinction: Settlement is where proofs are aggregated and value is finalized — different in kind from Execution, where transactions run.

Pass three — 5 Tiers: the fine grain (T0–T4)

Look closer and the three Layers spread into five Tiers. Each Tier has cryptographic assurance and a storage (DA) policy matched to the value of the data, not its speed:

Layer	Tier	Function	DA storage	Volume*
① Settlement	T0 · Root	Final settlement, ZK proof	Permanent	< 0.01%
② Execution	T1 · Value	Double-spend protection	Long-lived	~1%
② Execution	T2 · Interactive	State consistency	Medium-term	~9%
③ Data	T3 · Events	Tamper-evidence, timestamp	Prune ~weekly	~85%
③ Data	T4 · Edge	Attestation at checkpoint	Ephemeral	~5%

*Design estimates.

The core idea: tiering makes large-scale economics feasible by concentrating the expensive cryptographic guarantees on the data that truly carries value — instead of a monolithic chain paying consensus prices even for "likes".

Figure 3 — Most "transactions" never touch consensus (Data Layer); value is sharded in parallel (Execution); the apex only verifies proofs (Settlement).

How the Layers connect: "verify, don't re-execute"

The principle joining the Domains is verify, don't re-execute:

Data → Execution/Settlement: data committed on the Data Layer is retrievable/sampleable per the Tier's policy (DA Interface). The consensus chains do not re-run that volume — they only verify an inclusion/availability proof when a single event needs to be anchored into the value Domain.
Execution → Settlement: the value chains do not push their whole state to the Root. They compress it into proofs; the Settlement Layer aggregates and verifies (PAI) then finalizes (SC). The Root only verifies — one pairing on a small proof — never re-executing the child chains' transactions.

So the cost at the root of trust stays nearly constant no matter how much the edge volume (Tiers T3/T4) grows. The concrete testnet realization of this — three consensus chains plus namespaces on a DA node — and its live numbers are in Status & Live Network.

Takeaway: the architecture settles where data lives. What it has not yet said is how chains talk across these boundaries — and that interaction, not raw speed, is where multi-chain systems usually break. The cross-chain model is next.