Support self-improving HyperAgents

[myui]

Support self-improving meta agents concepts (HyperAgents) as one in

https://github.com/facebookresearch/HyperAgents
https://github.com/lablnet/HyperFlow

[myui]

HyperAgents (DGM-H) — Concise Summary

Definition

HyperAgents are self-referential agent programs that evolve both task-solving behavior and their own improvement mechanisms via evolutionary search.

---

Core Idea

The system does not just improve solutions — it improves:

the mechanism that generates improvements

---

Architecture

A single, editable program contains:

• Task logic (solve tasks)
• Meta logic (propose modifications)

program = { task_logic, meta_logic, memory, ... }

All components are subject to modification.

---

Execution Loop (DGM-H)

archive = [initial_agent]

while budget:

    parent = select(archive)        # fitness-based selection

    child = parent.self_modify()    # modifies task + meta + internal logic

    if not valid(child):
        continue

    score = evaluate(child)

    archive.append(child)

---

Key Properties

Self-Referential

• The agent can modify its own code, including its improvement logic

Evolutionary

• Population-based search (archive)
• Selection pressure (fitness-based sampling)
• Branching (multiple descendants coexist)

Open-Ended

• Maintains diverse intermediate agents (“stepping stones”)
• Supports long-horizon exploration

---

What Evolves

Each iteration can change:

{
  "task_logic": ...,
  "meta_logic": ...,
  "memory": ...,
  "internal_strategy": ...
}

The improvement algorithm itself is part of the search space

---

Constraints (Current Form)

Fixed:

select(...)
evaluate(...)
outer_loop

Mutable:

agent program (task + meta + internal logic)

---

One-Liner

A system that evolves not just solutions, but the way it generates improvements.

[myui]

HyperFlow — Overview

Definition

HyperFlow is a structured, multi-agent critic loop implemented with explicit orchestration (e.g., LangGraph), where agents iteratively improve task execution via evaluation and feedback.

---

Core Idea

HyperFlow follows a standard refinement cycle:

solve → evaluate → improve → retry

Unlike ad-hoc loops, this is implemented as a clear, explicit execution graph.

---

Architecture

HyperFlow typically separates roles:

system = {
    "task_agent": ...,     # executes the task
    "improver": ...,       # evaluates and suggests improvements
}

• Task Agent

  • Produces outputs (code, answers, plans)

• Improver / Evaluator

  • Analyzes outputs
  • Generates feedback

---

Execution Flow

for i in range(N):

    result = task_agent.run(task)

    feedback = improver.analyze(result)

    task_agent = update(task_agent, feedback)

---

Key Properties

Structured Orchestration

• Execution flow is explicitly defined (often as a graph/DAG)
• Each step (solve, evaluate, improve) is modular

---

Multi-Agent Separation

• Clear division of responsibilities:

  • execution vs evaluation

---

Iterative Refinement

• Improves results over multiple attempts
• Converges via repeated feedback loops

---

What Changes

{
  "prompts": ...,
  "tool_usage": ...,
  "reasoning_strategy": ...
}

• Updates agent behavior across iterations
• Keeps the improvement mechanism fixed

---

Characteristics

• Deterministic or semi-deterministic control flow
• Engineering-oriented (practical optimization)
• Easy to reason about and debug

---

Limitation

improvement_logic = fixed

• The system improves outputs
• But does not evolve how it improves

---

One-Liner

A structured, multi-agent implementation of a critic loop with explicit orchestration.

[myui]

Self-Improving Agents — Quick Comparison

HyperFlow / Critic Loop

for _ in range(N):
    y = agent.solve(x)
    fb = critic(y)
    agent = improve(agent, fb)

• Improves outputs
• Improvement logic is fixed
• Local optimization

---

HyperAgents (DGM-H)

archive = [agent]

while budget:
    p = select(archive)
    c = p.self_modify()   # task + meta
    score = eval(c)
    archive.append(c)

• Evolves the agent itself
• Improvement mechanism is mutable
• Evolutionary search

---

Intuition

• Critic loop:

  "Try better"

• DGM-H:

  "Learn how to try better"