Protocol-Governed Computing: An Architecture for Closed-Loop Governed Transformation

Preface Software changes continuously, yet software engineering has traditionally treated construction, execution, and evolution as largely separate concerns. This paper presents an architecture for software evolution—how running software changes over time while remaining governed, verifiable, and executable—in an era in which AI and LLM-based coding assistants can automate software implementation at increasing scale. When implementation can be generated, modified, and regenerated automatically, the question of who governs the act of change becomes the architectural question. It is the second of three companion papers: the first addresses deterministic declarative execution [Ganti, 2026l], and the third addresses realization of the architecture as a functioning normative platform [Ganti, 2026m]. Most of what follows can be read without any prior knowledge of Protocol-Governed Computing (PGC). The architecture is general. It concerns the relationship between a business problem and the running software that addresses it, and that relationship is the same whether the implementation is written by humans, generated by AI, or produced through fully automated software construction. A reader interested in software architecture—and skeptical of any particular platform—is exactly the reader this paper is written for. Still, a few words of orientation will help, because the architecture was worked out and validated in a working reference implementation — open source at https://github.com/protocol-governed-computing, and described in the realization companion [Ganti, 2026m]. The architecture is offered here on its own terms, but nothing in it is hypothetical: the transformation stages, the compiler, the validated candidates, and the promotions this paper argues from are all inspectable. A protocol-governed system separates business intent from behavioral implementation. Business intent is transformed into an executable behavioral model that is described declaratively as executable protocols rather than embedded in imperative application code. A compiler resolves, validates, and compiles those declarations into a single authoritative artifact—the Protocol Snapshot. A runtime then executes that snapshot and nothing else. The runtime carries no behavioral knowledge of its own; every behavior it performs was determined, validated, and compiled before execution began. 1In a protocol-governed system, nothing runs that was not first declared, validated, and compiled into the Protocol Snapshot. This paper takes up the first half of that sentence: how a Protocol Snapshot comes to be declared, validated, and compiled at all. Its companion—An Architecture for Deterministic Declarative Execution [Ganti, 2026l]—takes up the second half, and treats nothing runs that was not as a promise execution itself must keep. Earlier papers in this series established the discipline for construction and execution. They did not fully answer what happens when the Protocol Snapshot itself must change—or who governs the act of changing it. That is the question this paper takes up. The answer, like its companion’s, turns on a single rule about authority: Only a human-directed author may create meaning; the machine may derive it, never originate it. That rule is not specific to any implementation. It is an architectural model for governed software evolution—and, increasingly, a necessary foundation for software whose implementation may itself be produced and transformed by machines.