Hyperagents — part 6/7

Cleaned-text code points [77547, 93356). Bibliography omitted here; source.md includes it.

Use structured processes, not attitude instructions. In the paper review domain, the DGM-H transitions from behavioral prompting to structurally grounded decision-making Figure 7 . In generation 39, the agent attempted to improve performance by adopting a “rigorous and critical” reviewer persona, encouraging stricter standards and default rejection. Subsequent analysis showed that such attitude-based instructions were unreliable, leading to a key insight in generation 54: “for LLMs, use structured processes, not attitude instructions”. The DGM-H therefore introduced a two-stage evaluation procedure in which the agent first identifies weaknesses using an explicit checklist and only then makes an accept/reject decision based on predefined rules. This shift from behavioral guidance to process-level structure enabled more stable and higher-performing review behavior in later generations.

Accumulating domain knowledge. In robotics reward design, the most impactful changes stem from progressively grounding the agent in accurate domain knowledge ( Figure 8 ). A major breakthrough in generation 8 added comprehensive documentation of the target environment, explicitly listing valid state variables and constraints and providing high-level reward design guidelines, which eliminated failures caused by hallucinated attributes. Later generations (12 and 13) iteratively refined this documentation by tightening constraints, adding concrete code examples, and specifying typical reward formulations and scaling ranges. Rather than isolated prompt edits, the DGM-H continuously improved a shared, example-driven knowledge base that supported increasingly effective reward design.

Automated rubrics and decision tree. For Olympiad-level math grading, the DGM-H shows a steady move toward explicit evaluation structure ( Figure 9 ). In generation 3, listing grading categories with clear definitions corrected the tendency to solve problems instead of grading them. Subsequent generations (18 and 37) refined these categories with systematic decision procedures, calibration, and concrete boundary-case examples. Generation 168 introduced explicit rubrics, per-item checklists, and a decision-tree framework mapping rubric satisfaction to final grades, replacing descriptive guidance with precise logical flow and substantially improving grading consistency. Rather than relying on human-designed rubrics, the DGM-H autonomously discovers evaluative structures that mirror those used in recent rubric-based approaches to improve consistency and interpretability in complex judgments [ Cook et al., 2024 , Fan et al., 2024 , Chen et al., 2026 , Lv et al., 2026 ] .

Features implemented in a given generation are often inspired by, enabled by, or recombined from mechanisms discovered in earlier generations. For example, while the agent in ( Figure 9 ) appears to require only five code edits to achieve the best performance in that run, these edits were in fact inspired by insights and infrastructure developed in previous generations. This kind of cumulative learning is enabled by the DGM-H’s meta-level improvements (e.g., evaluation analysis utilities, persistent memory, performance tracking) ( Section E.3 ). Together, these qualitative results show that the DGM-H’s gains do not arise from isolated, single-step changes, but instead emerge from open-ended cumulative improvements in both task-level behavior and the meta-level machinery that generates those behaviors.

### E.3 Qualitative: Improving the Ability to Improve

Beyond quantitative performance metrics, we conducted a qualitative analysis of the code modifications to the hyperagent, which reveals a range of emergent self-improvement mechanisms that arise autonomously, without any explicit instruction to create such capabilities. The hyperagent develops sophisticated metacognitive abilities, including learning to measure its own performance, diagnose pathological behaviors, construct infrastructure to support future improvements, and accumulate knowledge across generations. These behaviors demonstrate that the system is not merely improving task performance, but is improving its own ability to improve. Notably, none of these meta-level capabilities were explicitly requested. Instead, they emerge autonomously from the agent’s pursuit of better task performance. This suggests that sufficiently capable systems, when granted the ability to modify their own code, may spontaneously develop the metacognitive machinery necessary for effective and sustained self-improvement.

#### E.3.1 Better Evaluation Analysis

A key shift in the meta agent’s behavior is the evolution from blind modification to data-driven optimization. Initially, the meta agent receives only a simple instruction to “modify any part of the codebase”. Then, the agent autonomously develops mechanisms to analyze previous evaluation results before making changes. For example, the meta agent introduces an _analyze_evaluations() method that systematically processes evaluation data: ⬇

Another example is augmenting the instruction prompt with evaluation context: ⬇

These modifications allow subsequent generations to retrieve performance metrics and identified failure patterns, enabling more targeted improvements, a principle that the hyperagent discovers independently.

#### E.3.2 Compute-Aware Strategic Planning

