📄 AutoAgents: A Framework for Automatic Agent Generation

📋 메타 정보

항목	내용
논문 제목	AutoAgents: A Framework for Automatic Agent Generation
저자	Guangyao Chen, Siwei Dong, Yu Shu, Ge Zhang, Jaward Sesay, Börje F. Karlsson, Jie Fu, Yemin Shi
소속 기관	Peking University, Hong Kong University of Science and Technology (HKUST), Beijing Academy of Artificial Intelligence, University of Waterloo
발표처	IJCAI 2024 (Main Track), Pages 22-30
발표 연도	2024
arXiv	arXiv:2309.17288
DOI	10.24963/ijcai.2024/3
GitHub	Link-AGI/AutoAgents
Corresponding Authors	gy.chen@pku.edu.cn, ymshi@pku.edu.cn, jiefu@ust.hk

---

🎯 한줄 요약

태스크에 맞는 전문 에이전트 팀을 자동으로 생성하고 조율하는 적응형 멀티에이전트 프레임워크로, 사전 정의된 에이전트에 의존하지 않고 동적으로 역할을 생성하여 복잡한 태스크를 해결한다.

---

🔍 연구 배경 및 동기

기존 문제점

1. 사전 정의된 에이전트의 한계
   • 대부분의 기존 LLM 기반 멀티에이전트 시스템은 사전에 정의된(predefined) 에이전트에 의존
   • 단순한 태스크 처리에는 적합하나, 다양한 시나리오에 대한 적응성이 부족
   • 수동으로 다수의 전문가 에이전트를 생성하는 것은 많은 리소스 소모
2. 협업 범위의 제한
   • 특정 역할과 인간 감독이 필요한 수동 설계 에이전트
   • 협업 애플리케이션의 범위가 제한됨
   • 태스크별 최적의 에이전트 구성을 찾기 어려움
3. 확장성 문제
   • 기존 연구들은 인간이 설계한 프레임워크에 크게 의존
   • 에이전트 시스템의 기능 범위와 확장성이 제한됨

연구 동기

• 인간 팀처럼 다양한 전문가가 협력하여 복잡한 문제를 해결하는 AI 시스템 구축
• 태스크 내용에 따라 자동으로 적절한 에이전트 팀을 구성하는 메커니즘 필요
• 인간 그룹 내 다양성이 다양한 관점을 촉진하고 그룹 성과를 향상시킨다는 경험적 증거에 기반

---

💡 핵심 아이디어

1. 동적 에이전트 생성 (Dynamic Agent Generation)

태스크 내용을 분석하여 필요한 전문 에이전트를 동적으로 생성:

Task Input → Agent Generation → Specialized Agent Team

• 태스크와 역할 간의 관계를 연결(coupling)
• 태스크 콘텐츠 기반 필요 에이전트 자동 도출
• 생성된 전문가 에이전트 기반 실행 계획 수립

2. 2단계 프로세스 (Two-Stage Process)

Drafting Stage (초안 단계)

• 3개의 사전 정의된 에이전트(Planner, Agent Observer, Plan Observer)가 협력적 토론
• 입력 문제/태스크에 맞는 커스터마이즈된 에이전트 팀 합성
• 태스크에 적합한 실행 계획 생성

Execution Stage (실행 단계)

• 에이전트 간 협업과 피드백을 통한 계획 개선
• 자기 개선(Self-refinement)과 협력적 개선(Collaborative refinement) 수행
• 최종 결과물 생성

3. Observer 메커니즘

• Agent Observer: 생성된 에이전트의 적절성 검토
• Plan Observer: 실행 계획의 합리성 검토
• Action Observer: 실행 과정에서의 행동 및 결과 검토

4. 개선 메커니즘 (Refinement Mechanisms)

Self-Refinement (자기 개선)

• 단일 에이전트가 전문 태스크 수행 능력을 자체적으로 향상
• 계획 → 실행 → 피드백의 순환을 통한 지속적 개선

Collaborative Refinement (협력적 개선)

• 여러 에이전트 간 지식 공유
• 학제간 전문성이 필요한 태스크 달성
• 순차적 턴테이킹 방식의 협업

---

🏗️ 아키텍처 / 방법론

전체 시스템 아키텍처

