Governed by Protocol. Constructed by Compiler. Proven by Trace.
A reference architecture for building deterministic, inspectable, AI-era software systems.
Modern software has a governance problem.
As systems become:
- distributed,
- event-driven,
- AI-assisted,
- and increasingly machine-generated,
the gap between:
- what engineers intended, and
- what software is actually allowed to do
keeps widening.
Behavior hides in:
- orchestration code,
- runtime conditionals,
- framework conventions,
- implicit routing,
- service glue,
- and increasingly, AI-generated implementation details.
PGS explores a different model:
What if behavior was governed before execution instead of inferred during execution?
PGS is a Protocol-Governed Execution Architecture where:
- behavior is declared in governed protocol artifacts
- admissible execution paths are compiled ahead of time
- runtime traversal is deterministic
- undeclared behavior is unreachable
- every execution produces structured evidence
The runtime does not "figure out" what to do.
It traverses a precompiled execution graph.
Most workflow systems orchestrate code.
PGS governs behavior itself.
Traditional systems still allow:
- hidden routing,
- implicit side effects,
- undeclared execution paths,
- runtime interpretation,
- and logic spread across services.
PGS moves those concerns into:
- protocol declarations,
- compiler-enforced invariants,
- federated governance boundaries,
- and deterministic execution topology.
This is not a framework abstraction.
It is a different execution model.
AI can generate software faster than humans can reliably govern it.
PGS was designed around a simple premise:
AI-generated behavior should not bypass architectural admissibility.
In PGS:
- execution legality is compiled before runtime
- side effects are explicitly declared
- routing surfaces are closed
- execution traces are immutable
- runtime is intentionally semantic-agnostic
The system cannot invent undeclared behavior at execution time.
This repository is the reference workspace for the Protocol-Governed Systems ecosystem.
It demonstrates:
- governed workflow execution
- compile-time admissibility construction
- federated governance boundaries
- deterministic runtime traversal
- immutable execution traces
- semantic-agnostic execution infrastructure
This is not a toy mockup.
The workflows execute end-to-end against real state and produce real traces.
PGS separates software into two distinct spaces:
| Space | Responsibility |
|---|---|
| Human Governance Space | Defines what behavior is admissible |
| Machine Execution Space | Executes only what has already been declared and compiled |
This inversion matters.
The runtime is not trusted to "do the right thing."
The compiler constrains what the runtime is even capable of doing.
You will execute real workflows against persistent state.
You will observe:
- deterministic routing
- compile-time constrained behavior
- immutable structured traces
- different outcomes from the same workflow without code changes
- runtime execution without orchestration logic embedded in services
The protocol — not handwritten runtime branching — governs outcomes.
PGS is not:
- a low-code workflow builder
- a BPM engine
- an orchestration DSL
- a rules engine
- an agent framework
- or another event bus abstraction
It is a governed execution substrate.
- Engineers building high-integrity systems
- Teams integrating AI-generated code safely
- Architects exploring deterministic execution models
- Researchers interested in governed computation
- Anyone curious what software looks like when protocol becomes the source of truth
- Compile-time admissibility enforcement
- Federated governance boundaries (FB_*)
- Semantic-agnostic runtime execution
- Deterministic execution graphs
- Immutable execution evidence
- Fully declared side-effect surfaces
- Protocol-first system evolution
- FQDN-based artifact identity
- Governance-constrained compiler behavior
PGS is released under Apache-2.0.
The goal is not to create a closed platform.
The goal is to explore whether software systems can become:
- more governable,
- more inspectable,
- and more deterministic
without sacrificing extensibility.
The full architectural model, governance system, compiler/runtime separation, and federated execution model are described in:
-
Technical Paper — formal model, dual-space architecture, security inversion, scalability analysis
-
DOI: 10.5281/zenodo.20330650 — persistent global reference (Zenodo)
-
Conceptual Model — protocol snapshot, four-layer admissibility model, constitutional invariants, evidence model
-
DOI: 10.5281/zenodo.20300611 — persistent global reference (Zenodo)
The practitioner's guide (18 chapters, ~102K words) covers PGS from first principles through advanced topics:
- Practitioner's Guide — all chapters in a single document
Author: ORCID 0009-0007-3810-6520 — public profile and full publication list
Explore what PGS makes possible beyond workflow governance:
- Protocol-Governed Transformer Runtime — declarative AI model topology as a governed execution substrate
- Protocol-Governed Autonomous Agent Runtime — structural governance for autonomous AI agents
Start here:
You will be running governed workflows in minutes.
PGS explores what software looks like when protocol — not runtime code — becomes the governing authority of execution.