title: T81 Foundation Specification — Cognitive Tiers
nav:
← Back to Spec Index
Cognitive Tiers Specification
Version 0.3 — Draft (Standards Track)
Status: Draft → Standards Track
Last Revised: 2026-03-01
Applies to: Axion, T81VM, T81Lang, TISC
The Cognitive Tier Model defines progressively more complex modes of computation and reasoning within the T81 Ecosystem.
Tiers allow Axion to enforce:
- complexity limits
- recursion and branching bounds
- symbolic reasoning constraints
- safety and ethics policies
This document specifies tier structure, progression, constraints, and execution semantics.
0. Rationale
Higher-order computation—deep recursion, symbolic reasoning, large tensor transformations—requires strict supervision to:
- ensure determinism
- avoid runaway complexity
- preserve canonical structure
- maintain safety boundaries
- support verifiable reasoning paths
The T81 architecture separates computation into five deterministic levels, each governed by Axion.
1. Tier Structure
Axion defines five cognitive tiers.
A program may declare, inherit, or be forcibly promoted to a tier based on behavior.
Tier 0 — Ground State (Load & Validation)
Tier 0 is not computational; it is an Axion validation state.
A program in Tier 0:
- is being loaded
- is being type-checked, shape-checked, and canonicalized
- has not yet begun execution
Axion validates:
- metadata
- purity declarations
- tier annotations
- resource projections
If validation fails, execution never begins.
Tier 1 — Pure Deterministic Computation
Tier for:
- primitive arithmetic
- pure functions
- no mutable state
- no deep recursion (≤1 indirect call level)
- no tensor operations above rank-1
- simple control flow
Tier 1 is the most restrictive and the easiest to fully certify.
Tier 1 Constraints
- recursion depth ≤ 1
- loop iteration must be statically bounded
- all types must be canonical
- no calls to Axion privileged instructions except:
- tensor rank ≤ 1
- branching must not depend on high-entropy data
Axion expects Tier 1 code to be provably safe.
Conformance program: spec/conformance/cognitive-tiers/tier-annotation-enforcement.t81
Tier 2 — Structured Algorithms
Tier for:
- deterministic loops (possibly unbounded, if annotated)
- structured branching
- shallow recursion (≤10 depth)
- vector and matrix operations
- limited tensor operations (rank ≤ 3)
Tier 2 allows efficient high-level algorithms while remaining predictably deterministic.
Tier 2 Constraints
- recursion ≤ 10
- matrices must have shape ≤ 81×81
- tensor rank ≤ 3
- no symbolic search
- branching structure must be finite and predictable
- effectful operations allowed with explicit annotation
Axion enforces complexity ceilings at this level.
Tier 3 — Recursive / Symbolic Reasoning
Tier for:
- recursive algorithms with deep structural patterns
- symbolic manipulations
- graph-based algorithms
- shape-transforming deep tensor ops
- tree search (bounded)
- state-space exploration with canonical pruning
Tier 3 is where “high-level intelligence” begins to emerge.
Tier 3 Constraints
- recursion ≤ 81
- tree/graph exploration must have explicit bounding functions
- tensor rank ≤ 5
- symbolic operations must have deterministic reduction strategies
- Axion MUST monitor convergence
Failure to converge → Tier Fault and termination.
Tier 4 — Analytic Reasoning (Advanced)
Tier for:
- advanced symbolic reasoning
- multi-layer recursive structures
- quasi-proof systems
- bounded combinatorial search
- statistically guided heuristics (deterministic heuristics only)
Tier 4 computations are powerful and closely supervised by Axion.
Tier 4 Constraints
- recursion ≤ 243
- tensor rank ≤ 7
- graph depth ≤ 3 canonical passes
- search must be explicitly bounded and monotonic
- effectful operations allowed only under policy rules
- branching entropy must remain below Axion-set thresholds
Tier 4 requires explicit opt-in from the program.
Tier 5 is the highest tier permitted in the T81 architecture.
Tier for:
- metareasoning
- proof transformation
- program self-analysis
- structural reflection
- tier supervision logic
- high-order symbolic recursion
Tier 5 is used by Axion itself and by programs that have been explicitly granted metacognitive permission.
Tier 5 Constraints
- recursion ≤ 729
- tensor rank ≤ 9
- no uncontrolled shape growth
- no unbounded symbolic expansion
- explicit invariants must be declared
- Axion may inject deterministic constraints
Tier 5 computation is always supervised by Axion.
2. Tier Determination
Axion determines the tier of a program using three mechanisms:
2.1 Static Tier Declarations
Programmers may annotate functions with a numeric tier value (1–5):
@tier(3)
fn analyze_graph(g: Graph) -> Result { ... }
Annotation convention:
@tier(N) accepts integers 1 through 5 only.@tier(0) is not user-declarable. Tier 0 is an Axion-internal validation
state; user code is never resident in Tier 0 during execution.- If no
@tier annotation is present, Axion infers the tier from observed
behavior and may promote dynamically (see §2.2).
Static declarations indicate intent.
Axion MUST verify that behavior matches declaration.
If mismatch → Tier Fault.
If program behavior exceeds its tier:
- recursion too deep
- symbolic reasoning detected
- tensor rank violation
- branching explosion
Axion MAY promote execution to a higher tier.
Promotion must be:
- deterministic
- logged in META
- consistent with tier boundaries
2.3 Tier Enforcement
If program enters a tier it is not allowed to enter (due to policy limits):
- Axion MUST halt the program
- produce structured Tier Fault metadata
- optionally snapshot VM state
3. Complexity Metrics (Normative)
Axion evaluates complexity using these metrics:
3.1 Recursion Depth
Tracked in RCS (Recursion Control Subsystem).
3.2 Shape Complexity
For tensors/matrices:
complexity = product(shape) × rank
3.3 Branching Entropy
Each conditional contributes entropy. Tier 4+ places strict limits.
3.4 Symbolic Complexity
Measured as:
- term depth
- DAG width
- rewrite rule count
3.5 Graph/Tensor Explosion Risk
Tier 3+ requires convergence analysis.
4. Tier Transitions
Tier transitions are always:
- deterministic
- logged
- observable by T81VM
- reversible or final based on Axion policy
Occurs when:
- recursion exceeds threshold
- symbolic reasoning triggered
- tensor rank increases
- branch divergence increases beyond tier limits
4.2 Tier-Down (Demotion)
Occurs when:
- recursion ends
- symbolic operations cease
- tensor rank decreases
- program returns to simpler patterns
Axion uses a conservative approach to downshifts.
5. Enforcement
5.1 On Violation
If execution violates tier constraints:
-
Axion MUST issue a Tier Fault
-
VM MUST stop issuing further instructions
-
canonical snapshot MAY be taken
-
META MUST include:
- tier at violation
- reason code
- relevant call stack info
- recent operations
5.2 Interaction With Purity and Effects
Tier rules complement purity analysis:
- Tier 1: pure functions only
- Tier 2+: effectful allowed with annotations
- Tier 4+: highly restricted effect patterns
- Tier 5: effectful operations allowed only under Axion policy
6. Interoperability Summary
Cognitive Tiers MUST interoperate with:
- Axion Kernel: tier control, metrics, faults
- T81Lang: tier annotations, purity rules
- T81VM: execution visibility, trace
- TISC: instruction supervision
- Data Types: shape, tensor, structural complexity
Cross-References
Overview
Data Types
TISC
- Privileged Instructions & Tier Hooks →
tisc-spec.md
- Note:
AXREAD and AXSET are restricted to Tier 2 and above.
AXVERIFY is the only privileged instruction permitted in Tier 1 (see §1, Tier 1 Constraints).
T81VM
Axion
T81Lang