用 Kiro 和 AWS 构建企业级 Agentic AI 平台

我们如何用 Kiro（来自 AWS 的 AI IDE）完成从需求到部署的完整开发生命周期——基于 Strands Agents、Amazon Bedrock AgentCore 和 AWS 基础设施，构建了一个可用于生产的 AI Agent 平台。一个人，一周时间，零手写代码。

为什么要做”以交付为核心”的 AI Agent？#

大多数 AI 聊天产品止步于对话。你提个问题，得到一段文本回复，然后就没了。但企业场景需要的是可交付成果：架构图、已部署的网页、账单分析报告、可执行的代码。

这正是我们构建这个 AI Agent 平台的原因。用户用自然语言描述需求，Agent 便产出实实在在的成果——图片、视频、文档、数据分析、已部署的静态网站，甚至是 AWS 架构图。

平台主界面——左侧边栏展示会话与导航，右侧展示 Agent 对话，并实时显示工具执行进度与交付成果输出。

真正的挑战不在于”构建一个 Agent”——而在于让它在生产环境中稳定运行：自动扩缩容、安全的代码执行沙箱、跨会话的记忆持久化、多工具编排。从零构建这些能力需要数月时间。

我们的答案是一套三层运行时架构：Strands Agents（Agent 框架）+ Amazon Bedrock AgentCore（运行时 + 记忆 + 沙箱）+ AWS CDK（基础设施即代码）。

而最关键的一点是——整个平台从头到尾都是由 AI 开发的。

开发层：用 Kiro 构建一切#

这个项目最引人注目的地方在于：从需求收集、架构设计、任务拆解、代码开发、测试到部署——所有工作都由 Kiro（来自 AWS 的 AI IDE）完成，零手写代码。

这不是”AI 辅助开发”，而是真正的 AI 驱动开发——人类描述意图并验收结果，Kiro 负责从意图到代码的整条流水线。

规格驱动开发（Spec-Driven Development）：从模糊想法到可执行任务#

Kiro 的核心工作流是规格驱动开发（Spec-Driven Development）。你用自然语言描述想要什么，Kiro 会自动生成一份三层规格：

第一步：需求文档

我们告诉 Kiro：“构建一个以交付为核心的 AI Agent 平台，用户与 Agent 对话，Agent 产出图片、视频、文档和网页。后端使用 FastAPI + Strands Agents，部署在 AgentCore Runtime 上。”

Kiro 自动生成了一份结构化的需求文档，包含用户故事、验收标准和技术约束：

### Requirement 1: User Authentication
**User Story:** As a user, I want to sign in with my Google account,
so that I can securely access my personal workspace and deliverables.

### Requirement 3: Agent Tool Integration
**User Story:** As a user, I want the Agent to execute code, browse web,
generate images/videos, and deploy web pages...

Kiro 规格驱动开发生成结构化需求，包含用户故事、验收标准和技术约束。

第二步：技术设计

确认需求后，Kiro 生成一份技术设计文档——数据库 schema、API 定义、组件架构、时序图：

## Architecture
The architecture follows a three-tier design:
1. Frontend: React-based SPA for user interaction
2. Backend API: FastAPI server handling authentication and API routing
3. Agent Runtime: Strands Agent deployed on AgentCore Runtime

Kiro 生成技术设计，涵盖系统架构、数据库 schema、API 定义和组件交互时序。

第三步：任务拆解

设计完成后，Kiro 把整个项目拆解为增量式的可执行任务，每个任务都关联到对应的需求：

- [x] 1.1 Initialize frontend project with React, TypeScript, and TailwindCSS
- [x] 1.2 Initialize backend project with FastAPI
- [x] 1.3 Set up database schemas and connections
- [x] 1.4 Set up Redis connection and utilities
- [x] 2.1 Implement Google OAuth authentication flow
- [x] 3.1 Implement Strands Agent with BedrockModel
- [x] 3.2 Implement Code Interpreter tool with AgentCore
...

