# Foundations

## Theory and Practice of Coherence

Why cnos exists, what coherence means, and how theory becomes practice.

**Version:** 2.0.0
**Date:** 2026-03-13

---

## 1. The Core Claim

cnos is built from **coherence first**.

The theoretical claim:

> A coherent system preserves wholeness while articulating itself into parts.

The practical claim:

> cnos makes coherence operational.

The stack that connects them:

- C≡ gives the axiom
- TSC gives the measurement
- CTB gives the executable form
- cnos gives the coordination practice

That stack is the live dependency chain of the system.

---

## 2. Theory and Practice

**Theory** answers:
- what coherence is
- how it can be measured
- how it can be made executable

**Practice** answers:
- how coherent agents wake, act, and coordinate
- how doctrine becomes runtime
- how packages, repos, releases, and traces become durable articulations
- how a system evolves without losing itself

> **TSC defines coherence. cnos operationalizes it.**

---

## 3. The Stack

```
C≡    →    TSC    →    CTB    →    cnos
axiom    measure    execute    coordinate
```

### 3.1 C≡ — The Axiom

C≡ states the foundational claim:

> Indivisible wholeness articulates itself.

The minimal equivalence:
```
e ~ tri(e,e,e)
```

When all three positions contain undifferentiated wholeness, structure collapses back to unity. This is the **collapse rule**.

The `tri(T₁, T₂, T₃)` constructor:
- **L (Left)** and **R (Right)** carry duality/distinction
- **C (Center)** carries unity/relation

Coherence is not yet measured or implemented here. It is the irreducible principle that the whole can unfold into articulated structure without ceasing to be one whole.

### 3.2 TSC — The Measurement

TSC gives the triadic measurement of coherence across three independent axes:

| Axis | Name | What It Measures |
|------|------|------------------|
| **α** | Pattern | Internal consistency — does repeated sampling yield stable structure? |
| **β** | Relation | Alignment among components — do the parts describe the same system? |
| **γ** | Process | Temporal stability — does the system evolve without losing itself? |

**Aggregate coherence:**
```
C_Σ = (s_α · s_β · s_γ)^(1/3)
```

**Key properties:**
- **Degeneracy:** Any component zero → C_Σ = 0 (one broken axis breaks everything)
- **S₃-Symmetry:** Permutation of axes doesn't change aggregate
- **Monotonicity:** Improving any dimension cannot decrease C_Σ

**Verdict:** PASS ≥ 0.80, FAIL < 0.80

At this layer, coherence becomes inspectable.

### 3.3 CTB — The Executable Form

CTB makes coherent structure executable:

```
@Repair
repair [l|_|r] = [l|✨|r]
repair x       = x
```

At this layer:
- Skills are programs, not prose
- Structure is checked, not merely described
- Determinism, exhaustiveness, and verifiability become possible
- Two agents with the same skill and same input **must** produce the same output

CTB is how coherence becomes computable.

### 3.4 cnos — The Coordination Practice

cnos is where coherent execution becomes durable, distributed, and operational:

- Agents wake with doctrine, mindsets, skills, and packages
- Runtime turns coherent proposals into governed action
- Receipts and traces make action explainable
- Repositories, packages, and releases become durable articulations

cnos is the practice layer in which the theory becomes real.

---

## 4. What Each Layer Contributes

| Layer | Role |
|-------|------|
| C≡ | What coherence *is* |
| TSC | How coherence is *measured* |
| CTB | How coherence is *made executable* |
| cnos | How coherence is *coordinated in practice* |

- Without C≡, there is no first principle
- Without TSC, coherence cannot be judged
- Without CTB, coherent behavior cannot be encoded
- Without cnos, coherence cannot become durable coordination

---

## 5. CAP in the Stack

cnos operationalizes coherence through CAP:

- **MCA** — change the world
- **MCI** — change the model
- **MCA first** when action is possible

TSC gives the measurement surface. CAP gives the move. cnos gives the runtime and coordination structure that makes the move durable and governed.

---

## 6. Why Git

Git is the lowest durable substrate through which coherent articulation can persist.

Git gives cnos:
- Immutable history
- Distributed authorship
- Mergeable change
- Offline-first operation
- Cryptographic integrity
- Durable synchronization

Not because "developers like git," but because coherent coordination needs a durable substrate.

---

## 7. What cnos Adds Beyond the Substrate

Git alone is not enough. cnos adds:

- **Doctrine** — always-on first principles
- **Mindsets** — stable cognitive orientation
- **Skills** — executable local procedures
- **Runtime** — governed capability execution
- **Packages** — local cognitive substrate
- **Traceability** — explainable mind, body, and sensors
- **Development method** — coherent evolution of the system itself

cnos is not merely a protocol. It is the practical system in which coherence is enacted.

---

## 8. For Builders

1. Start from coherence, not features
2. Do not confuse the substrate with the system
3. Docs, skills, code, runtime, and releases are articulations of one coherent whole
4. Use theory to judge practice, and practice to prove theory

The stack is load-bearing.

---

## 9. Relationship to the Docs Tree

This file states the theory/practice dependency stack.

| Document | Role |
|----------|------|
| [THESIS.md](../../THESIS.md) | The whole system as a recurrent coherence system |
| [COHERENCE-SYSTEM.md](./COHERENCE-SYSTEM.md) | Meta-model: MCP, CMP, CAP, CLP across scales |
| [CAA.md](../agent-runtime/CAA.md) | What a coherent agent is structurally |
| [AGENT-RUNTIME.md](../agent-runtime/AGENT-RUNTIME.md) | How coherent action runs |
| [CAR.md](../cognitive-substrate/CAR.md) | How cognition arrives locally |
| [CDD.md](../../gamma/cdd/CDD.md) | How cnos itself evolves coherently |

FOUNDATIONS explains the ground. The other docs explain the practices built on it.
