Overview
A Praxeological Operating System Architecture
Derived from “Praxeological Meta-Structure Theory” (PMS): operators → language → CPU → memory → filesystem → AI integration → distributed systems.
What this is
PMS-STACK is a conceptual system architecture that realises the Praxeological Meta-Structure (PMS) operator grammar as an executable stack: from irreducible operators (Δ–Ψ) to PMSL, execution semantics, structural memory, persistence boundaries, and invariant enforcement.
PMS-STACK is not presented as a replacement for existing operating systems. It is an architectural exploration of structural execution, derived from a formal operator grammar.
Concrete anchor:
PMS-STACK treats “programs” as operator chains with explicit
frames (□), commit boundaries (Σ), and
invariants (Ψ), executed by a structural machine
(PMS-CPU) and preserved as auditable structural artifacts.
Why PMS-STACK
Many contemporary stacks are historically layered: abstractions accumulate, security is retrofitted, and invariants become conventions rather than enforced structure.
PMS-STACK inverts that order:
formal structure first → CPU semantics, kernel boundaries, storage, networking, and governance follow as consequences.
- Implicit context and hidden assumptions (“ambient semantics”).
- Retrofit governance and policy layers.
- Overwrite-first state changes that erase history.
- Unclear construction vs execution vs persistence boundaries.
- Distributed coordination via hidden global state.
What Makes PMS-STACK Different
- Operator-first design — execution defined by Δ–Ψ, not instructions.
- Grammar before implementation — admissibility precedes execution.
- Frame-aware execution — context (□) is explicit and auditable.
- Structural CPU semantics — operator chains, not instruction streams.
- Non-linear memory semantics — Σ and Ψ, not overwrite-first RAM.
- Invariant-native governance — constraints are structural.
- Native AI compatibility — constrained action spaces, no anthropomorphism.
Reading Lens
PMS-STACK is easiest to read as a derivation claim: if a mechanism cannot be expressed as a well-formed operator chain under PMS dependency constraints, then it is not part of PMS-STACK.
This page therefore focuses on three things:
-
Explicitness: frames (
□), commits (Σ), and invariants (Ψ) are not implicit runtime assumptions. - Auditability: structural validity is checkable without importing domain semantics.
- Closure: the operator set remains unchanged; architecture layers are instantiations, not extensions.
The sections below link to canonical sources (grammar, repositories, and publication) and provide the practical entry points.
Micro-definitions: PMS Operators (Δ–Ψ)
PMS-STACK uses the canonical PMS operator grammar as its structural alphabet. The operators are not instruction mnemonics and not metaphors. They denote structural transformation steps that remain consistent across contexts (language, execution, memory, persistence, governance, distributed coordination).
Below is a compact operator index with a pragmatic “analog function” hint per operator. (The analogies are not definitions; they are entry bridges for first-time readers.)
| Operator | Structural role | Analog in systems |
|---|---|---|
| ΔDifference / Distinction | introduce or detect a categorical distinction. | type/kind discrimination, branching predicate, message kind, state classification. |
| ∇Impulse / Enactment | apply a directed action that changes state. | write/update step, syscall-like act, state transition application, I/O enactment. |
| □Frame / Context | establish or switch the context within which operations have meaning. | scope/namespace, address space, call frame, session context, protocol context. |
| ΛNon-Event / Absence | encode meaningful absence where an event was expected. | timeout, idle, dropped message, null-result, non-blocking “no data yet”. |
| ΑAttractor / Pattern | represent reusable patterns, stable shapes, and repeatable structural forms. | templates/macros, canonical protocol flows, loop schemas, “normal forms”, recurrent subroutines. |
| ΩAsymmetry / Role | state or enforce directional relations and privileged positions. | capabilities/permissions, privilege levels, client/server roles, authority boundaries. |
| ΘTemporal Ordering / Sequence | impose ordering constraints and progression steps. | scheduling order, happens-before constraints, event-loop ordering, retry/backoff order. |
| ΦRecontextualization / Shift | change interpretation context without discarding what exists. | exception reframing, version negotiation, migration, feature-flag reinterpretation, coercion layer. |
| ΧIsolation / Reachability | enforce boundaries of reachability and interaction. | sandboxing, process isolation, network segmentation, capability confinement, locality constraints. |
| ΣIntegration / Commit | bind transitions into a durable integrated artifact; define commit boundaries. | transaction commit, durable write boundary, merge/integration point, persistence checkpoint. |
| ΨPolicy / Invariant | bind constraints that must hold across execution, memory, and persistence. | invariants, policy enforcement, type/contract constraints, governance rules, admissibility checks. |
Note: In PMS-STACK, the admissible “program space” is the set of operator words
that satisfy the dependency constraints (as defined by the canonical grammar in PMS.yaml).
Stack Overview & Components
The PMS-STACK is organised as a structural derivation chain rather than a traditional layered software stack. Each component represents a distinct role in the transition from formal admissibility to executed and persisted structure.
The diagram below shows how grammar, execution, memory, persistence, governance, and distribution relate to one another — not as interchangeable layers, but as constrained transformation stages with explicit boundaries.
□ frame
Σ commit
Ψ invariant
Below: short component summaries matching the diagram boxes.
PMS Operators (Δ–Ψ) — Structural grammar
- Closed operator set
- Formal dependency rules
- Layered structure (L1–L4)
- No embedded semantics
- No domain assumptions
- Canonical definition via
PMS.yaml
PMSL — Praxeological Meta-Structure Language
- Declarative, not imperative
- Explicit operator ordering
- Frame-aware composition (□)
- Commit boundaries (Σ)
- Invariant declarations (Ψ)
- Audit-friendly, machine-readable
PMS-CPU — Execution semantics
- Executes operator chains, not instructions
- Dependency-enforced execution
- Structural invalidity is detectable
- No implicit control flow
- Substrate-agnostic execution model
PMS-RAM — Structural memory model
- Non-linear memory semantics
- Σ defines commit points
- Post-commit structure treated as history
- No implicit overwrite
- Replayable, auditable state
PMS-FS — Persistence & structural storage
- Frame-separated storage
- Commit-based persistence
- No implicit global namespace
- Invariants persist across restarts
- Structural versioning
AI Runtime Layer — Governance & constraint
- Agents propose actions, PMS constrains
- Explicit action-space enforcement
- Structural audit trail
- Policy as invariant (Ψ)
Distributed / Cluster Layer
- Frame isolation across nodes
- Explicit integration points
- No hidden global state
- Invariant-checked coordination
Links & Resources
PMS-STACK exists within a broader praxeological ecosystem that spans formal theory, applied anthropology, executable specifications, and interactive tooling.
The resources below represent different entry points into that ecosystem: from canonical grammar definitions and formal papers, to applied models, books, and executable explorations. Together, they form a coherent reference space rather than independent artifacts.
| Category | Resource | Description |
|---|---|---|
| Model website | pms-theory.com | PMS theory reference |
| Book websites | maturity-in-practice.com | Praxeological Anthropology — English edition |
| reife-im-vollzug.de | Praxeologische Anthropologie — Deutsche Ausgabe | |
| pms-stack.com | PMS-STACK reference architecture (this page) | |
| Amazon | Maturity in Practice (EN) | Book — English edition |
| Reife im Vollzug (DE) | Buch — Deutsche Ausgabe | |
| PMS-STACK | Book — PMS-STACK reference architecture | |
| GitHub | Praxeological Meta-Structure Theory | Canonical PMS grammar, theory & YAML definitions |
| Maturity in Practice | Book sources, applied praxeological anthropology | |
| PMS-QC | Quantum computing paper using PMS operators | |
| Custom GPTs | PMS Model Assistant | Interactive PMS.yaml exploration & validation |
| Maturity in Action | Applied praxeological anthropology assistant |