七大智能体运行时引擎实战横评：谁在重新定义Agent基础设施

// Temporal Agent Workflow: 带人工审批的客服处理
import { proxyActivities, executeChild } from '@temporalio/workflow';
import * as wf from '@temporalio/workflow';

const { callLLM, searchKnowledgeBase, sendNotification } = proxyActivities({
  startToTimeout: '30s',
  retryPolicy: { maximumAttempts: 3, backoffCoefficient: 2 },
});

export async function customerSupportAgent(query: string): Promise<string> {
  // Step 1: 知识库检索 — 自动重试3次
  const context = await searchKnowledgeBase(query);

  // Step 2: LLM生成回答
  const draft = await callLLM({ query, context });

  // Step 3: 人工审批 — Workflow在此挂起，不消耗计算资源
  const approved = await wf.condition(
    () => externalSignal.approved, 
    '24h'  // 最长等待24小时
  );

  if (!approved) {
    await sendNotification('回答被拒绝，需要重新生成');
    return await callLLM({ query: `改进: ${draft}`, context });
  }
  return draft;
}

// Restate Agent: 带重试和状态管理的LLM调用链
import { endpoint, ctx } from '@restatedev/restate-sdk';

const agentRouter = endpoint.router({
  researchAgent: async (ctx: restate.Context, topic: string) => {
    // 自动日志记录 — 崩溃后精确恢复到这一步
    const searchResults = await ctx.run('web-search', () =>
      fetch(`https://api.search.example/search?q=${topic}`).then(r => r.json())
    );

    // Restate自动处理幂等 — 同一个调用ID不会重复执行
    const analysis = await ctx.run('llm-analyze', () =>
      callLLM({ prompt: `分析: ${JSON.stringify(searchResults)}` })
    );

    // 持久化状态 — 即使进程崩溃也不丢失
    ctx.set('lastAnalysis', analysis);

    // 可选的长时间休眠 — 不消耗CPU，到时间自动唤醒
    await ctx.sleep(60_000); // 等待1分钟后继续

    const followUp = await ctx.run('llm-followup', () =>
      callLLM({ prompt: `基于之前分析深入: ${analysis}` })
    );

    return { analysis, followUp };
  }
});

// Inngest Agent: 多步骤研究助手
import { inngest } from './client';

export const researchAgent = inngest.createFunction(
  { id: 'research-agent', retries: 3 },
  { event: 'research/requested' },
  async ({ event, step, logger }) => {
    // 每个step.run()都是独立的持久化步骤
    const sources = await step.run('gather-sources', async () => {
      return await searchMultipleSources(event.data.topic);
    });

    // step.ai.infer() — 原生LLM调用步骤，自动处理限流
    const summary = await step.ai.infer('summarize', {
      model: 'gpt-4o',
      prompt: `总结以下资料: ${JSON.stringify(sources)}`,
      maxTokens: 2000,
    });

    // 条件分支 — 根据置信度决定是否需要人工审核
    if (summary.confidence < 0.8) {
      await step.run('request-review', async () => {
        await sendToHumanReview(summary);
      });
      // 暂停等待审核结果，不消耗计算资源
      const review = await step.waitForEvent('review/completed', {
        timeout: '24h',
      });
      return review?.data?.finalAnswer ?? summary.text;
    }

    return summary.text;
  }
);

// Trigger.dev v4: AI原生Agent定义
import { task, agent } from '@trigger.dev/sdk/v4';

export const codingAgent = task({
  id: 'coding-agent',
  run: async (payload: { requirement: string }) => {
    const result = await agent.loop('code-and-review', {
      model: 'claude-sonnet-4-6',
      maxIterations: 10,
      tools: [
        // 内置文件系统工具
        agent.tool('write-file', async ({ path, content }) => {
          await fs.writeFile(path, content);
          return { success: true };
        }),
        // 内置终端工具
        agent.tool('run-command', async ({ command }) => {
          const output = await exec(command);
          return { stdout: output };
        }),
      ],
      // 自动回退 — 当LLM调用失败时使用备用模型
      fallbackModel: 'gpt-4o-mini',
    }, async (ctx) => {
      const code = await ctx.run('generate-code', () =>
        callLLM({ prompt: `实现: ${payload.requirement}` })
      );

      const testResult = await ctx.run('test', () =>
        runTests(code)
      );

      if (!testResult.passed) {
        // 自动重试，保留之前的上下文
        ctx.feedback(`测试失败: ${testResult.errors}`);
        return 'retry';
      }
      return 'complete';
    });

    return result;
  },
});

// DBOS Agent: 数据库事务级持久化
import { DBOS } from '@dbos-inc/dbos-sdk';

export class ResearchAgent {
  @DBOS.step()  // 每个步骤自动持久化到Postgres
  static async searchWeb(query: string): Promise<string[]> {
    return await webSearch(query);
  }

  @DBOS.step()
  static async analyzeWithLLM(sources: string[]): Promise<string> {
    return await callLLM({ 
      prompt: `分析这些来源: ${sources.join('\n')}` 
    });
  }