┌─────────────────────────────────────────────────────────────────┐
│                        AutoAgents Framework                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    DRAFTING STAGE                            │ │
│  │  ┌─────────┐   ┌────────────────┐   ┌────────────────┐      │ │
│  │  │ Planner │◄─►│ Agent Observer │◄─►│ Plan Observer  │      │ │
│  │  └────┬────┘   └───────┬────────┘   └───────┬────────┘      │ │
│  │       │                │                     │               │ │
│  │       ▼                ▼                     ▼               │ │
│  │  ┌─────────────────────────────────────────────────────────┐│ │
│  │  │        Customized Agent Team + Execution Plan           ││ │
│  │  └─────────────────────────────────────────────────────────┘│ │
│  └─────────────────────────────────────────────────────────────┘ │
│                              │                                    │
│                              ▼                                    │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                   EXECUTION STAGE                            │ │
│  │  ┌─────────────────────────────────────────────────────────┐│ │
│  │  │              Generated Agent Team                        ││ │
│  │  │  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐           ││ │
│  │  │  │Agent 1 │ │Agent 2 │ │Agent 3 │ │Agent N │           ││ │
│  │  │  └────────┘ └────────┘ └────────┘ └────────┘           ││ │
│  │  └─────────────────────────────────────────────────────────┘│ │
│  │                              │                               │ │
│  │       ┌──────────────────────┼──────────────────────┐       │ │
│  │       ▼                      ▼                      ▼       │ │
│  │  ┌──────────────┐    ┌──────────────────┐    ┌───────────┐ │ │
│  │  │Self-Refinement│    │Collaborative     │    │  Action   │ │ │
│  │  │              │    │Refinement        │    │ Observer  │ │ │
│  │  └──────────────┘    └──────────────────┘    └───────────┘ │ │
│  └─────────────────────────────────────────────────────────────┘ │
│                              │                                    │
│                              ▼                                    │
│                       Final Output                                │
└─────────────────────────────────────────────────────────────────┘

핵심 컴포넌트

1. Planner (계획자)

# 역할: 전문가 역할 결정 및 실행 계획 수립
class Planner:
    def __init__(self, llm):
        self.llm = llm

    def generate_agents(self, task):
        """태스크 분석 후 필요한 에이전트 역할 생성"""
        prompt = f"""
        Task: {task}
        Analyze the task and determine:
        1. Required expert roles
        2. Each role's responsibilities
        3. Execution plan
        """
        return self.llm.generate(prompt)

    def create_execution_plan(self, agents, task):
        """생성된 에이전트 기반 실행 계획 수립"""
        pass

2. Observer 컴포넌트

# Agent Observer: 생성된 에이전트 검증
class AgentObserver:
    def validate_agents(self, agents, task):
        """에이전트의 적합성 및 완전성 검토"""
        # 역할 중복 검사
        # 필요 역할 누락 검사
        # 역할 정의의 명확성 검사
        pass

# Plan Observer: 실행 계획 검증
class PlanObserver:
    def validate_plan(self, plan, agents, task):
        """실행 계획의 실현 가능성 검토"""
        # 단계별 실행 가능성
        # 에이전트 역할과의 매칭
        # 논리적 순서 검증
        pass

# Action Observer: 실행 결과 검증
class ActionObserver:
    def validate_action(self, action, result):
        """실행 결과의 품질 검토"""
        pass

3. Refinement 메커니즘

# Self-Refinement: 단일 에이전트의 자기 개선
def self_refinement(agent, task, max_iterations=5):
    result = agent.execute(task)
    for i in range(max_iterations):
        feedback = agent.evaluate(result)
        if feedback.is_satisfactory:
            break
        result = agent.improve(result, feedback)
    return result

# Collaborative Refinement: 다중 에이전트 협력 개선
def collaborative_refinement(agents, task, max_rounds=5):
    chat_history = []
    current_result = None

    for round in range(max_rounds):
        for agent in agents:
            # 이전 에이전트들의 발화를 기반으로 응답 생성
            response = agent.generate(
                task=task,
                chat_history=chat_history,
                current_result=current_result
            )
            chat_history.append(response)
            current_result = response.result

        # 합의 도달 여부 확인
        if check_consensus(agents, current_result):
            break

    return current_result

알고리즘 흐름

Algorithm: AutoAgents Framework
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Input: Task T, LLM M, max_draft_iterations=3, max_refine_iterations=5
Output: Final Result R

