AI

Engineering teams adopting the AI-Driven Development Lifecycle (AI-DLC) with Amazon Bedrock AgentCore and coding agents like Kiro often struggle with the gap between conceptual frameworks and working code. Amazon Bedrock AgentCore is a service for building, connecting, and optimizing agents at scale with any framework or model. AI-DLC positions AI as a central collaborator across the software development lifecycle, handling routine execution while humans retain oversight of critical decisions. This post closes that gap with working reference implementations.

This post walks through the architecture, design decisions, and key code patterns behind two reference implementations that demonstrate AI-DLC construction phase patterns using Amazon Bedrock AgentCore, Kiro, and local agentic coding tools. The first generates Mermaid entity relationship diagrams from SQL schemas using AgentCore runtime, a capability of Amazon Bedrock AgentCore. The second provides automated code security analysis through a multi-agent architecture that uses AgentCore Gateway, a capability of Amazon Bedrock AgentCore, and AgentCore memory, a capability of Amazon Bedrock AgentCore, along with external tool integrations. Together, they illustrate how to structure AI-driven workflows that maintain human-in-the-loop governance while accelerating delivery. Both implementations link to complete deployment instructions in their respective GitHub repositories.

AI-DLC construction patterns in practice

The AI-DLC construction phase positions AI to propose architecture, generate implementation plans, produce code, and create deployment artifacts, with team members providing clarification on technical decisions in real time. The implementations described here map directly to this pattern:

Both systems share a common architectural foundation built on AgentCore, demonstrating how teams can compose AI-driven workflows from modular, manageable components.

Solution 1: SQL schema to ER diagram generation

This AWS Samples project auto-generates Mermaid ER diagrams from SQL schema files using an agentic AI workflow on Amazon Bedrock AgentCore. After SQL code is checked in by developers, the Amazon Simple Storage Service (Amazon S3) trigger and AWS Lambda function-based workflow invokes the AgentCore runtime, which parses the data definition language (DDL) to produce an .mmd diagram saved back to Amazon S3. It reads only schema metadata (tables, constraints, and foreign keys), never row data, making it a clean reference for schema-to-diagram automation.

Database teams managing evolving SQL schemas need current entity relationship documentation. Manual creation of ER diagrams is time-intensive and documentation frequently drifts from the actual schema. When schema changes land through pull requests, teams need updated diagrams without adding manual documentation steps to the development workflow.

The system uses a serverless, event-driven architecture with the following components:

Figure 1: Event-driven architecture for SQL schema to ER diagram generation

The workflow proceeds as follows:

The agent implementation uses the BedrockAgentCoreApp runtime wrapper with the @app.entrypoint decorator to register the handler:

The complete implementation, including OpenAI Codex skills and MCP server integration, is available in the sample-to-create-mermaid-entity-diagrams-from-sql-using-agentic-ai-on-agentcore repository.

Solution 2: Secure software handoffs

This serverless code security analysis solution uses Amazon Bedrock AgentCore to automatically scan Python or Java code for security vulnerabilities, CVE risks in dependencies, and policy violations. The analysis is triggered when code is pushed from a GitLab pipeline to Amazon S3. A Strands-based agent then evaluates the code using Anthropic Claude Sonnet models on Amazon Bedrock. It calls Model Context Protocol (MCP) tools that run on AWS Lambda for CVE and policy checks. (For model availability by Region, see Regional availability by models.) Results, including quality scores from 1 to 10 and recommendations, are stored in AgentCore memory with semantic search and surfaced through a real-time, session-based web dashboard. Amazon Cognito provides authentication, and AgentCore Observability, a capability of Amazon Bedrock AgentCore, and Amazon CloudWatch provide monitoring.

Code reviews for security compliance require specialized knowledge across CVE databases, organizational coding policies, and language-specific security patterns. Manual security reviews create bottlenecks in delivery pipelines, and inconsistent application of standards across teams leads to variable code quality.

This solution provides automated code security analysis through a multi-agent architecture for secure software handoffs between development stages:

Figure 2: Multi-agent architecture for automated code security analysis

To learn more, see AgentCore memory strategies.

The analysis agent follows the same AgentCore runtime pattern as Solution 1, with the addition of MCP tool calls routed through AgentCore Gateway:

The agent receives code content from the AWS Lambda trigger, performs multi-dimensional analysis using the foundation model (FM), then invokes external tools (policy checker, CVE scanner) through AgentCore Gateway as needed. Results are persisted to AgentCore memory for dashboard retrieval and historical comparison.

The complete implementation is available in the sample-agentic-secure-software-handoffs repository.

Integrating local agentic tools: Kiro, OpenAI ChatGPT Codex and Claude Code

While AgentCore provides the cloud runtime for deployed, event-driven agent workloads, the development workflow itself benefits from local agentic tools that implement AI-DLC patterns at the developer’s workstation.

Kiro supports the AI-DLC inception and construction phases through structured specifications and custom agent skills:

The repository also includes an OpenAI Codex integration that demonstrates how the same ER diagram generation workflow extends to additional coding agents through MCP and custom skills:

Claude Code operates as a local command-line agent that complements AgentCore deployments:

A typical AI-DLC bolt (short, intense work cycle) using these tools follows this pattern:

Based on implementing these systems, we recommend the following practices:

The AI-DLC methodology becomes practical when backed by concrete implementation patterns. Amazon Bedrock AgentCore provides the runtime infrastructure (containerized agents, persistent memory, secure gateways, and external tool integration) while local tools like Kiro and Claude Code accelerate the development workflow itself.

Start with the SQL-to-ER-Diagram sample to deploy your first AgentCore agent. Follow the deployment scripts in sequence, then extend the pattern with multi-agent coordination, MCP tool integrations, and CI/CD-driven triggers using the Secure software handoffs sample.

To go deeper, see Move your AI agents from proof of concept to production with Amazon Bedrock AgentCore for a complementary walkthrough of taking agents to production scale. For full-service details, API references, and configuration guidance, refer to the Amazon Bedrock AgentCore documentation.