AI-driven growth lifecycle utilizing Amazon Bedrock AgentCore

Engineering groups adopting the AI-Pushed Growth Lifecycle (AI-DLC) with Amazon Bedrock AgentCore and coding brokers like Kiro usually wrestle with the hole between conceptual frameworks and dealing code. Amazon Bedrock AgentCore is a service for constructing, connecting, and optimizing brokers at scale with any framework or mannequin. AI-DLC positions AI as a central collaborator throughout the software program growth lifecycle, dealing with routine execution whereas people retain oversight of important choices. This submit closes that hole with working reference implementations.

This submit walks via the structure, design choices, and key code patterns behind two reference implementations that show AI-DLC building part patterns utilizing Amazon Bedrock AgentCore, Kiro, and native agentic coding instruments. The primary generates Mermaid entity relationship diagrams from SQL schemas utilizing AgentCore runtime, a functionality of Amazon Bedrock AgentCore. The second offers automated code safety evaluation via a multi-agent structure that makes use of AgentCore Gateway, a functionality of Amazon Bedrock AgentCore, and AgentCore reminiscence, a functionality of Amazon Bedrock AgentCore, together with exterior device integrations. Collectively, they illustrate how you can construction AI-driven workflows that keep human-in-the-loop governance whereas accelerating supply. Each implementations hyperlink to finish deployment directions of their respective GitHub repositories.

AI-DLC building patterns in observe

The AI-DLC building part positions AI to suggest structure, generate implementation plans, produce code, and create deployment artifacts, with workforce members offering clarification on technical choices in actual time. The implementations described right here map on to this sample:

Automated artifact era: An agent receives structured enter (SQL schema information), creates an in depth plan, generates output (Mermaid ER diagrams), and shops outcomes for human overview.
Steady code high quality enforcement: A multi-agent system analyzes code pushed via steady integration and steady supply (CI/CD) pipelines, producing safety assessments, Widespread Vulnerabilities and Exposures (CVE) checks, and coverage compliance stories that inform human decision-making.

Each programs share a typical architectural basis constructed on AgentCore, demonstrating how groups can compose AI-driven workflows from modular, manageable parts.

Answer 1: SQL schema to ER diagram era

This AWS Samples undertaking auto-generates Mermaid ER diagrams from SQL schema information utilizing an agentic AI workflow on Amazon Bedrock AgentCore. After SQL code is checked in by builders, the Amazon Easy Storage Service (Amazon S3) set off and AWS Lambda function-based workflow invokes the AgentCore runtime, which parses the information definition language (DDL) to provide an .mmd diagram saved again to Amazon S3. It reads solely schema metadata (tables, constraints, and international keys), by no means row information, making it a clear reference for schema-to-diagram automation.

Enterprise problem

Database groups managing evolving SQL schemas want present entity relationship documentation. Guide creation of ER diagrams is time-intensive and documentation ceaselessly drifts from the precise schema. When schema adjustments land via pull requests, groups want up to date diagrams with out including handbook documentation steps to the event workflow.

Structure

The system makes use of a serverless, event-driven structure with the next parts:

An Amazon S3 upload triggers a Lambda function that invokes an AgentCore agent to generate a Mermaid ER diagram

Determine 1: Occasion-driven structure for SQL schema to ER diagram era

S3 occasion set off: SQL information uploaded to an Amazon S3 bucket set off an AWS Lambda perform that initiates the evaluation workflow.
Authentication: Amazon Cognito offers OAuth2 machine-to-machine (M2M) authentication. Consumer credentials are saved in AWS Methods Supervisor Parameter Retailer.
AgentCore runtime: A containerized agent constructed with the Strands framework runs on AgentCore runtime. The agent makes use of Claude Sonnet 4 via Amazon Bedrock to parse SQL DDL statements and generate Mermaid ER diagram syntax. (For mannequin availability by AWS Area, see Regional availability by fashions.)
AgentCore reminiscence: Offers persistent session context with a 90-day expiry, and helps semantic search throughout earlier analyses and incremental schema understanding.
Output storage: Generated .mmd diagram information are saved to Amazon S3 below a devoted prefix, with metadata monitoring the supply file and era timestamp.

