多Agent编排三极架构：DAG·状态机·Actor选型

from dagster import asset, AssetIn, materialize

@asset
def raw_research(context) -> str:
    """研究Agent抓取并聚合信息"""
    agent = ResearchAgent(model="claude-opus-4-5")
    return agent.run("2026量子计算最新进展")

@asset(ins={"research": AssetIn("raw_research")})
def fact_checked(research: str) -> list[dict]:
    """事实核查Agent验证声明"""
    return FactCheckAgent().verify(research)

@asset(ins={"claims": AssetIn("fact_checked")})
def final_report(claims: list[dict]) -> str:
    """写作Agent生成最终报告"""
    return WriterAgent().draft(claims)

result = materialize([raw_research, fact_checked, final_report])

// 每个Agent的显式状态定义
type AgentState =
  | { type: 'idle'; context: AgentContext }
  | { type: 'preparing'; context: AgentContext; intent: TaskIntent }
  | { type: 'executing'; context: AgentContext; startTime: ISO8601 }
  | { type: 'validating'; context: AgentContext; candidate: CandidateOutput }
  | { type: 'negotiating'; context: AgentContext; 
      dispute: DisputeRecord; partners: AgentId[] }
  | { type: 'committing'; context: AgentContext; output: CommittedOutput }
  | { type: 'failed'; context: AgentContext; 
      reason: FailureReason; retryable: boolean };

// 状态转换守卫
const validTransitions = {
  idle: ['preparing'],
  preparing: ['executing', 'failed'],
  executing: ['validating', 'failed'],
  validating: ['committing', 'negotiating', 'failed'],
  negotiating: ['executing', 'committing', 'failed'],
  committing: ['idle'],
  failed: ['preparing', 'idle'],
};

// Temporal：多步骤补偿事务
export async function bookingWorkflow(
  request: BookingRequest
): Promise<BookingResult> {
  const flight = await activities.bookFlight(request);
  try {
    const hotel = await activities.bookHotel(request);
    const car = await activities.bookCar(request);
    return { flight, hotel, car };
  } catch (err) {
    // 补偿：退款航班
    await activities.refundFlight(flight.id);
    throw err;
  }
}

import { VirtualObject } from "@restatedev/restate-sdk";

const agentSession = VirtualObject({
  name: "agentSession",
  handlers: {
    // 单并发保证：同一sessionId不会被并发调用
    chat: async (ctx, request: { sessionId: string; message: string }) => {
      // 从内置KV存储恢复上下文
      const history = ctx.get<string[]>("history") || [];
      history.push({ role: "user", content: request.message });

      // LLM调用持久化——崩溃后从断点恢复
      const response = await ctx.run("llm-call", () =>
        callLLM({ messages: history })
      );

      history.push({ role: "assistant", content: response });
      ctx.set("history", history);
      return response;
    },

    // 人工审批：暂停等待外部响应，跨重启保持
    approve: async (ctx, approval: { approved: boolean }) => {
      // 恢复暂停的Agent并注入审批结果
    }
  }
});

export const researchAgent = inngest.createFunction(
  { id: "research-agent" },
  { event: "agent/research.requested" },
  async ({ event, step }) => {
    // 每个step持久化，崩溃后只重试失败步骤
    const queries = await step.run("plan", () => 
      planQueries(event.data.topic)
    );
    const results = await step.run("search", () => 
      searchWeb(queries)
    );
    // AI原生原语：模型故障转移、Prompt缓存、Token计量
    const report = await step.ai.infer("summarize", {
      model: openai({ model: "gpt-5" }),
      body: { messages: buildSummaryPrompt(results) },
    });
    return report;
  }
);

export const codeReviewAgent = task({
  id: "code-review-agent",
  maxDuration: 3600,  // 1小时超时
  retry: { maxAttempts: 3 },
  run: async (payload: { prUrl: string }) => {
    const diff = await fetchDiff(payload.prUrl);
    const findings = await runStaticAnalysis(diff);
    const llmReview = await callClaude(diff, findings);
    await postReviewComment(payload.prUrl, llmReview);
    return { findings: findings.length, posted: true };
  },
});

