1
 2
 3
 4
 5
 6
 7
 8
 9
10

graph TD
    A[Environment] --> B[Task Agent]
    B --> C[Task Execution]
    C --> D[Task Trajectory]
    D --> E[Meta Agent]
    E --> F[Meta Optimization]
    F --> G[Updated Strategies]
    G --> B
    F --> H[Meta-Agent Self-Modification]
    H --> E

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

from dataclasses import dataclass
from typing import List, Optional

@dataclass
class TaskTrajectory:
    """Task Agent의 실행 궤적을 기록하는 데이터 클래스"""
    state: str
    action: str
    observation: str
    reward: float
    strategy_used: str
    metadata: dict

class TaskAgent:
    def __init__(self, model, tools, meta_strategy=None):
        self.model = model
        self.tools = tools
        self.meta_strategy = meta_strategy or {}
        self.trajectory_history: List[TaskTrajectory] = []
    
    def execute_task(self, task_description: str, max_steps: int = 10):
        """
        Meta Agent가 제공한 전략을 적용하여 task를 수행합니다.
        """
        current_state = task_description
        
        for step in range(max_steps):
            # Meta Agent의 전략을 프롬프트에 통합
            strategy_prompt = self._build_strategy_prompt(
                current_state, 
                self.meta_strategy
            )
            
            # 모델이 액션을 선택
            action = self.model.generate(strategy_prompt)
            
            # 환경에서 액션 실행
            observation, reward, done = self.environment.step(action)
            
            # 궤적 기록 (Meta Agent의 학습 데이터)
            trajectory = TaskTrajectory(
                state=current_state,
                action=action,
                observation=observation,
                reward=reward,
                strategy_used=str(self.meta_strategy),
                metadata={"step": step}
            )
            self.trajectory_history.append(trajectory)
            
            current_state = observation
            
            if done:
                break
        
        return self.trajectory_history
    
    def update_strategy(self, new_strategy: dict):
        """Meta Agent로부터 새로운 전략을 수신"""
        self.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

meta_strategy = new_strategy
    
    def _build_strategy_prompt(self, state: str, strategy: dict) -> str:
        """전략을 실행 프롬프트로 변환"""
        return f"""
        Current State: {state}
        
        Recommended Approach: {strategy.get('approach', 'standard')}
        Key Considerations: {strategy.get('considerations', [])}
        Past Mistakes to Avoid: {strategy.get('past_errors', [])}
        
        Based on the above, select your next action.
        """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

class MetaAgent:
    def __init__(self, meta_model):
        self.meta_model = meta_model
        self.meta_strategy_pool = []
        self.meta_meta_parameters = {
            "reflection_depth": 2,
            "strategy_complexity": "moderate",
            "risk_tolerance": 0.3
        }
    
    def optimize(self, task_trajectories: List[TaskTrajectory]):
        """
        Level 1: Task Agent를 위한 전략 최적화
        Level 2: 자신의 최적화 메커니즘 자체 최적화
        """
        
        # Level 1: Task 성능 분석 및 전략 생성
        performance_analysis = self._analyze_trajectories(task_trajectories)
        new_strategy = self._generate_strategy(performance_analysis)
        
        # Level 2: 메타-메타 최적화 (자기 반영)
        meta_effectiveness = self._evaluate_meta_performance(
            past_strategies=self.meta_strategy_pool[-10:],
            recent_trajectories=task_trajectories
        )
        
        # 자신의 최적화 방식을 수정
        if meta_effectiveness < 0.5:
            self._modify_own_parameters(meta_effectiveness)
        
        self.meta_strategy_pool.append(new_strategy)
        return new_strategy
    
    def _modify_own_parameters(self, effectiveness_score: float):
        """
        Meta Agent가 자신의 동작 방식을 수정하는 핵심 메서드.
        이것이 HyperAgents의 '자기 참조' 본질입니다.
        """
        adjustment_prompt = f"""
        Current meta-parameters: {self.meta_meta_parameters}
        Recent effectiveness: {effectiveness_score}
        
        The current optimization approach is not working well.
        Suggest modifications to the meta-parameters themselves:
        - Should reflection_depth increase or decrease?
        - Is strategy_complexity appropriate?
        - Should risk_tolerance change?
        """
        
        suggested_changes = self.meta_model.generate(adjustment_prompt)
        self.meta_meta_parameters.update(suggested_changes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# OpenAI API를 활용한 기본 구현
import openai

class SimpleTaskAgent:
    def __init__(self):
        self.system_prompt = "You are a helpful task-solving agent."
    
    def run(self, task: str, context: list = None) -> dict:
        messages = [
            {"role": "system", "content": self.system_prompt},
            {"role": "user", "content": task}
        ]
        if context:
            messages.insert(1, {"role": "system", "content": str(context)})
        
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=messages,
            temperature=0.7
        )
        return {"action": response.choices[0].message.content}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class SimpleMetaAgent:
    def __init__(self):
        self.feedback_history = []
    
    def analyze_and_suggest(self, task_result: dict) -> dict:
        feedback_prompt = f"""
        Task result: {task_result}
        Past feedback: {self.feedback_history[-5:]}
        
        Analyze the result and suggest improvements:
        1. What went wrong?
        2. What strategy would work better?
        3. How should the approach change?
        """
        
        analysis = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[{"role": "user", "content": feedback_prompt}],
            temperature=0.3  # 더 결정론적 분석
        )
        
        suggestion = analysis.choices[0].message.content
        self.feedback_history.append(suggestion)
        return {"suggested_strategy": suggestion}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class HyperAgentSystem:
    def __init__(self):
        self.task_agent = SimpleTaskAgent()
        self.meta_agent = SimpleMetaAgent()
        self.iteration_count = 0
    
    def run_improvement_cycle(self, task: str, iterations: int = 5):
        results = []
        
        for i in range(iterations):
            # Task Agent가 작업 수행
            task_result = self.task_agent.run(task)
            
            # Meta Agent가 분석 및 제안
            meta_suggestion = self.meta_agent.analyze_and_suggest(task_result)
            
            # Task Agent의 프롬프트를 Meta Agent의 제안으로 업데이트
            self.task_agent.system_prompt += f"

Learned strategy: {meta_suggestion}"
            
            results.append({
                "iteration": i,
                "result": task_result,
                "meta_feedback": meta_suggestion
            })
            self.iteration_count += 1
        
        return results

# 실행 예시
system = HyperAgentSystem()
improvement_log = system.run_improvement_cycle(
    task="Write a function to find the longest palindromic substring",
    iterations=5
)

1
2
3
4
5
6
7

class SafeMetaAgent(SimpleMetaAgent):
    def __init__(self):
        super().__init__()
        self.safety_constraints = {
            "max_strategy_changes_per_cycle": 3,
            "forbidden_actions": ["delete_system_files", "modify_core_logic"],
            "