The hyperagent develops compute-aware optimization, adapting its improvement strategy based on the number of remaining iterations (which reflects the amount of compute available). This demonstrates an understanding that not all moments in an optimization process are equivalent: early decisions have compounding effects, whereas late-stage decisions should be more conservative. For example, the agent introduces conditional logic that adjusts its behavior based on the number of iterations left: ⬇

This reasoning mirrors human intuition about resource allocation. Early generations exhibit more ambitious architectural changes, while later generations focus on incremental refinements. The system balances exploration in early phases with exploitation in later phases, without this trade-off being manually specified.

More broadly, the ability to reason explicitly about compute allocation substantially expands the space of self-modification strategies possible. Rather than being restricted to a fixed improvement heuristic, a compute-aware agent can effectively emulate or instantiate a wide range of optimization algorithms (e.g., evolutionary search, hill climbing, or population-based exploration) by deciding how aggressively to explore, how many variants to generate, and when to consolidate progress. In this sense, compute awareness allows an agent to actively shape its own optimization process (e.g., running an evolutionary search within a single iteration of self-modification, essentially embedding one evolutionary search process within another).

#### E.3.3 Automated Bias Detection and Correction

The hyperagent develops self-diagnostic mechanisms. In classification tasks such as paper review, the hyperagent detects when the system exhibits pathological behavior, specifically, classification collapse, in which one class dominates the predictions. For example, the hyperagent introduces label-distribution tracking and automated bias detection: ⬇

Another example is the application of a threshold-based analysis to identify when predictions become degenerate: ⬇

When bias is detected, this diagnostic information is surfaced in the meta agent’s instruction prompt, enabling corrective action. In one observed case, paper review predictions exhibited a 99% acceptance rate, yielding near-random accuracy of 49%. After bias detection and correction, the predictions became more balanced and accuracy improved to 63%. The hyperagent thus learns to identify when its own improvements lead to degenerate behavior and to take corrective action, a crucial capability for any self-improving system.

#### E.3.4 Performance Tracking Infrastructure

The hyperagent creates performance tracking infrastructure that enables more effective future improvements, (i.e., investing in tools that improve the improvement process itself). For example, the agent develops a performance tracker for persistent metrics storage: ⬇

This infrastructure enables quantitative tracking of improvement across iterations, identification of which changes lead to performance gains, and data-driven decision-making for future modifications.

#### E.3.5 Prompt Template Systems

The hyperagent develops reusable prompt infrastructure, abstracting common patterns into modular, configurable components. This demonstrates the application of software engineering best practices, specifically, the DRY (Don’t Repeat Yourself) principle and the factory pattern. For example: ⬇

Predefined templates are stored for common scenarios: ⬇

By abstracting prompts into templates, the system becomes more maintainable and extensible. This infrastructure also provides a foundation for systematic experimentation with different prompting strategies.

#### E.3.6 Refinement Based on Multi-Generation Performance

The hyperagent develops a sophisticated iterative refinement process in which prompts are adjusted based on performance data across multiple generations. The agent learns not only to improve code, but also how to improve code effectively. For example, the system tracks performance across generations and synthesizes key learnings: Generation Performance Summary: - Gen 55: 63% accuracy, 75% reject rate (too harsh, 38% accept recall) - Gen 64: 61% accuracy, 53% reject rate (better balance, 64% accept recall) - Gen 66: 52% accuracy, 6% reject rate (too lenient, 96% accept recall) Key Learnings: 1. High accuracy requires critical evaluation with clear standards 2. Balance requires appropriate calibration, not just "fairness" language 3. Explicit criteria work better than subjective guidance 4. Borderline cases need clear default direction 5. Language matters - "fair" and "recognize" made agent too lenient

The hyperagent documents its reasoning and maintains records of what works: ⬇

By accumulating knowledge about which approaches succeed and fail, the hyperagent informs its decisions about what to modify next.

#### E.3.7 Persistent Memory

The hyperagent develops persistent memory systems that enable learning to accumulate across generations. Without explicit instruction to do so, the agent creates mechanisms for storing and retrieving insights across sessions. For example, the agent implements a memory tool with timestamped storage: ⬇

This memory system is actively used to accumulate knowledge across iterations. Examination of the memory.json file reveals structured storage of performance insights: ⬇