The workflow proceeds as follows:

A SQL file is uploaded to Amazon S3 (manually or via a CI/CD pipeline).
The Lambda set off reads the file content material and authenticates via Cognito OAuth.
The set off invokes the AgentCore runtime agent with the SQL content material because the payload.
The agent analyzes the schema and identifies tables, columns, constraints, and international key relationships. It then generates a whole Mermaid erDiagram.
The diagram is saved to Amazon S3 and the evaluation session is saved in AgentCore reminiscence.

Implementation particulars

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

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from bedrock_agentcore.reminiscence import MemoryClient
from strands import Agent
from strands.fashions import BedrockModel

app = BedrockAgentCoreApp()
mannequin = BedrockModel(model_id="us.anthropic.claude-sonnet-4-5-20250929-v1:0", region_name="us-west-2")
erdiagram_agent = Agent(mannequin=mannequin)
memory_client = MemoryClient(region_name="us-west-2")

@app.entrypoint
async def generate_er_diagram(payload: Dict[str, Any]) -> Dict[str, Any]:
    sql_content = payload.get("sql_content", "")
    file_name = payload.get("file_name", "unknown_file.sql")
    # Generate diagram, retailer in reminiscence, save to S3
    ...

Key design choices embrace:

Chunked processing: Giant SQL information are break up into manageable segments, analyzed independently, then consolidated right into a unified diagram. This handles schemas with a whole bunch of tables with out exceeding context limits.
Structured prompting: The agent makes use of a scientific evaluation immediate that extracts tables, columns, information sorts, main keys, and international key relationships earlier than producing diagram syntax.
OpenTelemetry tracing: Each step is instrumented with spans and attributes, offering observability into processing period, chunk counts, and error attribution.

The entire implementation, together with OpenAI Codex expertise and MCP server integration, is on the market within the sample-to-create-mermaid-entity-diagrams-from-sql-using-agentic-ai-on-agentcore repository.

Answer 2: Safe software program handoffs

This serverless code safety evaluation answer makes use of Amazon Bedrock AgentCore to routinely scan Python or Java code for safety vulnerabilities, CVE dangers in dependencies, and coverage violations. The evaluation is triggered when code is pushed from a GitLab pipeline to Amazon S3. A Strands-based agent then evaluates the code utilizing Anthropic Claude Sonnet fashions on Amazon Bedrock. It calls Mannequin Context Protocol (MCP) instruments that run on AWS Lambda for CVE and coverage checks. (For mannequin availability by Area, see Regional availability by fashions.) Outcomes, together with high quality scores from 1 to 10 and proposals, are saved in AgentCore reminiscence with semantic search and surfaced via a real-time, session-based net dashboard. Amazon Cognito offers authentication, and AgentCore Observability, a functionality of Amazon Bedrock AgentCore, and Amazon CloudWatch present monitoring.

Enterprise problem

Code critiques for safety compliance require specialised data throughout CVE databases, organizational coding insurance policies, and language-specific safety patterns. Guide safety critiques create bottlenecks in supply pipelines, and inconsistent utility of requirements throughout groups results in variable code high quality.

Structure

This answer offers automated code safety evaluation via a multi-agent structure for safe software program handoffs between growth phases:

Uploaded code is analyzed by an AgentCore agent that calls policy-check and CVE-scanner tools through AgentCore Gateway

Determine 2: Multi-agent structure for automated code safety evaluation

Code information are uploaded to an Amazon S3 bucket (manually or via a CI/CD pipeline). An AWS Lambda set off detects new uploads and initiates the AgentCore evaluation workflow with OAuth2 authentication.
AgentCore Gateway with MCP instruments: The gateway orchestrates calls to exterior device integrations:
1. Coverage Test Lambda: Validates code in opposition to organization-specific safety insurance policies.
2. CVE Database Test Lambda: Scans dependency information for identified vulnerabilities.
AgentCore runtime (Strands framework): The core evaluation agent performs deep code overview, together with construction evaluation, logic high quality analysis, reminiscence and efficiency evaluation, safety situation detection, and greatest practices compliance.
AgentCore reminiscence: Shops evaluation outcomes with semantic search capabilities, supporting historic comparability and pattern evaluation.
Dashboard Lambda: Serves an internet UI that gives session-based outcomes with search and multi-tab navigation throughout information, violations, and high quality metrics.

