graph TD
    subgraph L1["L1: 硬编码"]
        A[预设角色] --> B[SOP流程]
        B --> C[固定输出格式]
    end
    subgraph L2["L2: 模板化"]
        D[角色模板] --> E[配置化流程]
        E --> F[参数化输出]
    end
    subgraph L3["L3: 动态选择"]
        G[角色池] --> H[LLM选择发言人]
        H --> I[上下文适配]
    end
    subgraph L4["L4: 自涌现"]
        J[无预设角色] --> K[目标驱动自组织]
        K --> L[角色+拓扑同时涌现]
    end
    L1 --> L2 --> L3 --> L4
    style L4 fill:#e8f5e9
    style L1 fill:#fce4ec

import asyncio
from metagpt.roles import ProductManager, Architect, ProjectManager, Engineer, QaEngineer
from metagpt.software_company import generate_repo, ProjectRepo

async def main():
    # 预设角色链——每个角色有固定的上游输入和下游输出
    company = SoftwareCompany()
    company.hire([
        ProductManager(),      # 角色1: 需求分析
        Architect(),           # 角色2: 架构设计
        ProjectManager(),      # 角色3: 任务分解
        Engineer(),            # 角色4: 代码实现
        QaEngineer(),          # 角色5: 质量保障
    ])
    company.invest(investment=5.0)
    company.run_project("一个支持Markdown的笔记应用")

from chatdev.chat_dev import ChatDev
from chatdev.model import ModelProvider

# ChatDev 1.x: 配置化角色
chatdev = ChatDev(
    model=ModelProvider("gpt-4o"),
    organization_config={
        "CEO": {"role": "决策"},
        "CTO": {"role": "技术方案"},
        "Programmer": {"role": "编码"},
        "Art Designer": {"role": "UI设计"},
        "Reviewer": {"role": "代码审查"},
        "CTO": {"role": "测试审查"},
    },
    chat_chain=["Design", "Coding", "CodeComplete", "Test"],
)
chatdev.run("开发一个贪吃蛇游戏")

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import SelectorGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.conditions import TextMentionTermination

model_client = OpenAIChatCompletionClient(model="gpt-4o")

# 定义角色池——角色是预设的，但发言人选择是动态的
planner = AssistantAgent("planner", model_client,
    system_message="你负责分析用户需求并制定计划")
coder = AssistantAgent("coder", model_client,
    system_message="你负责编写代码实现")
reviewer = AssistantAgent("reviewer", model_client,
    system_message="你负责审查代码质量和安全性")
tester = AssistantAgent("tester", model_client,
    system_message="你负责编写和执行测试用例")

# SelectorGroupChat: LLM动态选择每轮的发言Agent
team = SelectorGroupChat(
    participants=[planner, coder, reviewer, tester],
    model_client=model_client,  # Selector本身也用LLM
    termination_condition=TextMentionTermination("APPROVED"),
    max_turns=15,
)

# 运行团队
result = await team.run(task="实现一个LRU缓存，支持get/put操作")

# MetaGen核心流程伪代码
from metagen import MetaGenFramework, RoleEvolver, TopologyEvolver

framework = MetaGenFramework(
    backbone_model="gpt-4o",
    initial_roles=["analyzer", "solver", "verifier"],  # 初始角色种子
    initial_topology="fully_connected",                 # 初始拓扑
)

# 双引擎自演化循环
for iteration in range(max_iterations):
    # 1. 执行当前任务
    result = framework.execute(task)

    # 2. 评估角色效果——轻量级LLM评估
    role_scores = RoleEvolver.evaluate_roles(result)

    # 3. 更新角色提示词
    framework.roles = RoleEvolver.update(
        roles=framework.roles,
        scores=role_scores,
        strategy="incremental"  # 增量更新而非全量重写
    )

    # 4. 调整通信拓扑
    framework.topology = TopologyEvolver.adapt(
        topology=framework.topology,
        communication_log=framework.get_comm_log(),
        efficiency_metric=result.efficiency
    )

    # 5. 收敛检测
    if result.improvement < threshold:
        break

from agent_swarm import Swarm, Agent, Task

# 不预设角色——角色将在协作中涌现
swarm = Swarm(
    agents=[
        Agent(id=f"agent_{i}", model="gpt-4o")
        for i in range(5)
    ],
    cognitive_alignment=True,    # 启用认知对齐
    deliverable_tracking=True,   # 启用可交付物追踪
)

# 执行复杂任务——角色将自动涌现
result = swarm.execute(
    task=Task(
        description="分析一份100页的技术报告，生成摘要、关键发现和行动建议",
        deliverables=["executive_summary", "key_findings", "action_items"],
    )
)

# 查看涌现出的角色
for agent in swarm.agents:
    print(f"{agent.id}: {agent.emergent_role}")  # 自动分配的角色
    # 输出示例:
    # agent_0: 文档结构分析师
    # agent_1: 技术细节提取专家
    # agent_2: 摘要撰写者
    # agent_3: 行动项识别器
    # agent_4: 质量审查员

graph LR
    subgraph 预设结构["预设层级结构"]
        direction TB
        PM[PM] --> DEV1[Developer 1]
        PM --> DEV2[Developer 2]
        DEV1 --> QA[QA]
        DEV2 --> QA
    end

    subgraph 自组织["自组织结构"]
        direction TB
        A1[Agent 1] <-.-> A2[Agent 2]
        A2 <-.-> A3[Agent 3]
        A3 <-.-> A4[Agent 4]
        A1 <-.-> A4
        A1 <-.-> A3
    end

    预设结构 -->|25K任务对比| 自组织

    style 自组织 fill:#e8f5e9
    style 预设结构 fill:#fce4ec

# CARMI评估伪代码
def evaluate_emergence(team_trajectory):
    # Concentration: 每个Agent的任务分布熵
    concentration = []
    for agent in team_trajectory.agents:
        task_dist = agent.get_task_type_distribution()
        entropy = -sum(p * log(p) for p in task_dist.values())
        concentration.append(entropy)

    # Role Clarity: Agent间行为重叠度
    behavior_vectors = [a.get_behavior_embedding() for a in team_trajectory.agents]
    overlap_matrix = cosine_similarity_matrix(behavior_vectors)
    role_clarity = 1 - mean(overlap_matrix)  # 越低越清晰

    # Mutual Information: Agent行为间的依赖
    mi = mutual_information(
        team_trajectory.agent_actions[0],
        team_trajectory.agent_actions[1]
    )

    return {
        "concentration": mean(concentration),  # 越低=越专业化
        "role_clarity": role_clarity,           # 越高=越清晰
        "mutual_info": mi,                      # 适中=有协同但不过度
        "emerged": role_clarity > 0.7 and mean(concentration) < 1.5
    }

graph TD
    START[现有L1/L2系统] --> STEP1[步骤1: 引入角色评估]
    STEP1 -->|记录每个角色的实际产出效率| STEP2[步骤2: 动态权重调整]
    STEP2 -->|根据效率动态调整角色发言频率| STEP3[步骤3: LLM选择器]
    STEP3 -->|用LLM替代轮询/规则选择发言人| STEP4[步骤4: 角色提示词演化]
    STEP4 -->|允许LLM微调角色描述| STEP5[步骤5: 完全自组织]
    STEP5 -->|移除预设角色,仅保留目标约束| FINAL[L4 自涌现系统]

    style FINAL fill:#e8f5e9
    style START fill:#fce4ec