&ND v2

+++document/meta
schemaVersion = "1"
id = "aeon-quick-mental-model"
title = "AEON Quick Mental Model"
description = "High-level mental model of the AEON stack across structure, meaning, policy, and processing behavior."
family = "conventions"
group = "Convention Overview"
standing = "official"
lifecycle = "draft"
normativity = "informative"
license = "CC-BY-4.0"
path = "specification/conventions/quick-mental-model"
order = 10
publish = true
keywords = ["AEON", "mental model", "structure", "meaning", "policy", "processors"]
related = []
+++


# AEON Quick Mental Model [# aeon-quick-mental-model]

AEON is a structured data format designed for [* deterministic meaning, extensibility, and verifiable documents].

It separates four concerns:

~~~$ text
Structure → Meaning → Policy → Behavior
~~~$

| Layer       | Responsibility    |
| <--         | <--               |
| AEON Core   | defines structure |
| Conventions | define meaning    |
| Profiles    | define policy     |
| Processors  | define behavior   |
|~ AEON ecosystem layer responsibilities

---


## 1. What AEON Actually Is [# what-aeon-actually-is]

At its core, AEON is a system of [* deterministic assignments].

Example:

~~~$ aeon
user = {
  name = "Alice"
  role = "admin"
}
~~~$

This produces a canonical structural state.

AEON focuses on [* how data is structured], not what the data means.

Meaning is added by conventions.

---


## 2. The Three Parts of an AEON Document [# the-three-parts-of-an-aeon-document]

Most AEON documents follow this conceptual layout:

~~~$ text
aeon:header
document body
aeon:envelope
~~~$

Example:

~~~$ aeon
aeon:header = {
  encoding = "utf-8"
  mode = "strict"
}

data = {
  message = "Hello world"
}

"aeon:envelope":securityEnvelope = {
  integrity:integrityBlock = { ... }
}
~~~$


### Header [# header]

Processing metadata.


### Body [# body]

The actual structured data.


### Envelope [# envelope]

Security closure (optional).

---


## 3. AEON Is Not Just a Data Format [# aeon-is-not-just-a-data-format]

Most formats stop here:

~~~$ text
syntax → data
~~~$

AEON goes further:

~~~$ text
syntax
  ↓
canonical structure
  ↓
conventions
  ↓
profiles
  ↓
processors
~~~$

This allows AEON to support things like:

- signed documents
- structured metadata
- contextual interpretation
- verifiable datasets

without making the core language complex.

---


## 4. Conventions Add Meaning [# conventions-add-meaning]

AEON core does not interpret fields.

Instead, documents declare conventions.

Example:

~~~$ aeon
aeon:header = {

  encoding = "utf-8"
  mode = "strict"
  conventions = [
    "aeon.gp.measurement.v1"
  ]

}
~~~$

The convention tells consumers how to interpret certain fields.

Example:

~~~$ aeon
distance@{unit="meters"} = 3
~~~$

The [* unit meaning] is defined by a convention, not the language.

---


## 5. Profiles Add Policy [# profiles-add-policy]

Profiles define [* safe usage bundles].

Example:

~~~$ text
aeon.secure-basic.v1
~~~$

Profiles may define:

- required conventions
- allowed algorithms
- processing constraints

Profiles exist so independent implementations can interoperate safely.

---


## 6. Canonicalization Matters [# canonicalization-matters]

AEON guarantees that documents have a [* deterministic canonical structure].

Example:

~~~$ aeon
b = 2
a = 1
~~~$

Canonical ordering becomes:

~~~$ aeon
a = 1
b = 2
~~~$

This property enables:

- reproducible hashing
- cryptographic signatures
- deterministic processing

---


## 7. Security Is Layered [# security-is-layered]

Security is not built into the syntax.

Instead AEON defines conventions:

| Convention                | Purpose            |
| <--                       | <--                |
| [$ aeon.gp.security.v1]   | envelope structure |
| [$ aeon.gp.integrity.v1]  | canonical hashing  |
| [$ aeon.gp.signature.v1]  | signatures         |
| [$ aeon.gp.encryption.v1] | encryption         |
|~ AEON security conventions

Example envelope:

~~~$ aeon
"aeon:envelope":securityEnvelope = {
  integrity:integrityBlock = {
    alg:string = "sha256"
    hash:bytes = #...
  }

  signatures:signatureSet = [
    { alg:string = "ed25519" kid:string = "alice" sig:bytes = #... }
  ]
}
~~~$

This makes AEON documents [* self-verifying].

---


## 8. AEON Supports Advanced Integrity [# aeon-supports-advanced-integrity]

Because of canonical paths and deterministic structure, AEON naturally supports:

- Merkle subtree verification
- tamper-evident event logs
- verifiable datasets

These patterns can be built without modifying the core language.

---


## 9. What AEON Is Not [# what-aeon-is-not]

AEON deliberately avoids becoming:

- a programming language
- a computation system
- a schema engine
- a policy engine

Instead AEON focuses on [* deterministic structured representation].

Other systems can build on top of it.

---


## 10. Simple Mental Model [# simple-mental-model]

If you remember only one thing:

~~~$ text
AEON core defines structure.
Conventions define meaning.
Profiles define policy.
Processors define behavior.
~~~$

---


## 11. Typical Processing Pipeline [# typical-processing-pipeline]

~~~$ text
AEON source
   ↓
parse syntax
   ↓
build canonical structure
   ↓
apply conventions
   ↓
apply profile rules
   ↓
processor behavior
~~~$

---


## 12. A Small Example [# a-small-example]

~~~$ aeon
aeon:header = {
  encoding = "utf-8"
  mode = "strict"
  conventions = [
    "aeon.gp.measurement.v1"
    "aeon.gp.security.v1"
  ]
}

temperature@{unit="celsius"} = 23

"aeon:envelope":securityEnvelope = {
  integrity:integrityBlock = {
    alg:string = "sha256"
    hash:bytes = #1234...
  }
}
~~~$

This document:

- contains structured data
- declares interpretation conventions
- includes integrity protection

All without expanding the core language.

---


## Final Summary [# final-summary]

AEON is designed to provide:

- deterministic structured data
- extensible interpretation layers
- secure and verifiable documents
- long-term ecosystem growth

while keeping the [* core language minimal and stable].