Kiro 生成关联到需求的增量式任务，逐个执行直至全部完成。

随后 Kiro 逐个执行这些任务——编写代码、创建文件、配置依赖、运行测试——直到全部完成。

Vibe Coding：对话式迭代开发#

除了规格驱动的结构化开发之外，日常的功能迭代和 bug 修复采用 Vibe Coding——用自然语言向 Kiro 描述需求，它立即修改代码。

例如：

• “在 Library 页面添加文件预览功能”
• “Agent 生成架构图时使用 AWS 官方 SVG 图标”
• “WebSocket 断开后自动重连，最多重试 3 次”

Kiro 通过 Steering Files（架构文档和技术栈描述）理解项目上下文，并定位到需要修改的正确文件。

Steering Files：让 AI 掌握全局#

Kiro 编写代码时的准确性来自 Steering Files——放置在 .kiro/steering/ 目录下的项目上下文文档。我们配置了四份核心文档，确保 Kiro 始终遵循项目的架构模式和编码规范。

Hooks：自动化质量保障#

Kiro 的 Hooks 机制实现了自动化质量检查：

• API Test Hook：当 routers/、schemas/ 或 services/ 下的文件被修改时，自动运行 Postman 集合测试
• Structure Sync Hook：当创建新文件时，自动更新 structure.md 以保持文档同步

{
  "name": "API Postman Testing",
  "when": {
    "type": "fileEdited",
    "patterns": ["backend/app/routers/*.py", "backend/app/schemas/*.py"]
  },
  "then": {
    "type": "askAgent",
    "prompt": "API source code has been modified. Run Postman collection tests..."
  }
}

MCP Server 集成：实时访问文档#

在开发过程中，Strands Agents 和 AgentCore 都是快速迭代中的服务。我们配置了 Model Context Protocol (MCP) Servers，让 Kiro 能够实时访问最新的官方文档：

• Strands Agents MCP Docs Server——最新的 SDK API 文档、工具开发指南、部署示例
• AgentCore MCP Docs Server——最新的 Runtime、Memory、Code Interpreter 和 Browser 文档

Kiro 配置了 Strands Agents Docs 和 AgentCore Docs 的 MCP Servers，确保实时参考最新官方文档。

这意味着当 Kiro 编写 Agent 代码时，它参考的是实时的官方文档，而不是可能已经过时的训练数据。

开发效率：用天数取代月数#

如果按传统方式构建，这个项目需要一支 3-5 人的团队工作 2-3 个月。而借助 Kiro，一个人在一周内完成了从零到生产部署的整条流水线。

整体架构#

平台架构——用户请求经 CloudFront 进入 VPC，通过 ALB 到达运行在 ECS Fargate 上的 FastAPI 后端，Agent 通过 Bedrock AgentCore 调用 LLM 和工具，交付成果存储在 S3 中。

整个架构运行在 AWS Cloud 之内，VPC 划分为三层子网（Public / Private / Isolated）。Bedrock AgentCore 提供 Runtime 自动扩缩容、Memory 持久化、Code Interpreter 沙箱化和托管的 Browser。Amazon Bedrock 作为 LLM 平台，提供 Claude、Amazon Nova、Stability AI、Luma 等多种模型。

运行时第 1 层：Strands Agents——Agent 框架#

为什么选 Strands？#

在评估了多个 Agent 框架之后，我们选择 Strands Agents 的理由很简单：足够轻量，足够灵活。工具就是带 @tool 装饰器的 Python 方法。框架负责处理 Agent Loop、会话管理和模型调用。无需定义复杂的图结构，也不用学习专有的 DSL。

Strands Agents SDK 原生支持 Amazon Bedrock 作为模型提供方，这意味着我们可以直接使用 Bedrock 上的 Claude、Amazon Nova、Stability AI、Luma 等模型，无需额外的适配层。

核心 Agent 实现#

Agent 的初始化代码极其简洁：

from strands import Agent
from strands.models import BedrockModel
from strands.agent.conversation_manager import SlidingWindowConversationManager

class MyAgent:
    def __init__(self, user_id: str, conversation_id: str, config: AgentConfig):
        # Initialize model via Amazon Bedrock
        self.model = BedrockModel(
            model_id="us.anthropic.claude-sonnet-4-6",
            region_name="us-west-2",
            temperature=0.7,
            max_tokens=128000,
        )

        # Load tools — core tools always loaded, domain tools loaded per user's enabled Skills
        self.tools = get_agent_tools(
            user_id=user_id,
            conversation_id=conversation_id,
            config=config,
        )

        # Create Strands Agent
        self.agent = Agent(
            model=self.model,
            tools=self.tools,
            system_prompt=config.system_prompt,
            conversation_manager=SlidingWindowConversationManager(window_size=35),
        )

SlidingWindowConversationManager 是长对话的关键——它只保留最近 N 轮上下文，在维持对话连贯性的同时防止 token 溢出。

工具模式：@tool 装饰器#

每个工具都遵循”类方法 + @tool 装饰器”的模式：

from strands import tool

class CodeInterpreterTool:
    def __init__(self, region: str, user_id: str, conversation_id: str):
        self.region = region
        self.user_id = user_id

    @tool
    def execute_code(self, code: str, language: str = "python") -> str:
        """Execute code in a secure sandbox. Supports Python, JavaScript, and Shell.

        Args:
            code: The code to execute
            language: Programming language (python, javascript, shell)
        """
        # Executes via Amazon Bedrock AgentCore Code Interpreter — isolated sandbox
        ...

docstring 会自动成为 LLM 看到的工具描述，而类型注解会成为参数 schema。其余的一切——参数序列化、响应解析、把结果注入 Agent Loop——都由 Strands Agents 处理。

我们用这个模式构建了 15 个以上的工具。

动态工具加载：Skills 系统#

并非每个用户都需要每个工具。我们构建了一套 Skills 系统，根据用户启用的 Skill 动态加载工具：

# Core tools — always loaded
tools = [code_interpreter, browser, web_search, file_ops, ...]

# Domain tools — loaded only when corresponding Skills are enabled
requested = set(domain_tool_names or [])
if "aws_pricing" in requested:
    tools.append(AWSPricingTool(region=config.aws_region).query_price)
if "architecture_diagram" in requested:
    tools.extend([arch.generate_diagram, arch.modify_diagram, arch.list_aws_icons])

工具越少，LLM 的决策越准确。这是我们在实践中得到的一条重要经验。

运行时第 2 层：Amazon Bedrock AgentCore——运行时、记忆与沙箱#

Amazon Bedrock AgentCore 提供了三项核心能力，若从零构建每一项都需要数月时间：无服务器运行时、持久化记忆和安全的代码执行沙箱。

Amazon Bedrock AgentCore——为生产级 Agent 运行提供 Runtime、Memory、Code Interpreter 和 Browser 能力。

AgentCore Runtime：同一份代码，从开发到生产#

AgentCore Runtime——将 Agent 代码部署到 Runtime，即可获得自动容器编排、弹性扩缩容、会话管理和健康检查。

架构中最优雅的部分是双执行模式。AgentCore Runtime 入口只需要：

from bedrock_agentcore import BedrockAgentCoreApp
from bedrock_agentcore.runtime.context import RequestContext

app = BedrockAgentCoreApp()

@app.entrypoint
async def invoke(payload: dict, context: RequestContext):
    """AgentCore Runtime HTTP SSE streaming entry point"""
    user_id = payload.get("user_id", context.session_id)
    conversation_id = payload.get("conversation_id", context.session_id)

    agent = MyAgent(user_id=user_id, conversation_id=conversation_id)

    async for event in agent.process_message(payload["prompt"]):
        yield event  # Server-Sent Events streaming back to caller

if __name__ == "__main__":
    app.run()

AgentCore Runtime 负责处理容器编排、自动扩缩容、健康检查和会话管理。部署只需：

# Build and push container to Amazon ECR
docker build --platform linux/arm64 -t $ECR_URI:latest -f Dockerfile.agentcore .
docker push $ECR_URI:latest

# Update AgentCore Runtime
aws bedrock-agentcore-control update-agent-runtime \
    --agent-runtime-id $AGENT_ID \
    --agent-runtime-artifact '{"containerConfiguration":{"containerUri":"'$ECR_URI':latest"}}'

FastAPI 一侧只需一个环境变量即可切换模式：

if settings.agentcore_runtime_enabled:
    # Production: stream via AgentCore Runtime (HTTP SSE)
    async for event in agentcore_service.invoke_stream(payload):
        await websocket.send_json(event)
else:
    # Development: Agent runs directly in-process
    async for event in agent.process_message(message):
        await websocket.send_json(event)

本地开发使用 agentcore launch --local 启动一个本地 Runtime 实例，体验与生产环境完全一致。

AgentCore Memory：跨会话记忆#

Amazon Bedrock AgentCore Memory 提供两种持久化能力：

• 短期记忆（Short-Term Memory）——以事件形式存储最近的对话内容，并自动过期
• 长期记忆（Long-Term Memory）——通过语义方式抽取并存储关于用户的关键事实，用于跨会话的个性化

AgentCore Memory——短期记忆存储最近的对话事件并自动过期，长期记忆通过语义抽取持久化关键的用户事实。

与 Strands Agents 的集成通过 SDK 的 Session Manager 实现：

from bedrock_agentcore.memory.integrations.strands.session_manager import (
    AgentCoreMemorySessionManager,
)
from bedrock_agentcore.memory.integrations.strands.config import (
    AgentCoreMemoryConfig,
    RetrievalConfig,
)

memory_config = AgentCoreMemoryConfig(
    memory_id="my_agent_memory_id",
    region="us-west-2",
    retrieval_config=RetrievalConfig(max_results=20, retrieval_type="SEMANTIC"),
)

session_manager = AgentCoreMemorySessionManager(config=memory_config)

# Pass to Strands Agent — auto-handles persistence and context retrieval
agent = Agent(model=self.model, tools=self.tools, session_manager=session_manager)

Session Manager 会自动持久化每一轮对话。当新会话开始时，它会自动检索相关上下文。用户第二天再回来，Agent 依然记得之前的上下文。

AgentCore Code Interpreter：安全沙箱#

当用户提出”分析这个 CSV”或”运行这段 Python 脚本”时，我们需要一个隔离的执行环境。AgentCore Code Interpreter 提供临时沙箱，预装了 pandas、matplotlib、numpy 等数据科学库。每次执行都运行在隔离的沙箱中，不会跨用户污染，并会自动清理。

Agent 在 AgentCore Code Interpreter 隔离沙箱中执行 Python 代码，生成数据分析图表。

AgentCore Browser：浏览器操作#

网页抓取、表单填写和实时浏览都通过 AgentCore Browser 处理，它提供托管的 Chrome 实例，供 Agent 以编程方式控制。结合 Amazon DCV 流式传输，用户甚至可以在 UI 中实时观看 Agent 浏览网页。

AgentCore Browser——Agent 通过 API 控制托管的 Chrome 实例，结果以截图或 DCV 方式流式返回。

Agent 通过 AgentCore Browser 浏览网页，用户在嵌入的浏览器窗口中实时观看。

运行时第 3 层：AWS 基础设施——全程 CDK#

整个基础设施都定义在单个 AWS CDK Stack 中——可复现、可版本控制。

核心基础设施#

