#Data Hierarchy

The cryptography section showed what protects each piece of content: SLH-DSA signs it, SHA-512 fingerprints it, and AES-256-GCM encrypts the parts you want to keep private. But before any of that can happen, the content needs a structure. How is a Mind actually organized? What are the pieces, and how do they fit together?

The short answer is that a Mind is not one big file. It is a tree of small, individually addressable pieces, and each piece is identified by the SHA-512 fingerprint of its contents. The tree is called a Merkle DAG, and the pieces come in four types.

#Why Not One Big File?

The simplest approach would be to store an entire avatar as a single JSON blob. Everything about Einstein in one file, download the whole thing, done. This works when the avatar is small, but it breaks as soon as the content grows.

The answer is to break the avatar into small pieces, each with its own SHA-512 fingerprint, and link them together in a tree. Change one piece and only that piece gets a new fingerprint. The rest stays untouched.

#The Four Levels

Every avatar on Avatarnet follows the same four-level hierarchy. The running example throughout is einstein.avtr.

Here is what Einstein's avatar looks like as a folder tree. Each level nests inside the one above it, from the avatar at the top down to individual engrams at the leaves.

#Avatar

The Avatar is the root of the tree. It represents the whole person and has a .avtr domain name like einstein.avtr. The avatar object holds the person's display name, a profile image hash, a list of experience hashes, and the public key that signs everything below it. When someone types einstein.avtr into the browser, the network returns this root object first.

#Experience

An Experience is a major topic area, like a book on a shelf. Einstein might have one for "Physics Papers", another for "Education", and a third for "Music". Each experience contains a list of memory hashes as its children. Experiences do not hold any content directly. They are organizational containers that point downward into the tree.

#Memory

A Memory is a grouping that organizes engrams below it, like a chapter in a book. In the simplest case, an experience contains memories and each memory contains engrams. But memories can also contain other memories, up to three levels deep. This is optional. A simple avatar might never nest beyond one level, while a detailed textbook might use all three.

In the tree above, "Annus Mirabilis 1905" is a depth-1 memory that contains depth-2 memories like "Photoelectric Effect". Under "General Relativity", the nesting goes all the way to depth 3: "Development and Field Equations" contains "Equivalence Principle", which can only hold engrams.

#Engram

The Engram is the atomic unit of content. It is a single page of text, up to 8,192 characters, roughly three printed pages. If a topic needs more space, the author splits it into multiple engrams linked by references.

Each engram carries the text itself, a title, a timestamp, the author's public key, and a signature that proves the author wrote it. The SHA-512 hash of the entire engram object becomes its permanent address on the network.

#How They Connect: The Merkle DAG

The four levels are not just a filing system. They form a Merkle DAG, which stands for Directed Acyclic Graph. In a Merkle DAG, every node is identified by the SHA-512 hash of its contents, and every parent node includes the hashes of its children. Because the parent's hash depends on its children's hashes, a change at any level ripples upward through the tree.

Root: einstein.avtr
hash = SHA-512(avatar object including experience hashes)
        │              │              │
    hash_A          hash_B          hash_C
    Physics Papers  Education       Personal Life
    (Experience)    (Experience)    (Experience)
        │
    hash_M1 (Memory: "Photoelectric Effect")
    includes child hashes: [hash_1, hash_2, hash_3]
        │              │              │
    hash_1          hash_2          hash_3
    Photoelectric   Einstein's      Experimental
    Effect          Solution        Confirmation
    (Engram)        (Engram)        (Engram)

The word "directed" means links only go from parent to child, never backwards. "Acyclic" means there are no loops, so a child cannot be its own grandparent. "Graph" means the structure is more flexible than a strict tree, because the same engram can be referenced from more than one memory through cross-links.

#Change Propagation

This is where the Merkle DAG pays for itself. Suppose the creator fixes a typo in "The Long Road (1907-1915)" engram. Here is what happens.

1. "The Long Road" content changes  →  engram hash becomes hash_NEW
2. "Equivalence Principle" memory includes hash_NEW  →  memory hash changes
3. "Development and Field Equations" memory includes new child hash  →  memory hash changes
4. "General Relativity" memory includes new child hash  →  memory hash changes
5. "Physics Papers" experience includes new child hash  →  experience hash changes
6. Root manifest includes new experience hash  →  root hash changes

Result: 6 hashes changed (1 engram + 3 memories + 1 experience + 1 root).
Everything else is untouched. "Education", "Music", and every
engram in those experiences keeps its original hash.

This is exactly how git works. Every commit hash depends on its tree hash, which depends on blob hashes. Change one file and hashes ripple up to the root, while everything else stays the same.

#Why This Matters

The Merkle DAG gives Avatarnet four properties that a flat file cannot.

Efficient updates. When the creator edits one engram, only the changed objects and their ancestors need to be re-uploaded. A machine that already has the other 499 engrams does not need to download them again.

Tamper detection. Any machine can prove it holds the correct data by presenting the root hash. If any engram anywhere in the tree has been modified, the root hash will not match. A single 64-byte fingerprint verifies the integrity of the entire avatar.

Selective fetching. A visitor who only wants to read "Physics Papers" downloads that one experience and its children. They never touch "Music" or "Letters". The browser fetches content on demand, like a web browser loading pages as you click, not a zip file that forces you to download everything.

Permanent addresses. An engram that never changes keeps its SHA-512 hash forever. That hash is the engram's address on the network, and it stays valid for as long as the content exists. Unchanged content is always cacheable, always verifiable, and never needs re-uploading.

Every level in this hierarchy needs an address, and Avatarnet does not use a central database to assign one. Instead, each piece of content carries its own address, derived from the content itself. The next page Content Addressing explains how that works.