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

TL;DR

This paper introduces governed metaprogramming, a language design where program execution is mediated by governance policies, enabling safer and more controlled AI systems that synthesize executable structures at runtime.

Contribution

It reclassifies eval as a governed effect, formalizes governance-aware program manipulation, and implements this in mashinTalk for AI workflows with verified properties.

Findings

Formalized two judgments: pure form evaluation and governed materialization.

Proved properties: purity of form manipulation, no-bypass theorem, boundary preservation.

Implemented in mashinTalk with integration into existing theorem systems.

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.