传统框架：Agent Loop → State → [崩溃] → 丢失 → 从头重跑
执行引擎：Agent Loop → Journal → [崩溃] → 重放Journal → 从断点继续

# Temporal Python SDK — Durable AI Agent
from datetime import timedelta
from temporalio import workflow, activity

@activity.defn
async def call_llm(messages: list[dict]) -> str:
    """封装LLM调用为Activity，结果被自动记录"""
    response = await openai_client.chat.completions.create(
        model="gpt-4o", messages=messages
    )
    return response.choices[0].message.content

@activity.defn
async def execute_tool(tool_name: str, args: dict) -> str:
    """工具执行也是Activity，自带幂等性保证"""
    return await tool_registry.execute(tool_name, args)

@workflow.defn
class DurableAgent:
    def __init__(self):
        self.messages = []
        self.pending_approval = None

    @workflow.run
    async def run(self, prompt: str) -> str:
        self.messages.append({"role": "user", "content": prompt})
        while True:
            # LLM调用 — Activity，自动持久化
            response = await workflow.execute_activity(
                call_llm, self.messages,
                start_to_close_timeout=timedelta(seconds=30),
            )

            if "<approval_needed>" in response:
                # 挂起等待人类审批 — Signal机制
                self.pending_approval = response
                await workflow.wait_condition(
                    lambda: self.pending_approval is None
                )
                continue

            if "<tool_call:" in response:
                tool, args = parse_tool_call(response)
                result = await workflow.execute_activity(
                    execute_tool, tool, args,
                    start_to_close_timeout=timedelta(seconds=60),
                )
                self.messages.append({"role": "tool", "content": result})
                continue

            return response  # 最终响应

    @workflow.signal
    def approve(self, decision: str):
        """外部Signal注入人类审批结果"""
        self.messages.append({"role": "human", "content": decision})
        self.pending_approval = None

// Restate TypeScript SDK — Agent as Virtual Object
import { restate } from "@restatedev/restate-sdk";
import { openai } from "openai";

const agent = restate.object({
  name: "AIAgent",
  handlers: {
    // 每个session_id对应一个Virtual Object实例
    // 单线程执行保证 — 不会有两个并发处理同一个session
    async chat(ctx: restate.ObjectContext, message: string) {
      // 从持久化状态恢复对话历史
      const history = (await ctx.get<string[]>("history")) || [];
      history.push({ role: "user", content: message });

      // LLM调用 — 自动Journaling，崩溃后自动重放
      const response = await ctx.run(() =>
        openai.chat.completions.create({
          model: "gpt-4o",
          messages: history,
          tools: [
            { type: "function", function: { name: "search", ... } },
            { type: "function", function: { name: "send_email", ... } },
          ],
        })
      );

      if (response.tool_calls) {
        for (const call of response.tool_calls) {
          // 工具执行 — 也被Journaling保护
          const result = await ctx.run(() =>
            toolRegistry.execute(call.function.name, JSON.parse(call.function.arguments))
          );
          history.push({ role: "tool", content: result });
        }
        // 递归调用自身继续Agent Loop
        return ctx.objectClient(agent).chat("continue");
      }

      // 持久化对话历史
      ctx.set("history", history);
      return response.content;
    },

    // 人类审批 — Awakeable机制，代码看起来像同步等待
    async waitForApproval(ctx: restate.ObjectContext, proposal: string) {
      // 创建一个Awakeable（可被外部唤醒的Promise）
      const { id, promise } = ctx.awakeable<string>();

      // 发送审批请求到外部系统
      await ctx.run(() => sendApprovalRequest(proposal, id));

      // "阻塞"等待 — 实际上Virtual Object被挂起，不消耗计算资源
      const decision = await promise;

      return decision;  // "approved" or "rejected"
    },
  },
});

// Inngest — Event-Driven AI Agent with Step Functions
import { inngest } from "./client";

export const researchAgent = inngest.createFunction(
  {
    id: "research-agent",
    retries: 3,
    // 并发控制 — 限制同一用户的并发Agent数
    concurrency: [{ key: "event.data.userId", limit: 2 }],
  },
  { event: "research/request.created" },
  async ({ event, step, logger }) => {
    const { query, userId } = event.data;

    // Step 1: 搜索 — 自动持久化结果
    const searchResults = await step.run("search-web", async () => {
      return await tavilyClient.search(query, { max_results: 5 });
    });

    // Step 2: LLM分析搜索结果
    const analysis = await step.run("analyze-results", async () => {
      return await openai.chat.completions.create({
        model: "gpt-4o",
        messages: [
          { role: "system", content: "分析搜索结果并提取关键发现..." },
          { role: "user", content: JSON.stringify(searchResults) },
        ],
      });
    });

    // Step 3: 等待人类确认（最多24小时）
    const approval = await step.waitForEvent(
      "wait-for-approval",
      {
        event: "research/approval.decided",
        timeout: "24h",
        match: "data.researchId",
      }
    );

    if (!approval) {
      // 超时未审批
      await step.run("notify-timeout", async () => {
        await sendEmail(userId, "研究请求已超时");
      });
      return { status: "timeout" };
    }

    // Step 4: 生成最终报告
    const report = await step.run("generate-report", async () => {
      return await generateReport(analysis, approval.data.decision);
    });

    return { status: "completed", reportUrl: report.url };
  }
);

// Trigger.dev — Durable AI Agent Task
import { task, logger } from "@trigger.dev/sdk/v3";

// 子任务：单个工具执行
const executeToolCall = task({
  id: "execute-tool-call",
  run: async (payload: { tool: string; args: any }) => {
    const result = await toolRegistry.execute(payload.tool, payload.args);
    return result;
  },
});