// VPC with three subnet tiers: public, private, isolated
const vpc = new ec2.Vpc(this, 'Vpc', {
    maxAzs: 2,
    natGateways: 1,  // Cost optimization: single NAT Gateway
    subnetConfiguration: [
        { name: 'Public', subnetType: ec2.SubnetType.PUBLIC },
        { name: 'Private', subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
        { name: 'Isolated', subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
    ],
});

// RDS MySQL 8.4 in isolated subnet — no internet access
const mysql = new rds.DatabaseInstance(this, 'Mysql', {
    engine: rds.DatabaseInstanceEngine.mysql({
        version: rds.MysqlEngineVersion.VER_8_4_7,
    }),
    instanceType: ec2.InstanceType.of(ec2.InstanceClass.T4G, ec2.InstanceSize.MICRO),
    vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
});

// ElastiCache Redis 7.1 for sessions and caching
const redis = new elasticache.CfnCacheCluster(this, 'Redis', {
    cacheNodeType: 'cache.t4g.micro',
    engine: 'redis',
    engineVersion: '7.1',
});

服务层#

FastAPI 后端运行在 Application Load Balancer 后面的 ECS Fargate 上。React 前端通过 CloudFront 从 S3 提供服务。这种分离意味着前端部署大约只需 1 分钟（S3 sync + CloudFront 失效刷新），而后端部署则是独立的滚动更新。

CloudFront (app.example.com)  → S3 (React SPA)
CloudFront (docs.example.com) → S3 (Knowledge Portal)
ALB (api.example.com)         → ECS Fargate (FastAPI)

一键部署#

./deploy.sh all          # Full deploy (infrastructure + frontend)
./deploy.sh frontend     # Frontend only (~1 minute)
./deploy.sh backend      # ECS rolling update (~10s to trigger)
./deploy.sh agent        # Deploy AgentCore Runtime Agent
./deploy.sh status       # Show current endpoints

平台能力#

交付成果管理#

Agent 产出的所有文件——图片、文档、代码、已部署的页面——都存储在 S3 中，并通过 Library 页面统一管理。

Library 页面——统一管理所有 Agent 交付成果，支持按类型筛选、在线预览和一键下载。

架构图生成#

Agent 使用 AWS 官方图标生成 Draw.io 格式的架构图，支持在线查看和编辑。

Agent 生成的架构图，采用 AWS 官方 SVG 图标，Draw.io 格式。

网页部署#

Agent 可以将生成的 HTML/CSS/JS 直接部署到 S3 + CloudFront，为用户提供一个可分享的公开 URL。

Agent 在对话中接收需求、生成代码，并一键完成部署。

已部署页面通过 S3 + CloudFront 提供可分享的公开 URL，实现端到端交付。

图片与视频生成#

通过 Amazon Bedrock 上的 Stability AI 和 Luma AI 模型，Agent 可以直接生成图片和视频。

Agent 通过 Amazon Bedrock 上的 Stability AI SD3.5 生成图片，结果内嵌显示在对话中。

经验教训#

1. 让 LLM 来决策——不要过度编排#

早期我们尝试构建僵硬的工作流——“如果用户询问价格，就路由到定价工具”。这很脆弱，无法应对含糊的请求。Strands Agents 的 Agent Loop 方式效果更好：给 LLM 提供工具和一个优秀的 System Prompt，让它自己决定编排顺序。模型在选择工具序列方面出人意料地擅长。

2. 工具越少，决策越好#

一开始我们为每次对话都加载全部 15 个以上的工具。当面对过多选项时，LLM 偶尔会选错工具。基于 Skills 的动态加载解决了这个问题——用户启用所需的 Skill，只加载相关的工具。

3. 双执行模式是杀手级特性#

同一份 Agent 代码在本地（Direct 模式）和生产环境（AgentCore 模式）运行，消除了一整类”在我机器上没问题”的 bug。这层抽象的成本极低——只是 WebSocket 处理器里的一个条件判断。

4. 流式输出不可妥协#

Agent 任务可能耗时数分钟（生成视频、执行复杂代码、浏览多个页面）。如果没有 WebSocket 实时流式输出，用户只能盯着空白屏幕。我们把每一个事件都流式传出——思考、工具选择、工具结果、文件创建——让用户始终知道正在发生什么。

5. 记忆让 Agent 真正智能#

没有 AgentCore Memory，每次对话都从零开始。有了它，Agent 会记住用户偏好、过往的交付成果和正在进行的项目。这把体验从”使用一个工具”升级为”与一位助手协作”。

快速上手#

如果你也想构建一个类似的平台，这里是最短路径。我们推荐使用 Kiro 作为开发工具——规格驱动开发自动生成需求、设计和任务，然后用 Vibe Coding 逐步实现。

1. 搭建一个 Strands Agent#

pip install strands-agents strands-agents-tools
from strands import Agent, tool
from strands.models import BedrockModel

@tool
def my_tool(query: str) -> str:
    """Search for information."""
    return f"Results for: {query}"

agent = Agent(
    model=BedrockModel(
        model_id="us.anthropic.claude-sonnet-4-6",
        region_name="us-west-2",
    ),
    tools=[my_tool],
)
response = agent("Help me look up the latest EC2 pricing")

2. 接入 AgentCore Runtime#

pip install bedrock-agentcore
from bedrock_agentcore import BedrockAgentCoreApp

app = BedrockAgentCoreApp()

@app.entrypoint
async def invoke(payload: dict, context):
    agent = Agent(model=model, tools=tools)
    result = agent(payload["prompt"])
    yield {"type": "text", "data": {"content": str(result)}}

if __name__ == "__main__":
    app.run()

# Local testing
# agentcore configure --entrypoint app.py --name my_agent
# agentcore launch --local

# Deploy to production
# agentcore deploy

3. 用 AWS CDK 部署基础设施#

import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as rds from 'aws-cdk-lib/aws-rds';

const vpc = new ec2.Vpc(this, 'Vpc', { maxAzs: 2 });
const cluster = new ecs.Cluster(this, 'Cluster', { vpc });
const db = new rds.DatabaseInstance(this, 'DB', {
  engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0 }),
  vpc,
});
// ECS Fargate Service, ALB, CloudFront, ElastiCache...