import { Agent, Workflow } from "@mastra/core";

const researcher = new Agent({
  name: "researcher",
  instructions: "研究给定主题的最新进展",
  model: openai("gpt-4o"),
});

const writer = new Agent({
  name: "writer",
  instructions: "基于研究结果撰写报告",
  model: openai("gpt-4o"),
});

const workflow = new Workflow({
  name: "research-pipeline",
  triggerSchema: z.object({ topic: z.string() }),
})
  .step(researcher)
  .step(writer, { dependsOn: [researcher] });

// 内置评估、记忆、可观测性
const result = await workflow.run({ topic: "量子计算2026" });

graph TB
    subgraph "三大编排模型"
        direction TB
        DAG["DAG有向无环图<br/>━━━━━━━━<br/>Airflow 3.0 | Dagster<br/>Prefect ControlFlow"]
        FSM["有限状态机<br/>━━━━━━━━<br/>Temporal | LangGraph<br/>AWS Step Functions"]
        ACTOR["Actor模型<br/>━━━━━━━━<br/>Restate | Ray<br/>ElizaOS"]
    end

    subgraph "混合/融合引擎"
        direction TB
        HYBRID["事件驱动混合<br/>━━━━━━━━<br/>Inngest | Trigger.dev"]
        GRAPH["图融合<br/>━━━━━━━━<br/>Mastra | LangGraph"]
    end

    subgraph "持久化执行层"
        DUR["Durable Execution<br/>━━━━━━━━<br/>Temporal | Restate<br/>Inngest | Trigger.dev"]
    end

    subgraph "Agent能力层"
        direction LR
        LLM["LLM调用"]
        TOOL["工具调用"]
        MEM["记忆管理"]
        HUMAN["人机协作"]
    end

    DAG --> DUR
    FSM --> DUR
    ACTOR --> DUR
    HYBRID --> DUR
    GRAPH --> DUR

    DUR --> LLM
    DUR --> TOOL
    DUR --> MEM
    DUR --> HUMAN

    style DAG fill:#4A90D9,color:#fff
    style FSM fill:#E67E22,color:#fff
    style ACTOR fill:#27AE60,color:#fff
    style HYBRID fill:#8E44AD,color:#fff
    style GRAPH fill:#2C3E50,color:#fff
    style DUR fill:#C0392B,color:#fff

flowchart TD
    START[开始选型] --> Q1{工作流是否有循环/迭代?}
    Q1 -->|否| Q2{是否需要实时事件响应?}
    Q1 -->|是| Q3{是否需要超长周期等待?}

    Q2 -->|否| DAG_SEL[DAG模型<br/>Airflow / Dagster / Prefect]
    Q2 -->|是| Q4{Agent数量是否>10?}

    Q4 -->|否| EVENT_SEL[事件驱动<br/>Inngest / Trigger.dev]
    Q4 -->|是| ACTOR_SEL[Actor模型<br/>Restate / Ray]

    Q3 -->|是| FSM_SEL[状态机模型<br/>Temporal / Restate]
    Q3 -->|否| Q5{团队主语言?}

    Q5 -->|TypeScript| MASTRA_SEL[图融合<br/>Mastra / LangGraph]
    Q5 -->|Python| FSM_SEL2[状态机<br/>LangGraph / Temporal]
    Q5 -->|Go/Java| TEMPORAL_SEL[Temporal]

    style DAG_SEL fill:#4A90D9,color:#fff
    style FSM_SEL fill:#E67E22,color:#fff
    style ACTOR_SEL fill:#27AE60,color:#fff
    style EVENT_SEL fill:#8E44AD,color:#fff
    style MASTRA_SEL fill:#2C3E50,color:#fff