# Phase 1: Drafting Stage
1. Initialize Planner, AgentObserver, PlanObserver with M
2. for i = 1 to max_draft_iterations:
   a. agents_list ← Planner.generate_agents(T)
   b. agent_feedback ← AgentObserver.validate(agents_list)
   c. if agent_feedback.needs_revision:
      agents_list ← Planner.revise_agents(agents_list, agent_feedback)
   d. execution_plan ← Planner.create_plan(agents_list, T)
   e. plan_feedback ← PlanObserver.validate(execution_plan)
   f. if plan_feedback.needs_revision:
      execution_plan ← Planner.revise_plan(execution_plan, plan_feedback)
   g. if AgentObserver.approved AND PlanObserver.approved:
      break

# Phase 2: Execution Stage
3. Initialize ActionObserver with M
4. for each step in execution_plan:
   a. assigned_agents ← get_agents_for_step(step, agents_list)
   b. if step.requires_collaboration:
      result ← collaborative_refinement(assigned_agents, step)
   else:
      result ← self_refinement(assigned_agents[0], step)
   c. action_feedback ← ActionObserver.validate(result)
   d. if action_feedback.needs_revision:
      result ← refine_result(result, action_feedback)
   e. update_shared_memory(result)

5. R ← aggregate_results()
6. return R

하이퍼파라미터 설정

파라미터	값	설명
max_draft_discussions	3	Drafting 단계 최대 토론 횟수
max_self_refinement	5	자기 개선 최대 반복 횟수
max_collaborative_refinement	5	협력적 개선 최대 반복 횟수

---

📊 실험 및 결과

실험 설정

평가 태스크

1. Open-ended Question Answering: 개방형 질문 응답 태스크
2. Trivia Creative Writing: 상식 기반 창작 글쓰기
3. Software Development (Case Study): 소프트웨어 개발 사례 연구 (Tetris 게임)

베이스라인 비교

• Standard LLM: 에이전트 생성 없이 단일 LLM 사용
• SSP (Solo Performance Prompting): 에이전트 샘플 제공 방식
• AgentVerse: 에이전트 토론 기반 실행 계획 생성
• MetaGPT: 사전 정의된 역할 기반 멀티에이전트 시스템

평가 지표

• FairEval (LLM-based): LLM 기반 공정 평가
• Human Evaluation: 인간 평가자에 의한 품질 평가
• Accuracy: 정확도 측정

주요 결과

정량적 결과

Method	Open-ended QA	Knowledge Acquisition
Standard	Baseline	Baseline
SSP	+5%	–
AgentVerse	+7%	–
AutoAgents	+10%	+10%

핵심 발견사항:
1. AutoAgents는 Standard 방식 대비 모든 실험에서 10% 향상 달성
2. 에이전트 생성을 사용하지만 다른 접근 방식인 SSP보다 우수한 성능
3. FairEval 기반 LLM 평가와 Human 평가 모두에서 개별 LLM 모델을 능가

정성적 결과

개방형 질문에 대한 응답 품질:
– 다수의 전문가 모델을 합성하여 더 포괄적이고 뉘앙스 있는 답변 생성
– 기존 멀티에이전트 방법보다 더 일관성 있고 정확한 솔루션 생성

Case Study: Tetris 게임 개발

AutoAgents가 생성한 에이전트 팀:
1. Game Design Expert: 게임 메커니즘 설계
2. UI Design Expert: 사용자 인터페이스 설계
3. Programmer: 핵심 코드 구현
4. Debugging Expert: 테스트 및 디버깅

결과:
– 더 정교한 문서화와 프로그램 생성
– 사용자가 이해하기 쉬운 결과물
– 협업 기반의 완성도 높은 게임 개발

Ablation Study 결과

Component	제거 시 성능 변화
Agent Observer	성능 저하
Plan Observer	성능 저하
Self-Refinement	상당한 성능 저하
Collaborative Refinement	상당한 성능 저하

---

💪 강점 및 기여

학술적 기여

1. 새로운 프레임워크 제안
   • 다양한 태스크에 맞는 커스터마이즈된 AI 팀을 동적으로 합성하고 조율
   • 태스크와 역할 간의 관계를 효과적으로 연결(coupling)
2. 정량적 실험 검증
   • 두 가지 도전적인 태스크에서 엄격한 정량적 실험 수행
   • LLM의 지식 습득과 추론 능력 모두 유의미하게 향상
3. 실용적 적용 가능성 입증
   • 소프트웨어 개발 등 복잡한 태스크에 적용 가능성 시연

기술적 강점

1. 적응성 (Adaptability)
   • 태스크 특성에 따른 에이전트 팀 자동 구성
   • 사전 정의 없이 동적 역할 생성
