Agentic AI 架构设计：从单 Agent 到企业级 Agent 平台

构建一个能回答问题的 AI 对话系统不难，但构建一个能自主完成复杂任务的 Agent 系统则完全是另一回事。当你的 Agent 需要调用十几个工具、协调多个服务、处理各种异常情况时，架构设计就成了决定成败的关键因素。

单 Agent 架构的局限

大多数 Agent 项目从单 Agent 架构开始：一个 LLM、一组工具、一个循环。这种架构在原型阶段工作良好，但一旦规模扩大就会暴露问题。

上下文膨胀——当 Agent 调用越来越多的工具时，对话历史迅速膨胀，推理质量下降。

工具选择困难——当工具数量超过 20 个时，LLM 经常选错工具或遗漏合适的工具。

单点故障——如果 LLM 推理出错或工具执行失败，整个任务就中断了。

无法并行——单 Agent 只能串行执行任务，面对需要并行处理的场景效率低下。

企业级 Agent 平台的核心组件

一个成熟的企业级 Agent 平台通常包含以下核心组件：

┌─────────────────────────────────────────────────────────┐
│                    Agent Platform                         │
│                                                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │ Agent    │  │ Tool     │  │ Context  │  │ Monitor │ │
│  │ Runtime  │  │ Registry │  │ Manager  │  │ & Audit │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬────┘ │
│       │              │              │              │      │
│  ┌────┴──────────────┴──────────────┴──────────────┴───┐ │
│  │              Message Bus / Event System             │ │
│  └────┬──────────────┬──────────────┬──────────────┬───┘ │
│       │              │              │              │      │
│  ┌────┴─────┐  ┌─────┴────┐  ┌─────┴────┐  ┌─────┴────┐│
│  │ LLM      │  │ External │  │ Database │  │ Cache    ││
│  │ Gateway  │  │ APIs     │  │          │  │          ││
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘│
└─────────────────────────────────────────────────────────┘

Agent Runtime

Agent Runtime 是平台的核心——它负责管理 Agent 的生命周期、执行循环和状态管理。

class AgentRuntime {
  private agents: Map<string, AgentInstance> = new Map();

  async createAgent(config: AgentConfig): Promise<string> {
    const id = generateId();
    const agent = new AgentInstance(id, config);
    this.agents.set(id, agent);
    return id;
  }

  async run(agentId: string, task: string): Promise<AgentResult> {
    const agent = this.agents.get(agentId);
    if (!agent) throw new Error(`Agent ${agentId} not found`);

    return await agent.execute(task);
  }

  async stop(agentId: string): Promise<void> {
    const agent = this.agents.get(agentId);
    if (agent) {
      await agent.cleanup();
      this.agents.delete(agentId);
    }
  }
}

Tool Registry

Tool Registry 集中管理所有可用工具，支持动态注册和发现：

class ToolRegistry {
  private tools: Map<string, ToolDefinition> = new Map();

  register(definition: ToolDefinition): void {
    this.tools.set(definition.name, definition);
  }

  discover(query: string): ToolDefinition[] {
    // 基于语义匹配找到相关工具
    return Array.from(this.tools.values())
      .filter(tool => this.isRelevant(tool, query));
  }

  getForAgent(agentId: string): ToolDefinition[] {
    // 根据 Agent 的权限返回可用工具
    return Array.from(this.tools.values())
      .filter(tool => this.hasPermission(agentId, tool));
  }
}

Context Manager

Context Manager 负责管理每个 Agent 的上下文窗口：

class ContextManager {
  private contexts: Map<string, ConversationContext> = new Map();

  get(agentId: string): ConversationContext {
    if (!this.contexts.has(agentId)) {
      this.contexts.set(agentId, new ConversationContext());
    }
    return this.contexts.get(agentId)!;
  }

  async addToolResult(agentId: string, result: ToolResult): Promise<void> {
    const context = this.get(agentId);
    context.addMessage({
      role: 'tool',
      content: this.compress(result),
    });

    // 如果上下文接近限制，触发压缩
    if (context.tokenCount > this.maxTokens * 0.8) {
      await this.compressContext(agentId);
    }
  }

  private compress(result: ToolResult): string {
    // 截断过长的结果
    const maxLength = 2000;
    const text = result.content[0]?.text || '';
    if (text.length > maxLength) {
      return text.slice(0, maxLength) + '\n...(已截断)';
    }
    return text;
  }
}

Agent 从简单到复杂的演进路径

阶段一：单 Agent 原型

适合验证想法，工具数量 < 10，对话轮次 < 5。

阶段二：增强型单 Agent

添加错误重试、上下文压缩、工具缓存。适合 MVP 阶段。

阶段三：多 Agent 协作

引入专门化的子 Agent，主 Agent 负责任务分解和调度。

阶段四：Agent 平台

完整的运行时、注册中心、监控告警、权限管理。适合企业级落地。

性能与可扩展性设计

Agent 池化

class AgentPool {
  private pool: Map<string, AgentInstance[]> = new Map();

  async acquire(type: string): Promise<AgentInstance> {
    const available = this.pool.get(type)?.pop();
    if (available) return available;
    return await this.createAgent(type);
  }

  release(type: string, agent: AgentInstance): void {
    if (!this.pool.has(type)) {
      this.pool.set(type, []);
    }
    this.pool.get(type)!.push(agent);
  }
}

异步任务队列

对于长时间运行的任务，使用消息队列解耦请求和执行：

class TaskQueue {
  private queue: Task[] = [];

  async enqueue(task: Task): Promise<string> {
    const taskId = generateId();
    this.queue.push({ ...task, id: taskId });
    this.processNext();
    return taskId;
  }

  private async processNext(): Promise<void> {
    if (this.processing >= this.maxConcurrency) return;

    const task = this.queue.shift();
    if (!task) return;

    this.processing++;
    try {
      await this.executeTask(task);
    } finally {
      this.processing--;
      this.processNext();
    }
  }
}

常见问题（FAQ）

什么时候需要从单 Agent 升级到多 Agent？

当你的 Agent 工具数量超过 15 个，或者单次任务需要超过 10 轮工具调用时，考虑拆分为多 Agent。

Agent 平台的技术选型建议？

LLM 层选择 Claude 或 GPT-4，工具层使用 MCP 协议，编排层使用 LangGraph 或自研框架，监控层使用 OpenTelemetry。

如何评估 Agent 平台的性能？

关注三个指标：任务完成率（成功完成任务的比例）、平均工具调用次数（越少越好）、端到端延迟（从接收任务到返回结果的时间）。

总结

从单 Agent 到企业级 Agent 平台是一个渐进式的演进过程。关键是先让单 Agent 工作良好，再逐步引入多 Agent 协作、工具注册中心、上下文管理等平台级能力。过早引入复杂架构会拖慢迭代速度，过晚则会导致技术债务累积。