This memory system serves multiple critical functions. First, it enables cross-generation learning: insights from generation 55’s success and generation 66’s failure inform generation 67’s improvements. Second, it provides temporal context: timestamps allow the agent to track when insights were recorded and reason about recency. Third, it creates a shared knowledge base: key learnings are preserved even as code changes, preventing the system from repeating past mistakes.

By creating external memory storage, the hyperagent effectively extends its cognitive capabilities beyond the limitations of a single inference session. The memory entries reveal sophisticated reasoning patterns. The agent stores not just raw performance numbers, but synthesized insights (“Gen55 has best accuracy but is too harsh”), causal hypotheses (“gen65 changes over-corrected”), and strategic plans (“combine gen55’s critical reasoning with gen64’s balance”). This demonstrates that the hyperagent is not merely logging data, but actively constructing and preserving knowledge that informs future decision-making. This behavior aligns with a growing body of work on agents that autonomously discover and use external memory systems to support long-horizon reasoning and continual improvement [ Wei et al., 2025a , Weng et al., 2026 , Zhang et al., 2026 , Xiong et al., 2026 ] .

### E.4 Olympiad-level Math Graders

BetterGrader is produced automatically by the DGM-H without any domain-specific heuristics or handcrafted rules ( Section 5.3 ). Section E.1.3 shows the code changes that led to the BetterGrader. BetterGrader’s improvements over ProofAutoGrader [ Luong et al., 2025 ] are driven primarily by correcting a grading bias that collapses nuanced solutions into extreme labels. The confusion matrices show that ProofAutoGrader frequently misclassifies intermediate cases as either Correct or Incorrect : for Almost , it predicts Correct 98 times (vs. 70 for BetterGrader) and Incorrect 27 times (vs. 18), and for Partial it over-assigns Incorrect 137 times (vs. 106) ( Figure 10 ). BetterGrader assigns intermediate labels more appropriately, substantially increasing true positives for Almost (43 vs. 13) and Partial (72 vs. 47), which matches the large gains in recall ( Almost : + 18.52 % +18.52\% , Partial : + 10.50 % +10.50\% ) and F1 ( Almost : + 0.203 +0.203 , Partial : + 0.109 +0.109 ). Although BetterGrader trades a modest decrease in Correct recall ( − 6.00 % -6.00\% ), a regime where ProofAutoGrader was already near-saturated at 91.67 % 91.67\% , the net effect is higher overall accuracy ( + 4.06 % +4.06\% ), consistent with a grader that better matches human granularity rather than defaulting to all-or-nothing judgments.

### E.5 Modifying Parent Selection

In this section, we investigate whether the DGM-H can automatically modify the parent selection mechanism. In all other experiments ( Section 5 ), the DGM-H uses a fixed parent selection strategy that is roughly proportional to each agent’s performance score and the number of its children that successfully compiled ( score-child-prop ) ( Section A.2 ). In the DGM-H run with a modifiable parent selection mechanism ( modifiable ), we initialize the DGM-H with random parent selection and allow the agent to modify this mechanism over time ( Algorithm 5 ). We compare this setting against a baseline that uses random parent selection throughout the run ( random ). Each method is repeated across 5 repeated runs.

On test tasks, DGM-H with random parent selection improves average performance on paper review and robotics reward design from 0.030 (the initial agent) to 0.428 (CI: 0.407 – 0.432). Allowing the DGM-H to modify the parent selection mechanism further improves performance to 0.491 (CI: 0.387 – 0.512). The handcrafted score-child-prop parent selection achieves the highest performance, improving from 0.030 to 0.532 (CI: 0.384–0.586). While these differences are not statistically significant (p ¿ 0.05), they reveal a consistent qualitative trend: enabling meta-level modification of parent selection yields improvements over random selection, but does not yet surpass a carefully engineered mechanism ( Figures 11 and 12 ).

We qualitatively analyze how the DGM-H modifies the parent selection mechanism. Starting from random parent selection, the meta agent consistently replaces random sampling with structured exploration-exploitation strategies. Across all runs, the DGM-H independently creates variants of Upper Confidence Bound (UCB) [ Auer et al., 2002 ] style selection, combining normalized performance with explicit exploration bonuses: ⬇

This pattern emerges within the first few iterations of every run, indicating that the meta-agent recognizes UCB-style selection as a broadly useful principle for open-ended search. Beyond UCB, the DGM-H evolves probabilistic selection mechanisms based on temperature-controlled softmax sampling, allowing smoother trade-offs between exploration and exploitation: