ProofAgent Harness: Formal Proof Automation

• ProofAgent Harness is a runtime engineering framework that integrates reasoning loops, tool interfaces, context management, and control mechanisms for formal proof automation.
• It enables iterative, auditable proof construction over environments like theorem provers or codebases by enforcing deterministic guardrails and adaptive context curation.
• It supports meta-learning and adversarial evaluation through trace-guided diagnosis and learnable harness controllers, generalizing across diverse proof domains.

A ProofAgent Harness is the runtime engineering layer that operationalizes a LLM (or models) into an autonomous agent capable of constructing, verifying, and critiquing formal proofs over an external environment, such as an interactive theorem prover, codebase, or mathematical system. Unlike conventional LLM wrappers or stateless toolkits, the harness instantiates a persistent, adaptive loop integrating reasoning steps, external tool access, context curation, and non-bypassable controls, forming the substrate for rigorous proof automation and auditable agentic behavior (Macedo, 8 Jun 2026).

1. Constitutive Definition and Inclusion Criteria

The canonical definition of an agent harness—applicable to ProofAgent—requires the run-time instantiation of four core components:

• T1 – Agent Loop: A reasoning–action–observation cycle in which the agent forms plans, executes tool calls or actions (e.g., invoking proof tactics or file modifications), ingests the resulting observations, and continues this interleaved adaptive process until a specified stopping condition is met.
• T2 – Tool Interface: A set of API primitives granting the model both read and write access to facets of the external environment (e.g., file systems, shells, proof assistant kernels).
• T3 – Context Management: An algorithmic, content-aware policy that curates the model's working context, incorporating or discarding prior states, observations, and tool outputs according to task relevance—simple buffer truncation by size is strictly insufficient.
• T4 – Control Mechanisms: At least one verifiable, deterministic mechanism external to the model's own outputs that forces, checks, or rolls back actions to enforce correctness or containment (e.g., proof-checkers, rollback guards, hard-capped tool invocation).

A system is a ProofAgent Harness if and only if it implements all four elements at runtime. This predicate is operationalized via formal Boolean checks: hasAdaptiveLoop, hasReadWriteToolAPI, hasContentAwareContext, and hasExternalControl (Macedo, 8 Jun 2026).

2. Essential Architecture and Layered Responsibilities

Comprehensive harness engineering mandates separation of responsibility across conceptual layers, each tightly scoped and auditable:

• Execution Environment & Sandbox: An isolated, version-pinned process for the proof assistant or runtime, preventing state pollution or privilege escalation.
• Tool Interface: Strict schema for tactic/tool invocation, with argument validation and structured error propagation.
• Context Management: Tracking of active subgoals, hypotheses, module imports, and a summarized or indexable memory for lemma retrieval.
• Lifecycle Orchestration: Implementation of a reasoning–action–observation loop, stateful retry bounding, auto-termination, and protocol compliance checks.
• Observability: Persistent, stepwise trace of agent actions, tool responses, cost metrics, and proof-state deltas.
• Verification & Evaluation: Continuous and final kernel-based checking of proof obligations, subgoal coverage, and regression testing.
• Governance & Security: Policy gates, audit trails, forbidden action patterns, and access limitation (e.g., locked-down file system) (Chen et al., 4 Jun 2026).

This layered view is classified under the ETCLOVG taxonomy: Environment, Tool, Context, Lifecycle, Observability, Verification, Governance.

3. Automation, Evolution, and Diagnosis

Manual harness engineering is increasingly supplanted by meta-learned or trace-guided automation:

• Harness Evolution Loop: Iterative optimization where a worker agent executes, an evaluator adversarially diagnoses and scores, and an evolution agent proposes harness modifications (new prompts, tool sets, lemma libraries) using trace history and validation feedback. Performance is scored as $$sc = \mathbb{1}_\text{valid}\,-\,\alpha|\tau|\,-\,\beta\,(\text{extraneous calls})$$, and meta-optimization aligns toward protocols that generalize across proof domains (Seong et al., 22 Apr 2026).
• Trace-Guided Diagnosis and Repair (HarnessFix): Raw execution traces and harness code are compiled into a Harness-aware Trace Intermediate Representation (HTIR), supporting stepwise attribution of failures to harness layers and actionable generation of scoped repair operators. Automatic patch assessment uses pre/post-validation, target flaw reduction, and regression-safe acceptance (Chen et al., 4 Jun 2026).