单个 CDK Stack 定义了 VPC、ECS Fargate、RDS、ElastiCache、ALB、CloudFront 以及所有其他生产基础设施。执行 npx cdk deploy 即可一键部署。

结语#

构建一个企业级的 Agentic AI 平台曾经需要数月的基础设施工作——容器编排、沙箱执行、记忆系统、自动扩缩容。如今，整条流水线都可以由 AI 驱动：

• Kiro 承担完整的开发生命周期——规格驱动开发生成结构化规格，Vibe Coding 负责日常迭代，MCP Servers 提供实时文档
• Strands Agents 提供简洁的工具抽象和 Agent Loop，让我们专注于工具能力而非框架细节
• Amazon Bedrock AgentCore 提供运行时、记忆和沙箱，省去了数月的基础设施自建
• AWS CDK 让整个基础设施可复现、可版本控制、可一键部署

这不只是”用 AI 辅助开发”——而是用 AI 构建 AI。Kiro 作为开发者，构建了一个为用户交付成果的 AI Agent 平台。从一个模糊的产品想法到生产部署：一个人，一周时间，零手写代码。

源代码#

本文引用的完整项目代码已开源：

• GitHub 仓库：aws-samples/sample-for-bedrock-agentcore-strands-agents

参考资料#

Kiro (AI IDE)#

• Kiro 官方网站 — 来自 AWS 的 AI IDE，具备规格驱动开发和 Vibe Coding
• Kiro 文档 — Steering Files、Hooks、MCP 集成指南

Strands Agents#

• Strands Agents 快速入门 — 20 分钟构建你的第一个 Agent
• 自定义工具开发 — @tool 装饰器模式
• 部署到 AgentCore Runtime — 完整部署示例

Amazon Bedrock AgentCore#

• AgentCore Runtime 概览 — Runtime SDK 架构
• AgentCore Runtime 部署 — 从本地测试到生产
• AgentCore Code Interpreter — 安全代码沙箱
• AgentCore Browser — 托管浏览器工具

AWS 基础设施#

• AWS CDK 开发者指南
• Amazon ECS on Fargate
• Amazon Bedrock 用户指南