Governed Metaprogramming for Intelligent Systems: Reclassifying Eval as a Governed Effect

Alan L. McCann

arxiv: 2605.05248 · v4 · pith:OIF6UNGOnew · submitted 2026-05-05 · 💻 cs.PL · cs.AI

Governed Metaprogramming for Intelligent Systems: Reclassifying Eval as a Governed Effect

Alan L. McCann This is my paper

Pith reviewed 2026-05-22 10:44 UTC · model grok-4.3

classification 💻 cs.PL cs.AI

keywords metaprogrammingevalgoverned effectsintelligent systemslanguage designauthority amplificationformal verificationAI workflows

0 comments

The pith

Intelligent systems need to treat eval as a governed effect that checks authority before execution rather than an unrestricted primitive.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper argues that AI systems generating executable code at runtime must reclassify eval from a free language primitive into a governed effect. A sympathetic reader would care because the step from symbolic program representation to running code amplifies authority and therefore requires explicit mediation to enforce policies. The design keeps manipulation of program forms as pure computation while routing materialization to execution through a governance system that inspects capability requirements, policy compliance, and resource estimates. Two judgments formalize pure form evaluation, which emits no directives, and governed materialization, which emits exactly one governed directive. Proofs establish purity of form manipulation, a no-bypass theorem, and boundary preservation.

Core claim

Eval is reclassified from a language primitive into a governed effect. In governed intelligent systems the transition from symbolic program representations to executable authority constitutes an authority amplification that must be mediated by a governance system capable of analyzing capability requirements, policy compliance, and resource estimates. Governed metaprogramming makes program representations first-class values, keeps form manipulation as pure computation, and subjects materialization to governance. The design formalizes pure form evaluation that emits no directives and governed materialization that emits exactly one governed directive. Three properties are proved: purity of form

What carries the argument

Governed materialization, the transition from first-class program forms to executable authority that is subject to structural inspection and governance checks before any execution occurs.

If this is right

Any change to program forms remains pure computation that emits no directives.
Materialization to execution occurs only after the governance system has performed its analysis.
The no-bypass theorem guarantees that execution authority cannot be obtained without passing through the governed materialization judgment.
Boundary preservation ensures that pure form values and governed execution remain separated.
The implementation in mashinTalk shows the design integrates with existing machine-checked theorems for AI workflows.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

The same separation of pure form handling from governed materialization could be added to other dynamic languages used by AI agents to limit runtime code execution.
This approach offers a route to safer self-modifying systems by making every behavioral change pass an explicit governance gate.
Capability-based checks at materialization time resemble process-creation controls already used in secure operating systems.
An extension worth testing would be to encode the two judgments inside an existing theorem prover for larger AI workflow libraries.

Load-bearing premise

That a governance system can reliably analyze capability requirements, policy compliance, and resource estimates for any proposed program representation.

What would settle it

A concrete sequence of form manipulations that produces an executable program whose materialization succeeds without the governance system detecting or blocking violations of policy or capability limits.

read the original abstract

AI systems increasingly synthesize executable structure at runtime: LLMs generate programs, agents construct workflows,self-improving systems modify their own behavior. In classical homoiconic and staged languages, the transition from code representation to execution is unrestricted. eval is a language primitive, not a governed operation. We argue that in governed intelligent systems, this transition is an authority amplification: it converts symbolic structure into executable authority and must be mediated like any other effect. We present governed metaprogramming, a language design where program representations (machine forms) are first-class values, form manipulation is pure computation, and materialization (the transition from form to executable machine) is a governed effect subject to structural inspection. The governance system analyzes the proposed program's capability requirements, policy compliance, and resource estimates before permitting execution. We formalize two judgments: pure form evaluation (which emits no directives) and governed materialization (which emits exactly one governed directive). We prove three properties: purity of form manipulation, the no-bypass theorem, and boundary preservation. We implement the design in mashinTalk, a DSL for AI workflows compiling to BEAM byte code, and report on integration with 454 existing machine-checked Rocq theorems. The central contribution is reclassifying eval from a language primitive into a governed effect.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

The paper reclassifies eval as a governed effect with two judgments and a no-bypass theorem, backed by substantial Rocq formalization and a BEAM implementation, but enforcement in the runtime needs checking.

read the letter

The paper's main contribution is treating the shift from symbolic program forms to executable code as an authority-amplifying effect that requires explicit governance rather than leaving it as an unrestricted primitive. They split this into pure form evaluation, which does no side effects, and governed materialization, which emits a single directive after checks for capabilities, policy, and resources. The no-bypass theorem and boundary preservation are the properties they prove to keep the separation intact.

Referee Report

1 major / 1 minor

