# Devin工作流简化伪代码
class DevinAgent:
    def execute(self, task: str):
        plan = self.planner.decompose(task)  # 分解为子任务
        for step in plan:
            code = self.coder.generate(step)
            result = self.sandbox.execute(code)
            if result.failed:
                diagnosis = self.debugger.analyze(result.error)
                code = self.coder.fix(code, diagnosis)
                result = self.sandbox.execute(code)
            self.commit(result)

# OpenHands核心循环简化
from openhands.controller import AgentController
from openhands.runtime import DockerRuntime

controller = AgentController(agent=CodeActAgent(llm_config))
runtime = DockerRuntime(image="openhands/runtime:latest")

while not task_complete:
    observation = runtime.get_observation()
    action = controller.step(observation)  # 包含Reasoning+Action
    result = runtime.execute(action)
    event_stream.emit(action, result)  # 全链路追踪

# SWE-agent ACI配置片段
commands:
  - name: search_dir
    signature: "search_dir <search_term> [<dir>]"
    doc: "Searches for search_term in all files in dir"
  - name: edit_file
    signature: "edit_file <start_line>:<end_line> <<EOF\n<content>\nEOF"
    doc: "Replace lines start_line to end_line with content"

# Claude Code使用方式——极简到极致
npm install -g @anthropic-ai/claude-code
cd my-project
claude  # 启动交互式Agent会话
claude "修复所有TypeScript类型错误"  # 直接执行任务

# Letta记忆管理核心循环
class LettaAgent:
    def __init__(self):
        self.working_context = []      # 类似CPU寄存器
        self.archival_memory = VectorStore()  # 类似硬盘
        self.recall_memory = ConversationStore()    # 类似日志

    def think(self, message):
        # Agent自主决定是否需要检索记忆
        if self.needs_context(message):
            relevant = self.archival_memory.search(message)
            self.working_context.append(relevant)

        response = self.llm.generate(
            message,
            context=self.working_context,
            memory_instructions=self.memory_prompt
        )

        # Agent自主决定是否持久化新信息
        if response.should_memorize:
            self.archival_memory.insert(response.memory_item)

┌─────────────────────────────────────────────────┐
│              自主Agent核心循环                     │
│                                                 │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │  感知     │───▶│  推理     │───▶│  行动     │  │
│  │ Observe  │    │ Reason   │    │   Act    │  │
│  └──────────┘    └──────────┘    └──────────┘  │
│       ▲                               │         │
│       │         ┌──────────┐          │         │
│       └─────────│  反思     │◀─────────┘         │
│                 │ Reflect  │                    │
│                 └──────────┘                    │
│                      │                          │
│              ┌───────┴───────┐                  │
│              │               │                  │
│         ┌────▼────┐   ┌─────▼─────┐            │
│         │ 记忆层   │   │  工具层   │            │
│         │ Memory  │   │  Tools   │            │
│         └─────────┘   └───────────┘            │
└─────────────────────────────────────────────────┘

# ReAct模式核心
while not done:
    thought = agent.think(observation)  # "我需要先找到配置文件"
    action = agent.act(thought)         # search("config.yaml")
    observation = environment.execute(action)

flowchart TB
    subgraph 五层防线["自主Agent生产护栏五层架构"]
        L1["第1层：输入验证\nPrompt Injection检测\nSchema校验"]
        L2["第2层：行为约束\n工具白名单\n操作预算限制"]
        L3["第3层：输出过滤\nPII脱敏\n毒性检测"]
        L4["第4层：成本控制\nToken预算\n重试上限"]
        L5["第5层：审计追溯\n全链路日志\n回放能力"]
    end

    L1 --> L2 --> L3 --> L4 --> L5

    style L1 fill:#e1f5fe
    style L2 fill:#b3e5fc
    style L3 fill:#81d4fa
    style L4 fill:#4fc3f7
    style L5 fill:#29b6f6

┌─────────────────────────────────────────────┐
│          你需要什么样的自主Agent？             │
└──────────────────┬──────────────────────────┘
                   │
         ┌─────────┴─────────┐
         │                   │
    代码开发场景          非编码场景
         │                   │
    ┌────┴────┐        ┌─────┴─────┐
    │         │        │           │
  需要开箱即用  需要定制    需要长期记忆   短期任务
    │         │        │           │
  Claude Code  OpenHands  Letta      LangChain
  或 Devin     或 SWE-agent (MemGPT)  + Mem0

# autonomous_agent.py — 生产级自主Agent最小骨架
import os
from openhands.controller.agent import Agent
from langfuse.decorators import observe

class ProductionAgent:
    def __init__(self, llm_config, max_steps=20, max_cost_usd=5.0):
        self.agent = Agent(llm_config=llm_config)
        self.max_steps = max_steps
        self.max_cost = max_cost_usd
        self.total_cost = 0.0

    @observe(name="agent_step")  # Langfuse自动追踪
    def step(self, task_context):
        # 第1层防线：输入验证
        if self._detect_injection(task_context):
            return {"status": "blocked", "reason": "prompt_injection"}

        # 第2层防线：成本检查
        if self.total_cost >= self.max_cost:
            return {"status": "budget_exceeded"}

        # 核心推理-行动循环
        action = self.agent.think(task_context)
        result = self.agent.execute(action)

        # 记录成本
        self.total_cost += result.token_cost

        # 第3层防线：输出过滤
        result.output = self._sanitize(result.output)

        return {"status": "ok", "action": action, "result": result}

    def run(self, task):
        for step_num in range(self.max_steps):
            step_result = self.step({"task": task, "step": step_num})

            if step_result["status"] != "ok":
                break

            if step_result["result"].task_complete:
                return step_result["result"]

        return {"status": "max_steps_reached"}