2. 신뢰성 향상 (Reliability)
   • Observer 메커니즘을 통한 품질 보증
   • SSP, AgentVerse 대비 생성된 에이전트와 계획의 신뢰성 강조
3. 개선 메커니즘 (Refinement)
   • Self-refinement: 개별 에이전트 역량 강화
   • Collaborative refinement: 팀 협업 효과 극대화
4. 확장성 (Scalability)
   • 무제한 에이전트 생성 지원
   • 다양한 도메인에 적용 가능

차별화 요소 (vs 기존 방법)

특성	MetaGPT	SSP	AgentVerse	AutoAgents
동적 에이전트 생성	✗	✓	✓	✓
Self-Refinement	✗	✗	✗	✓
Collaborative Refinement	✗	✗	✗	✓
Observer 메커니즘	✗	✗	✗	✓

---

⚠️ 한계점 및 향후 연구

논문에서 언급한 한계

1. LLM 품질 의존성
   • 기반 LLM의 품질과 능력에 크게 의존
   • 생성된 멀티에이전트 시스템의 성능과 신뢰성이 LLM에 좌우
2. 훈련 데이터 편향
   • 훈련 데이터와 모델에 존재하는 편향이 에이전트 성능에 영향
3. 초기 연구 단계
   • 실제 환경에서의 검증 및 확장성 테스트 필요
   • 더 많은 실제 시나리오에서의 평가 필요

실제 구현 시 도전과제

1. 토큰 제약
   • GPT-4와 같은 LLM의 토큰 제한으로 긴 대화 관리 어려움
   • 히스토리 정보가 많아질수록 컨텍스트 관리 복잡
2. 에이전트 간 통신 설계
   • 원활한 에이전트 간 통신을 위한 실행 루프의 신중한 설계 필요
3. 비용 문제
   • GPT-4 같은 모델을 다중 에이전트에 사용 시 비용 증가
   • 프롬프트 최적화로 토큰 사용량 최소화 필요
4. 선형 구조 한계
   • MetaGPT, AutoAgents, SPP 등은 선형 멀티에이전트 시스템
   • 유한 상태 기계처럼 되돌아가는 능력 부족

향후 연구 방향

1. 시스템 견고성 향상
   • 다양한 환경과 태스크에서의 안정성 개선
   • 에러 핸들링 및 복구 메커니즘 강화
2. 응용 도메인 확장
   • 소프트웨어 개발 외 다양한 도메인 적용
   • 도메인 특화 에이전트 생성 전략 개발
3. 고급 AI 기법 통합
   • 강화학습 기반 에이전트 개선
   • 더 정교한 협업 메커니즘 개발
4. 윤리 및 보안 고려
   • 자율 생성 시스템의 윤리적 함의 검토
   • 보안 취약점 분석 및 대응

---

🔗 관련 논문

선행 연구

논문	연도	관계
MetaGPT: Meta Programming for Multi-Agent Collaborative Framework	2023	사전 정의된 역할 기반 멀티에이전트
AgentVerse: Facilitating Multi-Agent Collaboration	2023	동적 에이전트 생성 + 토론 기반 계획
Solo Performance Prompting (SPP)	2023	에이전트 샘플 기반 생성
CAMEL: Communicative Agents for Mind Exploration	2023	역할극 기반 에이전트 통신
AutoGen: Enabling Next-Gen LLM Applications	2023	멀티에이전트 대화 프레임워크

관련 개념

개념	설명
LLM-based Agents	LLM을 기반으로 한 자율 에이전트 시스템
Multi-Agent Systems	다수의 에이전트가 협력하는 시스템
Centralized Planning, Decentralized Execution (CPDE)	중앙 계획, 분산 실행 패턴
Self-Refinement	에이전트의 자기 개선 메커니즘

후속 연구 방향

• AutoAgent (2025): 완전 자동화된 제로코드 LLM 에이전트 프레임워크
• AutoGenesisAgent: 자기 생성 멀티에이전트 시스템
• MegaAgent: 사전 정의된 SOP 없는 대규모 자율 멀티에이전트 시스템

---

💻 실무 적용 포인트

구현 시 고려사항

1. 기본 프로젝트 구조 (MetaGPT 기반)