  @DBOS.workflow()  // 工作流自动获得持久化、重试和恢复
  @DBOS.transaction()  // 数据库事务保证一致性
  static async runResearch(topic: string): Promise<string> {
    const sources = await ResearchAgent.searchWeb(topic);
    const analysis = await ResearchAgent.analyzeWithLLM(sources);

    // 直接写入数据库 — 和业务数据在同一事务中
    await DBOS.query(
      'INSERT INTO research_results (topic, analysis) VALUES ($1, $2)',
      [topic, analysis]
    );

    return analysis;
  }
}

// Vercel Workflow: Serverless-native AI Agent
import { workflow } from '@vercel/workflow';
import { generateObject, generateText } from 'ai';

export const contentAgent = workflow({
  id: 'content-generation-agent',
}, async ({ step, context }) => {
  // Vercel AI SDK原生集成
  const outline = await step.ai.run('create-outline', async () =>
    generateObject({
      model: openai('gpt-4o'),
      schema: outlineSchema,
      prompt: context.topic,
    })
  );

  // 并行步骤 — 自动编排到多个Serverless实例
  const [intro, body, conclusion] = await Promise.all([
    step.ai.run('write-intro', () =>
      generateText({ model: openai('gpt-4o'), prompt: `写引言: ${outline.intro}` })
    ),
    step.ai.run('write-body', () =>
      generateText({ model: openai('gpt-4o'), prompt: `写正文: ${outline.body}` })
    ),
    step.ai.run('write-conclusion', () =>
      generateText({ model: openai('gpt-4o'), prompt: `写结论: ${outline.conclusion}` })
    ),
  ]);

  return { outline, intro, body, conclusion };
});

// Cloudflare Dynamic Workflow: 边缘Agent
import { Workflow } from 'cloudflare:workers';

interface Env {
  AI: any; // Cloudflare Workers AI binding
}

export class EdgeAgent extends Workflow<Env> {
  async run(event: WorkflowEvent, step: WorkflowStep) {
    // 步骤1: 边缘AI推理 — 毫秒级延迟
    const intent = await step.do('classify-intent', async () => {
      return await this.env.AI.run('@cf/meta-llama/llama-3.3-70b', {
        prompt: `分类用户意图: ${event.query}`,
      });
    });

    // 步骤2: 动态路由到租户自定义处理逻辑
    const tenantHandler = await step.do('load-tenant-code', async () => {
      // 从KV加载租户自定义Agent逻辑
      const code = await this.env.TENANT_KV.get(
        `handler:${event.tenantId}`, 'text'
      );
      return code;
    });

    // 步骤3: 执行租户代码（沙箱隔离）
    const result = await step.do('execute-tenant', async () => {
      return await executeInSandbox(tenantHandler, intent);
    });

    return result;
  }
}

graph TB
    subgraph "2026 Agent Runtime Landscape"
        A[Agent Framework Layer<br/>LangGraph / CrewAI / OpenAI SDK]

        subgraph "Durable Execution Layer"
            B1[Temporal<br/>状态机+事件溯源]
            B2[Restate<br/>日志重播]
            B3[Inngest<br/>事件驱动]
            B4[Trigger.dev<br/>AI原生托管]
            B5[DBOS<br/>数据库事务]
        end

        subgraph "Serverless/Edge Layer"
            C1[Vercel Workflow<br/>Serverless原生]
            C2[Cloudflare DW<br/>边缘原生]
        end

        subgraph "K8s Native Layer"
            D1[kagent<br/>Solo.io]
            D2[ARK<br/>McKinsey]
        end

        subgraph "Infrastructure"
            E1[PostgreSQL]
            E2[Kubernetes]
            E3[Workers/Edge]
        end
    end

    A --> B1 & B2 & B3 & B4 & B5
    A --> C1 & C2
    A --> D1 & D2

    B5 --> E1
    B1 & B2 & B3 --> E2
    C2 --> E3
    D1 & D2 --> E2

flowchart LR
    Start[你的Agent场景是？] --> Q1{需要自托管吗？}

    Q1 -->|是，合规要求| Q2{团队技术栈？}
    Q1 -->|否，全托管优先| Q3{已锁定云平台？}

    Q2 -->|Java/Go 企业| T1[Temporal]
    Q2 -->|TypeScript 全栈| Q4{Agent复杂度？}
    Q2 -->|数据密集型| T2[DBOS]

    Q4 -->|高，多步骤+人工审批| T1
    Q4 -->|中，事件驱动为主| T3[Inngest]
    Q4 -->|低，追求轻量| T4[Restate]

    Q3 -->|Vercel/Next.js| T5[Vercel Workflow]
    Q3 -->|Cloudflare| T6[Cloudflare DW]
    Q3 -->|无锁定| Q5{Agent需要MCP？}

    Q5 -->|是| T7[Trigger.dev]
    Q5 -->|否| T3

    Start --> Q6{K8s原生需求？}
    Q6 -->|企业微服务统一管理| T8[kagent]
    Q6 -->|低代码Agent定义| T9[ARK]