AWS Builder Center

Builder Center

Building Autonomous AI Agents on AWS: A Serverless Architecture with Amazon Bedrock, MCP & Zero-Cost Guardrails

Building Autonomous AI Agents on AWS: A Serverless Architecture with Amazon Bedrock, MCP & Zero-Cost Guardrails

Learn how to build production-grade, event-driven AI coding agents on AWS using Amazon Bedrock, Model Context Protocol (MCP), and AWS Step Functions, backed by strict FinOps spend guardrails.

Building Autonomous AI Agents on AWS: A Serverless Architecture with Amazon Bedrock, MCP & FinOps Guardrails

The era of static, prompt-response AI is rapidly evolving into Agentic AI: systems capable of reasoning, executing tool calls, maintaining state, and taking real-world infrastructure actions.
When building autonomous coding and DevOps agents on AWS, developers face three primary engineering challenges:
  1. Context & Tool Orchestration: How does an agent securely discover and invoke cloud APIs?
  2. State & Long-Running Operations: How do we manage multi-turn reasoning loops without paying for idle server compute?
  3. Financial Safety & Guardrails: How do we prevent autonomous tool-calling loops from generating unexpected cloud bills?
In this guide, we'll walk through a serverless architecture for deploying production-ready AI agents using Amazon Bedrock, Model Context Protocol (MCP), AWS Lambda, and AWS Step Functions.

🏗️ Architectural Overview

Our goal is to build an autonomous agent that can inspect cloud infrastructure, generate IaC (Terraform/CloudFormation), execute validation tests, and request human approval before applying changes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
+-------------------+ +------------------------+ +--------------------------+
| User / IDE CLI | --> | Amazon API Gateway | --> | AWS Step Functions |
+-------------------+ | (REST) | | (Agentic State Machine) |
+------------------------+ +--------------------------+
|
v
+--------------------------+
| Amazon Bedrock |
| (Claude / Amazon Nova) |
+--------------------------+
|
v
+--------------------------+
| MCP Tool Gateway |
| (Lambda / Fargate) |
+--------------------------+
|
+-------------------------------------------+-------------------------+
| | |
v v v
+--------------------+ +--------------------+ +--------------------+
| Amazon S3 (State) | | DynamoDB (Memory) | | CloudWatch Logs |
+--------------------+ +--------------------+ +--------------------+

Key Components

  • Reasoning Engine: Amazon Bedrock (Anthropic Claude or Amazon Nova) for high-reasoning tool selection.
  • Tool Standard: Model Context Protocol (MCP) server running as a serverless container on AWS Lambda / AWS Fargate.
  • Orchestration: AWS Step Functions handling turn-by-turn state persistence, retry logic, and human-in-the-loop approvals. Use Standard Workflows for long-running flows with human approval (Express Workflows do not support the callback pattern).
  • Guardrails: AWS Budgets + Cost Anomaly Detection paired with IAM least-privilege roles.

💡 Step 1: Standardizing Tool Invocation with MCP

The Model Context Protocol (MCP) is an open standard for connecting AI models to external tools and data stores. Instead of hardcoding API integrations inside your application, MCP abstracts AWS service interactions into standardized tool definitions.
Here is a Python Lambda example defining a tool execution handler for AWS infrastructure inspection:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import json
import boto3

s3_client = boto3.client("s3")
ec2_client = boto3.client("ec2")


def lambda_handler(event, context):
"""
Standardized MCP-style tool execution handler
"""
tool_name = event.get("tool_name")
arguments = event.get("arguments", {})

if tool_name == "inspect_ec2_instances":
response = ec2_client.describe_instances()
instances = []
for reservation in response.get("Reservations", []):
for instance in reservation.get("Instances", []):
instances.append({
"InstanceId": instance["InstanceId"],
"State": instance["State"]["Name"],
"Type": instance["InstanceType"],
})
return {"status": "success", "data": instances}

elif tool_name == "check_s3_bucket_policy":
bucket_name = arguments.get("bucket_name")
policy = s3_client.get_bucket_policy(Bucket=bucket_name)
return {"status": "success", "policy": json.loads(policy["Policy"])}

else:
return {"status": "error", "message": f"Unknown tool: {tool_name}"}

⚡ Step 2: Event-Driven Agentic Orchestration with Step Functions

Running agents inside long-lived Python scripts leads to high costs and potential timeout issues during multi-step reasoning loops. With AWS Step Functions, every tool-call turn is decoupled and event-driven.
Below is a simplified state machine for the multi-turn tool loop (message history handling is trimmed for readability):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
{
"Comment": "Agentic AI Multi-Turn Tool Loop",
"StartAt": "Invoke Bedrock Model",
"States": {
"Invoke Bedrock Model": {
"Type": "Task",
"Resource": "arn:aws:states:::bedrock:invokeModel",
"Parameters": {
"ModelId": "anthropic.claude-3-5-sonnet-20240620-v1:0",
"Body": {
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 2000,
"messages.$": "$.messages",
"tools.$": "$.mcp_tools"
}
},
"Next": "Check Tool Use Requested"
},
"Check Tool Use Requested": {
"Type": "Choice",
"Choices": [
{
"Variable": "$.Body.stop_reason",
"StringEquals": "tool_use",
"Next": "Execute MCP Tool"
}
],
"Default": "Return Final Answer"
},
"Execute MCP Tool": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"FunctionName": "arn:aws:lambda:region:account:function:mcp-tool-gateway",
"Payload.$": "$.tool_input"
},
"Next": "Invoke Bedrock Model"
},
"Return Final Answer": {
"Type": "Pass",
"End": true
}
}
}

🛡️ Step 3: Crucial FinOps Guardrails for Student & Indie Builders

Autonomous agents that iterate in infinite tool loops can rapidly consume AWS Free Tier quotas and incur unexpected charges. A strict budget safety net is mandatory:
  • VPC Gateway Endpoints: Always route S3 and DynamoDB traffic via Gateway Endpoints inside your VPC to avoid NAT Gateway data processing charges (about $0.045/GB).
  • Proactive Anomaly Alerts: Deploy an aws_ce_anomaly_monitor via Terraform to send real-time SNS/Email alerts if daily spend spikes unexpectedly.
  • Hard Token Limits: Restrict Bedrock max_tokens per request to cap per-turn costs.
  • Loop Limits: Add a turn counter in your state machine and stop after a fixed number of iterations.

🎯 Conclusion & Key Takeaways

Building production-grade AI agents on AWS requires combining high-reasoning models (Bedrock) with open standards (MCP), event-driven orchestration (Step Functions), and disciplined FinOps guardrails.
By decoupling reasoning from tool execution, developers can create resilient, scalable, and safe autonomous cloud workflows.

💬 Let's Connect!

  • What AI agents are you currently building on AWS?
  • Do you prefer Amazon Bedrock Agents or custom MCP + Lambda integrations for tool calling?
If you found this guide helpful, please drop a ❤️ and share your thoughts in the comments below!
# agentic-ai# amazon-bedrock# aws-lambda# serverless# cost-optimization
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article