Protocol-Governed Systems: A Constitutionally Constrained Architecture for Autonomous and AI- Generated Software

Abstract The rapid acceleration of AI-assisted software generation exposes a fundamental limitation in conventional software architecture: behavior is implicitly defined by implementation, while governance operates reactively and at human speed. This mismatch creates a structural gap in which systems can exhibit unauthorized, non-deterministic, and unauditable behavior. Existing approaches—static analysis, runtime guardrails, and policy engines—attempt to constrain behavior after code is produced, but cannot guarantee compliance when implementation evolves faster than governance. This paper introduces Protocol-Governed Systems (PGS), a computational architecture in which behavior is defined explicitly through governance artifacts and compiled into deterministic execution graphs prior to runtime. PGS establishes a strict boundary between intent and execution via a dedicated Compiler Subsystem that derives orchestration structure from protocol declarations, while computation remains implemented in conventional programming languages. Execution is constrained by a constitutionally defined model that separates pure computation from governed mutation and requires all externally observable effects to be explicitly enumerated and authorized. Within this model, code possesses no inherent authority; all privileges originate from protocol declarations and are enforced during execution. As a result, execution paths that violate declared protocol constraints cannot be constructed within the system, yielding correct-by- construction execution. This structural property replaces ambient authority with a zero- authority baseline and enables deterministic trace generation, replayable execution semantics, and complete auditability of externally observable behavior. PGS further demonstrates that governance can scale linearly with system growth by replacing 𝑂(𝑁 × 𝑀) pairwise implementation dependencies—where 𝑁 denotes the number of distinct capabilities and 𝑀 denotes the number of workflows that compose those capabilities—with protocol-mediated capability interfaces, reducing lifecycle complexity to 𝑂(𝑁 + 𝑀). We formalize the architectural model, define its governing invariants, and present empirical validation demonstrating deterministic execution, linear complexity scaling, and multi-language runtime bindings. We also show that these constraints preserve Turing completeness within the bounded capability surface defined by CT (Capability Transforms) and CS (Capability Side Effects) primitives, ensuring that governance rigor does not limit computational expressiveness. 1Protocol-Governed Systems redefine software construction as a compiler-mediated process in which behavior is specified prior to implementation and execution is constructed by the compiler from governance artifacts rather than authored directly. The architecture enables the generation of complete execution graphs at compile time—without requiring the execution of underlying implementations—while simultaneously validating conformance to constitutional constraints. This establishes a form of correct-by-construction execution in which behavioral admissibility is determined prior to runtime. The paradigm provides a foundation for building high-velocity, governable systems in environments where implementation is increasingly autonomous and ephemeral.