Key capabilities

The evaluation agent follows the identical AgentCore runtime sample as Answer 1, with the addition of MCP device calls routed via AgentCore Gateway:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from bedrock_agentcore.reminiscence import AgentCoreMemory
from strands import Agent
from strands.fashions import BedrockModel

app = BedrockAgentCoreApp()
mannequin = BedrockModel(model_id="us.anthropic.claude-sonnet-4-5-20250929-v1:0", region_name="us-west-2")
analysis_agent = Agent(mannequin=mannequin, instruments=[analyze_code, check_quality])
reminiscence = AgentCoreMemory(namespace="code-analysis")

@app.entrypoint
async def analyze_uploaded_code(payload: Dict[str, Any]) -> Dict[str, Any]:
    file_content = payload.get("file_content", "")
    file_name = payload.get("file_name", "unknown.py")
    session_id = payload.get("session_id", "")
    # Analyze code, retailer ends in reminiscence, return high quality rating
    ...

The agent receives code content material from the AWS Lambda set off, performs multi-dimensional evaluation utilizing the inspiration mannequin (FM), then invokes exterior instruments (coverage checker, CVE scanner) via AgentCore Gateway as wanted. Outcomes are endured to AgentCore reminiscence for dashboard retrieval and historic comparability.

Key design choices embrace:

Multi-agent separation: The code evaluation agent focuses solely on high quality evaluation. Coverage checking and CVE scanning are delegated to devoted AWS Lambda capabilities invoked via AgentCore Gateway, maintaining every part single-purpose and independently updatable.
Session-based outcome persistence: Every evaluation run creates a singular session in AgentCore reminiscence. The dashboard retrieves outcomes by session ID, permitting builders to check high quality scores throughout a number of code submissions.
Gateway-mediated device invocation: Exterior instruments are registered via AgentCore Gateway utilizing MCP reasonably than direct invocation. This decouples the agent from device implementation particulars and permits new instruments to be added with out modifying agent code.

The entire implementation is on the market within the sample-agentic-secure-software-handoffs repository.

Whereas AgentCore offers the cloud runtime for deployed, event-driven agent workloads, the event workflow itself advantages from native agentic instruments that implement AI-DLC patterns on the developer’s workstation.

Kiro brokers and expertise

Kiro helps the AI-DLC inception and building phases via structured specs and customized agent expertise:

Spec-driven growth: Kiro transforms pure language necessities into structured specs with acceptance standards, then generates implementation plans from these specs. This maps on to the AI-DLC sample of AI creating plans and in search of human validation earlier than execution.
Customized expertise: Groups can outline reusable Kiro agent expertise that encode organizational requirements (coding patterns, safety necessities, architectural pointers), in order that AI-generated code constantly meets enterprise high quality bars.
Agentic process execution: Kiro’s agent mode handles multi-file implementation duties with autonomous device use (file creation, terminal instructions, search) whereas sustaining the human-in-the-loop overview at every specification checkpoint.

OpenAI ChatGPT Codex (MCP server and expertise)

The repository additionally consists of an OpenAI Codex integration that demonstrates how the identical ER diagram era workflow extends to extra coding brokers via MCP and customized expertise:

MCP server for dwell database schema entry: A neighborhood stdio-based MCP server connects Codex to MySQL or Amazon Aurora MySQL databases via INFORMATION_SCHEMA. The server exposes three instruments (schema_summary, generate_er_markdown, and generate_mermaid) that enable Codex to question desk constructions, columns, indexes, and international key relationships with out accessing desk row information.
Customized Codex ability: A SKILL.md file encodes the ER diagram era workflow as a reusable Codex ability, guiding the agent via schema evaluation and diagram creation with constant high quality.
Safe credential administration: Database credentials are retrieved from AWS Secrets and techniques Supervisor with TLS verification enforced, following the identical safety patterns used within the AgentCore implementation.

Claude Code (native agent)