// 主任务：Agent Loop
export const agentLoop = task({
  id: "agent-loop",
  run: async (payload: { prompt: string; sessionId: string }) => {
    let messages = [
      { role: "user", content: payload.prompt },
    ];

    for (let i = 0; i < 10; i++) {  // 最多10轮
      // LLM调用 — 每轮结果自动持久化
      const response = await fetch("https://api.openai.com/v1/chat/completions", {
        method: "POST",
        headers: { "Authorization": `Bearer ${process.env.OPENAI_KEY}` },
        body: JSON.stringify({ model: "gpt-4o", messages }),
      });
      const data = await response.json();
      const assistantMsg = data.choices[0].message;

      if (!assistantMsg.tool_calls?.length) {
        return { response: assistantMsg.content };
      }

      // 并行执行所有工具调用 — 每个都是独立的持久化子任务
      const toolResults = await Promise.all(
        assistantMsg.tool_calls.map((tc) =>
          executeToolCall.triggerAndWait({
            tool: tc.function.name,
            args: JSON.parse(tc.function.arguments),
          })
        )
      );

      messages.push(assistantMsg);
      toolResults.forEach((result, idx) => {
        messages.push({
          role: "tool",
          content: result.output,
          tool_call_id: assistantMsg.tool_calls[idx].id,
        });
      });
    }

    return { response: "max iterations reached" };
  },
});

// DBOS TypeScript — 轻量级持久化Agent
import { DBOS } from "@dbos-inc/dbos-sdk";

class ResearchAgent {
  @DBOS.step()  // 标记为持久化步骤
  static async callLLM(messages: any[]) {
    const response = await openai.chat.completions.create({
      model: "gpt-4o", messages,
    });
    return response.choices[0].message;
  }

  @DBOS.step()
  static async searchWeb(query: string) {
    return await tavilyClient.search(query);
  }

  @DBOS.step()
  static async sendNotification(userId: string, message: string) {
    await emailClient.send({ to: userId, body: message });
  }

  @DBOS.workflow()  // 标记为持久化工作流
  static async runAgent(prompt: string, userId: string) {
    const searchResults = await ResearchAgent.searchWeb(prompt);

    let messages = [
      { role: "system", content: "你是研究助手..." },
      { role: "user", content: `查询：${prompt}\n搜索结果：${JSON.stringify(searchResults)}` },
    ];

    for (let i = 0; i < 5; i++) {
      const response = await ResearchAgent.callLLM(messages);
      if (!response.tool_calls) {
        await ResearchAgent.sendNotification(userId, response.content);
        return response.content;
      }
      // ... 工具调用处理
    }
  }
}

// 触发Agent — 直接调用，DBOS自动持久化到Postgres
await ResearchAgent.runAgent("2026年Agent框架趋势", "[email protected]");

graph TB
    subgraph "应用层 — Agent逻辑"
        A1[Agent Prompt / System Instructions]
        A2[Tool Definitions / MCP]
        A3[Memory / RAG]
    end

    subgraph "编排层 — 流程控制"
        B1[LangGraph<br/>Graph State Machine]
        B2[CrewAI<br/>Role-based Process]
        B3[Microsoft Agent Framework<br/>Agent + Harness]
        B4[Google ADK 2.0<br/>Code-first Agent Mesh]
    end

    subgraph "执行层 — 持久化运行时"
        C1[Temporal<br/>Event History + Replay]
        C2[Restate<br/>Journal + Virtual Object]
        C3[Inngest<br/>Step Functions + Events]
        C4[Trigger.dev<br/>Durable Tasks]
        C5[DBOS<br/>Postgres-backed Workflows]
    end

    subgraph "基础设施层"
        D1[Postgres / Cassandra]
        D2[Message Queue]
        D3[Object Storage]
    end

    A1 & A2 & A3 --> B1 & B2 & B3 & B4
    B1 & B2 & B3 & B4 --> C1 & C2 & C3 & C4 & C5
    C1 & C2 & C3 & C4 & C5 --> D1 & D2 & D3

    style C1 fill:#f9d71c,stroke:#333
    style C2 fill:#f9d71c,stroke:#333
    style C3 fill:#f9d71c,stroke:#333
    style C4 fill:#f9d71c,stroke:#333
    style C5 fill:#f9d71c,stroke:#333

graph TD
    Start[选择Agent运行时] --> Q1{团队主要语言?}
    Q1 -->|Python| Q2{需要微服务级可靠性?}
    Q1 -->|TypeScript| Q3{部署环境?}

    Q2 -->|是| Temporal[Temporal<br/>企业级Python Agent]
    Q2 -->|否| Q4{已有Postgres?}
    Q4 -->|是| DBOS[DBOS<br/>零运维Python Agent]
    Q4 -->|否| Temporal

    Q3 -->|Serverless/Cloud| Q5{事件驱动为主?}
    Q3 -->|自托管/VPS| Q6{并发规模?}

    Q5 -->|是| Inngest[Inngest<br/>事件驱动Step函数]
    Q5 -->|否| Trigger[Trigger.dev<br/>Durable Task平台]

    Q6 -->|高| Restate[Restate<br/>Virtual Object高并发]
    Q6 -->|中低| Q7{需要人机协作?}
    Q7 -->|是| Restate
    Q7 -->|否| DBOS

    style Temporal fill:#4CAF50,color:#fff
    style Restate fill:#2196F3,color:#fff
    style Inngest fill:#FF9800,color:#fff
    style Trigger fill:#9C27B0,color:#fff
    style DBOS fill:#607D8B,color:#fff