4. Safety, Control Mechanisms, and Error Mitigation

Empirical deployments highlight distinct failure modes—underspecification ($f_1$), capability errors ($f_2$), and harness failures ($f_3$)—with error propagation captured as $$P(\text{unsound proof}) = 1 - (1-f_1)(1-f_2)(1-f_3)$$. Harness controls address $f_3$ via:

• Extended system prompts guiding proof structure and explicit protocol adherence.
• Tactic classifiers (fast/slow pass) that filter or escalate tool calls before execution.
• Three-strikes policies immediate halting on repeated unsafe or misaligned actions.
• Deterministic guardrails, including precondition and postcondition assertions tied to each tactic invocation.
• Context management tools empowering the agent to prune, freeze, or summarize context history (Ge et al., 13 Jun 2026).

These interventions demonstrably increase soundness (from ≈70% to ≈90%) and completeness rates in formal proof tasks, while reducing leakage of unsound actions and context bloat (Ge et al., 13 Jun 2026).

5. Formal Theories and Compositional Abstraction

The categorical architecture formalizes the harness as an object triple $A = (G, \text{Know}, \Phi)$, where:

• $G$ is a typed wiring graph specifying the flow of inputs/outputs between modules (e.g., parser, lemma proposer, tactic applier, checker), supporting serial, parallel, and feedback/tracing compositions (operads).
• $\text{Know}$ is a certificate algebra containing structural guarantees (integrity gates, quality-based escalation, convergence checks), which are preserved under category morphisms or compiler functors.
• $\Phi$ is the concrete deployment map assigning model endpoints to protocol stages.

Structural certificates ensure that properties—such as no unsanitized flow, minimum verifier score, and halting within bounded iterations—are mechanically enforced and replayable under harness compilation or migration (Banu, 12 May 2026).

6. Adversarial Evaluation, Extensibility, and Benchmarking

The ProofAgent Harness infrastructure extends beyond static code evaluation, providing a platform for adversarial, multi-turn, and extensible assessment:

• Adversarial Multi-Juror Scoring: After orchestrated, trap-infused trials, multi-persona jurors score agent transcripts at metric and turn-level granularity, supported by consensus protocols and evidence-linking.
• Auditability: Full behavioral traces and interventions are preserved, enabling post-hoc forensic analysis and regulatory alignment (e.g., per EU AI Act compliance).
• Extensibility: Plugin models for new domains (trap libraries, metrics, reporting formats), agent role definitions, and juror personas enable rapid adaptation to new risk surfaces and application domains (Bousetouane, 22 May 2026).

Empirical studies found pipeline amplification—whereby smaller harness LLMs can expose weaknesses in larger agent models due to evaluation protocol design, not model scale per se.

7. Learned Harness Controllers and Generalization

Recent advances replace manual harness logic with lightweight, learnable controllers:

• Bidirectional harness projection: Jointly trained observation and action projections distill raw trajectories into task-relevant states and filter or refine proposed actions before execution.
• Unified instruction tuning: Both projections are parameterized as a multi-task policy learned via instruction-following, with performance matching or surpassing specialized manual harnesses while reducing input-token consumption and trajectory length (Wang et al., 11 Jun 2026).
• Model transferability: The learned harness generalizes across agent LM backends, with robust cross-model performance and resource efficiency.

This approach confirms that agent–environment interface policies can be systematically optimized, rather than hand-crafted, for long-horizon proof and coding tasks.

---

References:

(Macedo, 8 Jun 2026, Seong et al., 22 Apr 2026, Ge et al., 13 Jun 2026, Chen et al., 4 Jun 2026, Zhong et al., 13 May 2026, Banu, 12 May 2026, Bousetouane, 22 May 2026, Wang et al., 11 Jun 2026)