Claude Code operates as an area command-line agent that enhances AgentCore deployments:

Speedy prototyping: Earlier than deploying to AgentCore runtime, builders use Claude Code to iterate on agent logic, check prompts, and validate device integration patterns regionally.
Infrastructure-as-code era: Claude Code generates deployment scripts, Dockerfiles, AWS Id and Entry Administration (IAM) insurance policies, and AWS CloudFormation templates. These artifacts observe architectural specs produced through the AI-DLC building part.
Code overview and refactoring: Native brokers carry out first-pass critiques in opposition to undertaking guidelines and customized directions, catching points earlier than code enters the CI/CD pipeline the place the safe software program handoff system offers the authoritative safety evaluation.

The mixed workflow

A typical AI-DLC bolt (quick, intense work cycle) utilizing these instruments follows this sample:

Inception (Kiro): Rework enterprise necessities into specs with acceptance standards. The workforce validates AI-generated specs in a mob elaboration session.
Development (Claude Code and Kiro): Generate implementation code, deployment scripts, and check suites. Native brokers deal with file era and iterative refinement whereas Kiro manages process orchestration.
Validation (AgentCore): Code pushed via CI/CD triggers automated safety evaluation. The multi-agent system offers a top quality evaluation earlier than merge.
Operations (AgentCore): Manufacturing brokers (just like the ER diagram generator) run repeatedly on AgentCore runtime, triggered by occasions, processing workloads at scale with full observability.

Finest practices

Based mostly on implementing these programs, we suggest the next practices:

Separate agent considerations: Design every agent with a single, well-defined duty. The ER diagram agent solely generates ER diagrams. Composability comes from orchestration, not from overloading particular person brokers.
Use AgentCore reminiscence for context continuity: Persistent reminiscence permits brokers to study from earlier interactions, examine present evaluation with historic baselines, and keep state throughout periods with out reprocessing.
Instrument with OpenTelemetry from day one: Tracing offers visibility into agent habits, processing period, and failure modes. That is important for debugging immediate effectiveness and figuring out efficiency bottlenecks.
Retailer configuration in Parameter Retailer: Decouple configuration from code. Cognito credentials, reminiscence IDs, mannequin alternatives, and bucket names ought to all be retrievable at runtime.
Implement chunked processing for giant inputs: Design brokers to deal with inputs that exceed mannequin context home windows by splitting, analyzing independently, and consolidating outcomes.
Safe with Cognito M2M authentication: Use OAuth2 consumer credentials move for service-to-service communication. Keep away from hardcoded credentials or long-lived tokens.
Combine via CI/CD, not handbook add: In manufacturing, join brokers to repository occasions (merge requests, pipeline phases) reasonably than requiring handbook file uploads. The S3 set off sample proven right here interprets on to GitLab webhook or GitHub Actions integration.
Apply Amazon Bedrock Guardrails for manufacturing agent outputs: Configure content material filtering insurance policies, denied subject detection, and grounding validation to verify agent-generated responses meet accountable AI requirements. For code evaluation brokers, guardrails can block outputs containing insecure code patterns or hallucinated CVE references. For diagram era brokers, grounding checks validate that outputs precisely mirror the supply schema. Mix guardrails with automated analysis pipelines to repeatedly monitor agent habits and flag drift from anticipated output high quality.

Conclusion

The AI-DLC methodology turns into sensible when backed by concrete implementation patterns. Amazon Bedrock AgentCore offers the runtime infrastructure (containerized brokers, persistent reminiscence, safe gateways, and exterior device integration) whereas native instruments like Kiro and Claude Code speed up the event workflow itself.

Begin with the SQL-to-ER-Diagram pattern to deploy your first AgentCore agent. Observe the deployment scripts in sequence, then prolong the sample with multi-agent coordination, MCP device integrations, and CI/CD-driven triggers utilizing the Safe software program handoffs pattern.

To go deeper, see Transfer your AI brokers from proof of idea to manufacturing with Amazon Bedrock AgentCore for a complementary walkthrough of taking brokers to manufacturing scale. For full-service particulars, API references, and configuration steering, consult with the Amazon Bedrock AgentCore documentation.