Summary. The manuscript proposes governed metaprogramming for intelligent systems that synthesize executable code at runtime. It reclassifies eval from an unrestricted language primitive into a governed effect by distinguishing pure form manipulation from governed materialization, formalizing two judgments (pure form evaluation emitting no directives, governed materialization emitting exactly one), proving three properties (purity of form manipulation, no-bypass theorem, boundary preservation), and implementing the design in the mashinTalk DSL that compiles to BEAM bytecode while integrating with 454 existing Rocq theorems.

Significance. If the no-bypass property holds for the delivered artifact, the work supplies a principled mechanism for mediating authority amplification when symbolic program representations become executable in AI workflows and self-modifying systems. The scale of the machine-checked Rocq integration (454 theorems) is a concrete strength that supports the formal claims.

major comments (1)

[Implementation section] Implementation section (BEAM bytecode target): the no-bypass theorem is stated for the high-level model with two judgments, yet the manuscript does not demonstrate that all BEAM primitives for dynamic module loading, hot code swapping, and low-level binary-to-code conversion are wrapped or disabled; without such wrapping a program could materialize executable authority without invoking the governed judgment, falsifying the property in the running system.

minor comments (1)

[Abstract] Abstract: the claim of integration with '454 existing machine-checked Rocq theorems' is stated without identifying which theorems are reused or how they compose with the new judgments.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the careful review and for identifying this important gap between the formal model and the implementation. We address the comment below.

read point-by-point responses

Referee: [Implementation section] Implementation section (BEAM bytecode target): the no-bypass theorem is stated for the high-level model with two judgments, yet the manuscript does not demonstrate that all BEAM primitives for dynamic module loading, hot code swapping, and low-level binary-to-code conversion are wrapped or disabled; without such wrapping a program could materialize executable authority without invoking the governed judgment, falsifying the property in the running system.

Authors: We agree that the no-bypass theorem must hold in the delivered artifact for the practical claims to be substantiated. The manuscript presents the high-level judgments and proves the no-bypass property for the abstract model, while describing the mashinTalk DSL and its compilation to BEAM bytecode. It does not, however, detail the runtime configuration that prevents direct use of the listed BEAM primitives. In the revised manuscript we will expand the Implementation section to describe the sandboxed BEAM environment in which mashinTalk executes: dynamic module loading and hot code swapping are disabled at the VM level, and any low-level binary-to-code conversion is routed exclusively through the governed materialization judgment. We will also note the specific BEAM configuration flags and Erlang/OTP restrictions employed, thereby showing how the running system preserves the boundary established by the formal model. revision: yes

Circularity Check

0 steps flagged

No circularity: formalization and proofs are machine-checked in Rocq and independent of inputs

full rationale

The paper defines two new judgments (pure form evaluation and governed materialization) and proves three properties (purity, no-bypass theorem, boundary preservation) within a Rocq formalization integrated with 454 existing machine-checked theorems. These steps constitute an independent formal development rather than any reduction of the central claim to fitted parameters, self-referential definitions, or load-bearing self-citations. The implementation in mashinTalk targeting BEAM is presented as a separate artifact; no equations or derivations in the provided text equate the reclassification result to its own inputs by construction. This is a standard case of a self-contained formal proposal.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 1 invented entities

The design rests on a domain assumption that runtime code materialization in intelligent systems requires governance and introduces a new entity for the governed transition without external falsifiable evidence supplied in the abstract.

axioms (1)

domain assumption In governed intelligent systems, the transition from code representation to execution is an authority amplification that must be mediated like any other effect.
This premise is stated directly as the argument for reclassifying eval and underpins the need for the governance system.

invented entities (1)

governed directive no independent evidence
purpose: To represent the single controlled output of governed materialization that enforces inspection and policy checks.
New entity introduced to distinguish governed materialization from pure form evaluation.

pith-pipeline@v0.9.0 · 5759 in / 1377 out tokens · 64159 ms · 2026-05-22T10:44:13.442350+00:00 · methodology

Review history (3 revisions) →

discussion (0)

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

IndisputableMonolith/Foundation/AbsoluteFloorClosure.lean reality_from_one_distinction unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

We formalize two judgments: pure form evaluation (which emits no directives) and governed materialization (which emits exactly one governed directive). We prove three properties: purity of form manipulation, the no-bypass theorem, and boundary preservation.
IndisputableMonolith/Foundation/ArithmeticFromLogic.lean LogicNat recovery and embed_injective unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

The central contribution is reclassifying eval from a language primitive into a governed effect.

What do these tags mean?

matches: The paper's claim is directly supported by a theorem in the formal canon.
supports: The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends: The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses: The paper appears to rely on the theorem as machinery.
contradicts: The paper's claim conflicts with a theorem or certificate in the canon.
unclear: Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.