autoagents/
├── agents/
│   ├── planner.py          # Planner 에이전트
│   ├── observers/
│   │   ├── agent_observer.py
│   │   ├── plan_observer.py
│   │   └── action_observer.py
│   └── generated/           # 동적 생성 에이전트
├── actions/
│   ├── self_refinement.py
│   └── collaborative_refinement.py
├── roles/
│   └── role_bank.py         # 역할 템플릿 저장소
├── memory/
│   └── shared_memory.py     # 에이전트 간 공유 메모리
└── main.py

2. 핵심 구현 예시

# agents/planner.py
from metagpt.roles import Role
from metagpt.actions import Action

class AgentGenerationAction(Action):
    """태스크 분석 및 에이전트 생성 액션"""

    PROMPT_TEMPLATE = """
    Analyze the following task and generate a list of required expert agents:

    Task: {task}

    For each agent, provide:
    1. Role name
    2. Role description
    3. Specific responsibilities
    4. Required skills/knowledge

    Output format: JSON
    """

    async def run(self, task: str):
        prompt = self.PROMPT_TEMPLATE.format(task=task)
        response = await self._aask(prompt)
        return self.parse_agents(response)

class Planner(Role):
    """중앙 계획자 역할"""

    def __init__(self):
        super().__init__()
        self._init_actions([AgentGenerationAction])

    async def _act(self):
        task = self.get_current_task()
        agents = await AgentGenerationAction().run(task)
        plan = await self.create_execution_plan(agents)
        return {"agents": agents, "plan": plan}

# actions/collaborative_refinement.py
class CollaborativeRefinement:
    """다중 에이전트 협력적 개선"""

    def __init__(self, agents, max_rounds=5):
        self.agents = agents
        self.max_rounds = max_rounds
        self.chat_history = []

    async def execute(self, task):
        current_result = None

        for round_num in range(self.max_rounds):
            for agent in self.agents:
                # 컨텍스트 구성
                context = self.build_context(
                    task,
                    self.chat_history,
                    current_result
                )

                # 에이전트 응답 생성
                response = await agent.respond(context)

                # 히스토리 업데이트
                self.chat_history.append({
                    "agent": agent.name,
                    "response": response
                })

                current_result = response.result

            # 합의 체크
            if self.check_consensus():
                break

        return current_result

    def check_consensus(self):
        """에이전트들이 합의에 도달했는지 확인"""
        # 구현 로직
        pass

3. 동적 에이전트 생성

# roles/dynamic_agent_factory.py
class DynamicAgentFactory:
    """동적 에이전트 생성 팩토리"""

    AGENT_TEMPLATE = """
    You are a {role_name}.

    Description: {description}
    Responsibilities: {responsibilities}

    Your goal is to {goal}

    Guidelines:
    - Focus on your specialized area
    - Collaborate with other team members
    - Provide detailed and actionable outputs
    """

    def create_agent(self, agent_spec):
        """스펙에 따라 에이전트 동적 생성"""

        class GeneratedAgent(Role):
            def __init__(self, spec):
                super().__init__()
                self.name = spec["role_name"]
                self.description = spec["description"]
                self.system_prompt = DynamicAgentFactory.AGENT_TEMPLATE.format(
                    **spec
                )

        return GeneratedAgent(agent_spec)

실무 적용 팁

1. 프롬프트 최적화
   • 토큰 사용량 최소화를 위한 간결한 프롬프트 설계
   • 역할 정의는 핵심만 포함
2. 메모리 관리
   • 긴 대화에서 컨텍스트 윈도우 관리 필수
   • 요약 메커니즘 도입 고려
3. 비용 최적화
   • 복잡하지 않은 작업에는 저렴한 모델 사용
   • 캐싱 전략 적용
4. 에러 처리
   • 에이전트 생성 실패 시 폴백 메커니즘
   • 실행 단계 중 오류 복구 전략

적용 가능 도메인

도메인	적용 예시
소프트웨어 개발	코드 생성, 리뷰, 테스트 자동화
콘텐츠 생성	글쓰기, 편집, 팩트체크 팀
연구 보조	문헌 조사, 분석, 요약
고객 서비스	다층 지원 시스템
교육	맞춤형 튜터링 시스템

---

🏷️ Tags

#AIAgent #MultiAgent #LLM #AutoGeneration #IJCAI2024 #DynamicAgentGeneration #MetaGPT #AgentVerse #CollaborativeAI #SelfRefinement #TaskPlanning #PekingUniversity #HKUST

---

📚 참고 자료

• IJCAI 2024 Proceedings
• arXiv Paper
• GitHub Repository
• Semantic Scholar