Papers

© 2026 Bhash Ganti Independent Researcher — Camas, WA, USA Contact: bachipeachy@gmail.com ORCID Profile: https://orcid.org/0009-0007-3810-6520 Abstract As software projects become increasingly agent-mediated, implicit authorization fails: the lifecycle is gated repeatedly—merge, release, deployment—and those disjoint approvals are assumed to compose, a composition living in reviewers’ heads that requires producers to be few, known, and sharing tacit context. Agents break all three, and no single point determines what behavior a system is authorized to realize. Authorization must instead be an explicit, independently checkable property established during governed construction and carried in a sealed state that execution realizes but cannot amend. Three tests are reported: a reference implementation assembling seven governed domains under one governance surface; an independent realization built from a frozen specification, claiming only the surfaces it exercised; and mutation testing in which removing two required guards left demonstrations unaffected, while a discriminating mutation of declared routing failed as expected. These address realizability, specification sufficiency, and evidence adequacy, exposing a concrete limitation of conventional evidence. ...

Author: Bhash Ganti (aka Bachi) (c) 2026 Bhash Ganti. All rights reserved. Released under the Apache-2.0 License. Preprint: https://doi.org/10.5281/zenodo.22650863 — this page is the frozen rendition of that deposit. Abstract Autonomous agents can now perform substantial portions of the software-engineering lifecycle, yet conventional lifecycles rarely make explicit who authorizes the resulting software: repository write access and human review do not by themselves constitute an authorization decision. This paper reports an empirical realization and evaluation of Protocol-Governed Computing, an architecture in which behaviour is determined during governed construction and sealed into state that execution can realize but cannot amend. We distinguish activity autonomy — who may analyze, design, construct and transform — from authorization authority — who may establish scope, admit a candidate and promote it as the next executable baseline. The question this paper asks is what remains of that authority when an agent performs the activity. ...

Author: Bhash Ganti (aka Bachi) (c) 2026 Bhash Ganti. All rights reserved. Released under the Apache-2.0 License. bachipeachy@gmail.com · ORCID 0009-0007-3810-6520 Preprint: https://doi.org/10.5281/zenodo.22758703 — this page is the frozen rendition of that deposit. Abstract Software systems are governed across three activities usually treated separately: changing what the system is, constructing an executable representation, and executing it. This separation lets authority migrate between them. Transformation may author behavior, construction may repair incomplete declarations, or a runtime may resolve omissions by inference. Behavior is then determined partly by declarations and partly by the mechanisms that realize them. ...

Author: Bhash Ganti (aka Bachi) (c) 2026 Bhash Ganti. All rights reserved. Released under the Apache-2.0 License. bachipeachy@gmail.com · ORCID 0009-0007-3810-6520 Preprint: https://doi.org/10.5281/zenodo.22736531 — this page is the frozen rendition of that deposit. Abstract Conventional software architecture spreads behavioral authority across several sources. Declarations govern some behavior. Implementation, build tooling and runtime decide the rest. Protocol-Governed Computing reverses that arrangement. Governed declarations determine authorized behavior, business process rules included. Construction, implementation and execution realize that determination and add nothing to it. ...

© 2026 Bhash Ganti Contact: bachipeachy@gmail.com ORCID Profile: https://orcid.org/0009-0007-3810-6520 Preface This paper describes an architecture for software execution within a fundamentally redesigned software architecture suited to 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, conventional assumptions about where software behavior resides—and how that behavior remains governed—no longer suffice. This paper presents Protocol-Governed Computing (PGC), an architecture in which behavioral authority is moved out of implementation and into explicit, validated, executable protocols. It is the first of three companion papers: the second addresses governed transformation, and the third addresses realization of the architecture as a functioning normative platform. ...

© 2026 Bhash Ganti Contact: bachipeachy@gmail.com ORCID Profile: https://orcid.org/0009-0007-3810-6520 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]. ...

© 2026 Bhash Ganti. All rights reserved. Bhash Ganti (aka Bachi) Contact: bachipeachy@gmail.com ORCID Profile: https://orcid.org/0009-0007-3810-6520 Companion papers Part 1 — Protocol-Governed Computing: An Architecture for Deterministic Declarative Execution. https://doi.org/10.5281/zenodo.21879516 Part 2 — Protocol-Governed Computing: An Architecture for Closed-Loop Governed Transformation. https://doi.org/10.5281/zenodo.21879948 Abstract Two companion papers establish the architecture of protocol-governed computing. One defines execution as declarative traversal of a compiled protocol; the other defines evolution as the governed transformation of one executable baseline into the next. Both state what must be true. Neither states what it takes to make it true, nor how one would know it had been achieved. ...

Author: Bhash Ganti (aka Bachi) © 2026 Bhash Ganti. All rights reserved. Released under the Apache-2.0 License. Audience: architects · compiler engineers · runtime engineers · governance engineers · AI coding agents under human supervision What this manual is A high-density restoration artifact. Its purpose is to rebuild the correct mental model of Protocol-Governed Computing in under thirty minutes — not to teach it, not to document code, not to walk a codebase. ...

(c) 2026 Bhash Ganti Contact: mailto:bachipeachy@gmail.com ORCID Profile: https://orcid.org/0009-0007-3810-6520 Revision v1. Two changes, neither altering a claim of the paper. The preface was reframed so the paper reads as an entry point rather than as the fourth of a series, which is the role it now serves. A note on the change of name from Protocol-Governed Systems to Protocol-Governed Computing was added. The fifteen inversions and their development are unchanged from v0. ...

(c) 2026 Bhash Ganti Bhash Ganti Contact: bachipeachy@gmail.com Purpose: Define the conceptual model for Protocol-Governed Systems, validated through the PGS reference implementation. Audience: Protocol designers, compiler authors, runtime implementers, conformance engineers Abstract Protocol-Governed Systems (PGS) propose a computational architecture in which governance precedes execution. Instead of relying on runtime policies, conventions, or post-hoc validation, PGS defines admissible behavior through governed protocol artifacts that are compiled into deterministic execution structures before runtime begins. ...