Construct multi-agent web site reliability engineering assistants with Amazon Bedrock AgentCore

Web site reliability engineers (SREs) face an more and more complicated problem in fashionable distributed techniques. Throughout manufacturing incidents, they have to quickly correlate information from a number of sources—logs, metrics, Kubernetes occasions, and operational runbooks—to establish root causes and implement options. Conventional monitoring instruments present uncooked information however lack the intelligence to synthesize info throughout these various techniques, typically leaving SREs to manually piece collectively the story behind system failures.

With a generative AI resolution, SREs can ask their infrastructure questions in pure language. For instance, they’ll ask “Why are the payment-service pods crash looping?” or “What’s inflicting the API latency spike?” and obtain complete, actionable insights that mix infrastructure standing, log evaluation, efficiency metrics, and step-by-step remediation procedures. This functionality transforms incident response from a guide, time-intensive course of right into a time-efficient, collaborative investigation.

On this publish, we show the way to construct a multi-agent SRE assistant utilizing Amazon Bedrock AgentCore, LangGraph, and the Model Context Protocol (MCP). This method deploys specialised AI brokers that collaborate to offer the deep, contextual intelligence that fashionable SRE groups want for efficient incident response and infrastructure administration. We stroll you thru the entire implementation, from establishing the demo setting to deploying on Amazon Bedrock AgentCore Runtime for manufacturing use.

Resolution overview

This resolution makes use of a complete multi-agent structure that addresses the challenges of recent SRE operations via clever automation. The answer consists of 4 specialised AI brokers working collectively beneath a supervisor agent to offer complete infrastructure evaluation and incident response help.

The examples on this publish use synthetically generated information from our demo setting. The backend servers simulate reasonable Kubernetes clusters, utility logs, efficiency metrics, and operational runbooks. In manufacturing deployments, these stub servers would get replaced with connections to your precise infrastructure techniques, monitoring companies, and documentation repositories.

The structure demonstrates a number of key capabilities:

• Pure language infrastructure queries – You possibly can ask complicated questions on your infrastructure in plain English and obtain detailed evaluation combining information from a number of sources
• Multi-agent collaboration – Specialised brokers for Kubernetes, logs, metrics, and operational procedures work collectively to offer complete insights
• Actual-time information synthesis – Brokers entry stay infrastructure information via standardized APIs and current correlated findings
• Automated runbook execution – Brokers retrieve and show step-by-step operational procedures for frequent incident situations
• Supply attribution – Each discovering contains specific supply attribution for verification and audit functions

The next diagram illustrates the answer structure.

The structure demonstrates how the SRE help agent integrates seamlessly with Amazon Bedrock AgentCore parts:

• Buyer interface – Receives alerts about degraded API response occasions and returns complete agent responses
• Amazon Bedrock AgentCore Runtime – Manages the execution setting for the multi-agent SRE resolution
• SRE help agent – Multi-agent collaboration system that processes incidents and orchestrates responses
• Amazon Bedrock AgentCore Gateway – Routes requests to specialised instruments via OpenAPI interfaces:
  • Kubernetes API for getting cluster occasions
  • Logs API for analyzing log patterns
  • Metrics API for analyzing efficiency developments
  • Runbooks API for looking out operational procedures
• Amazon Bedrock AgentCore Reminiscence – Shops and retrieves session context and former interactions for continuity
• Amazon Bedrock AgentCore Id – Handles authentication for software entry utilizing Amazon Cognito integration
• Amazon Bedrock AgentCore Observability – Collects and visualizes agent traces for monitoring and debugging
• Amazon Bedrock LLMs – Powers the agent intelligence via Anthropic’s Claude giant language fashions (LLMs)

The multi-agent resolution makes use of a supervisor-agent sample the place a central orchestrator coordinates 5 specialised brokers:

• Supervisor agent – Analyzes incoming queries and creates investigation plans, routing work to acceptable specialists and aggregating outcomes into complete reviews
• Kubernetes infrastructure agent – Handles container orchestration and cluster operations, investigating pod failures, deployment points, useful resource constraints, and cluster occasions
• Software logs agent – Processes log information to seek out related info, identifies patterns and anomalies, and correlates occasions throughout a number of companies
• Efficiency metrics agent – Displays system metrics and identifies efficiency points, offering real-time evaluation and historic trending
• Operational runbooks agent – Gives entry to documented procedures, troubleshooting guides, and escalation procedures based mostly on the present state of affairs

Utilizing Amazon Bedrock AgentCore primitives

The answer showcases the ability of Amazon Bedrock AgentCore through the use of a number of core primitives. The answer helps two suppliers for Anthropic’s LLMs. Amazon Bedrock helps Anthropic’s Claude 3.7 Sonnet for AWS built-in deployments, and Anthropic API helps Anthropic’s Claude 4 Sonnet for direct API entry.

The Amazon Bedrock AgentCore Gateway element converts the SRE agent’s backend APIs (Kubernetes, utility logs, efficiency metrics, and operational runbooks) into Mannequin Context Protocol (MCP) instruments. This allows brokers constructed with an open-source framework supporting MCP (reminiscent of LangGraph on this publish) to seamlessly entry infrastructure APIs.

Safety for your complete resolution is offered by Amazon Bedrock AgentCore Id. It helps ingress authentication for safe entry management for brokers connecting to the gateway, and egress authentication to handle authentication with backend servers, offering safe API entry with out hardcoding credentials.

The serverless execution setting for deploying the SRE agent in manufacturing is offered by Amazon Bedrock AgentCore Runtime. It robotically scales from zero to deal with concurrent incident investigations whereas sustaining full session isolation. Amazon Bedrock AgentCore Runtime helps each OAuth and AWS Identity and Access Management (IAM) for agent authentication. Purposes that invoke brokers will need to have acceptable IAM permissions and belief insurance policies. For extra info, see Identity and access management for Amazon Bedrock AgentCore.

Amazon Bedrock AgentCore Reminiscence transforms the SRE agent from a stateless system into an clever studying assistant that personalizes investigations based mostly on consumer preferences and historic context. The reminiscence element supplies three distinct methods:

• Consumer preferences technique (/sre/customers/{user_id}/preferences) – Shops particular person consumer preferences for investigation model, communication channels, escalation procedures, and report formatting. For instance, Alice (a technical SRE) receives detailed systematic evaluation with troubleshooting steps, whereas Carol (an govt) receives business-focused summaries with influence evaluation.
• Infrastructure information technique (/sre/infrastructure/{user_id}/{session_id}) – Accumulates area experience throughout investigations, enabling brokers to be taught from previous discoveries. When the Kubernetes agent identifies a reminiscence leak sample, this information turns into obtainable for future investigations, enabling sooner root trigger identification.
• Investigation reminiscence technique (/sre/investigations/{user_id}/{session_id}) – Maintains historic context of previous incidents and their resolutions. This allows the answer to recommend confirmed remediation approaches and keep away from anti-patterns that beforehand failed.

The reminiscence element demonstrates its worth via customized investigations. When each Alice and Carol examine “API response occasions have degraded 3x within the final hour,” they obtain similar technical findings however fully totally different shows.

Alice receives a technical evaluation:

memory_client.retrieve_user_preferences(user_id="Alice")
# Returns: {"investigation_style": "detailed_systematic_analysis", "reviews": "technical_exposition_with_troubleshooting_steps"}

Carol receives an govt abstract:

memory_client.retrieve_user_preferences(user_id="Carol") 
# Returns: {"investigation_style": "business_impact_focused","reviews": "executive_summary_without_technical_details"}

Including observability to the SRE agent

Including observability to an SRE agent deployed on Amazon Bedrock AgentCore Runtime is simple utilizing the Amazon Bedrock AgentCore Observability primitive. This allows complete monitoring via Amazon CloudWatch with metrics, traces, and logs. Establishing observability requires three steps:

1. Add the OpenTelemetry packages to your pyproject.toml:

   dependencies = [
       # ... other dependencies ...
       "opentelemetry-instrumentation-langchain",
       "aws-opentelemetry-distro~=0.10.1",
   	]

2. Configure observability for your agents to allow metrics in CloudWatch.
3. Begin your container utilizing the opentelemetry-instrument utility to robotically instrument your utility.

The next command is added to the Dockerfile for the SRE agent:

# Run utility with OpenTelemetry instrumentation 
CMD ["uv", "run", "opentelemetry-instrument", "uvicorn", "sre_agent.agent_runtime:app", "--host", "0.0.0.0", "--port", "8080"]

As proven within the following screenshot, with observability enabled, you achieve visibility into the next:

• LLM invocation metrics – Token utilization, latency, and mannequin efficiency throughout brokers
• Software execution traces – Period and success charges for every MCP software name
• Reminiscence operations – Retrieval patterns and storage effectivity
• Finish-to-end request tracing – Full request movement from consumer question to closing response

The observability primitive robotically captures these metrics with out extra code modifications, offering production-grade monitoring capabilities out of the field.

Improvement to manufacturing movement

The SRE agent follows a four-step structured deployment course of from native improvement to manufacturing, with detailed procedures documented in Development to Production Flow within the accompanying GitHub repo:

The deployment course of maintains consistency throughout environments: the core agent code (sre_agent/) stays unchanged, and the deployment/ folder comprises deployment-specific utilities. The identical agent works regionally and in manufacturing via setting configuration, with Amazon Bedrock AgentCore Gateway offering MCP instruments entry throughout totally different phases of improvement and deployment.

Implementation walkthrough

Within the following part, we give attention to how Amazon Bedrock AgentCore Gateway, Reminiscence, and Runtime work collectively to construct this multi-agent collaboration resolution and deploy it end-to-end with MCP help and chronic intelligence.

We begin by establishing the repository and establishing the native runtime setting with API keys, LLM suppliers, and demo infrastructure. We then carry core AgentCore parts on-line by creating the gateway for standardized API entry, configuring authentication, and establishing software connectivity. We add intelligence via AgentCore Reminiscence, creating methods for consumer preferences and investigation historical past whereas loading personas for customized incident response. Lastly, we configure particular person brokers with specialised instruments, combine reminiscence capabilities, orchestrate collaborative workflows, and deploy to AgentCore Runtime with full observability.

Detailed directions for every step are offered within the repository:

Stipulations

You’ll find the port forwarding necessities and different setup directions within the README file’s Prerequisites part.

Convert APIs to MCP instruments with Amazon Bedrock AgentCore Gateway

Amazon Bedrock AgentCore Gateway demonstrates the ability of protocol standardization by changing current backend APIs into MCP instruments that agent frameworks can eat. This transformation occurs seamlessly, requiring solely OpenAPI specs.

Add OpenAPI specs

The gateway course of begins by importing your current API specs to Amazon Simple Storage Service (Amazon S3). The create_gateway.sh script robotically handles importing the 4 API specs (Kubernetes, Logs, Metrics, and Runbooks) to your configured S3 bucket with correct metadata and content material varieties. These specs can be used to create API endpoint targets within the gateway.

Create an identification supplier and gateway

Authentication is dealt with seamlessly via Amazon Bedrock AgentCore Id. The main.py script creates each the credential supplier and gateway:

# Create AgentCore Gateway with JWT authorization
def create_gateway(
    shopper: Any,
    gateway_name: str,
    role_arn: str,
    discovery_url: str,
    allowed_clients: record = None,
    description: str = "AgentCore Gateway created through SDK",
    search_type: str = "SEMANTIC",
    protocol_version: str = "2025-03-26",
) -> Dict[str, Any]:
    
    # Construct auth config for Cognito
    auth_config = {"customJWTAuthorizer": {"discoveryUrl": discovery_url}}
    if allowed_clients:
        auth_config["customJWTAuthorizer"]["allowedClients"] = allowed_clients
    
    protocol_configuration = {
        "mcp": {"searchType": search_type, "supportedVersions": [protocol_version]}
    }

    response = shopper.create_gateway(
        title=gateway_name,
        roleArn=role_arn,
        protocolType="MCP",
        authorizerType="CUSTOM_JWT",
        authorizerConfiguration=auth_config,
        protocolConfiguration=protocol_configuration,
        description=description,
        exceptionLevel="DEBUG"
    )
    return response

Deploy API endpoint targets with credential suppliers

Every API turns into an MCP goal via the gateway. The answer robotically handles credential administration:

def create_api_endpoint_target(
    shopper: Any,
    gateway_id: str,
    s3_uri: str,
    provider_arn: str,
    target_name_prefix: str = "open",
    description: str = "API Endpoint Goal for OpenAPI schema",
) -> Dict[str, Any]:
    
    api_target_config = {"mcp": {"openApiSchema": {"s3": {"uri": s3_uri}}}}

    # API key credential supplier configuration
    credential_config = {
        "credentialProviderType": "API_KEY",
        "credentialProvider": {
            "apiKeyCredentialProvider": {
                "providerArn": provider_arn,
                "credentialLocation": "HEADER",
                "credentialParameterName": "X-API-KEY",
            }
        },
    }
    
    response = shopper.create_gateway_target(
        gatewayIdentifier=gateway_id,
        title=target_name_prefix,
        description=description,
        targetConfiguration=api_target_config,
        credentialProviderConfigurations=[credential_config],
    )
    return response

Validate MCP instruments are prepared for agent framework

Submit-deployment, Amazon Bedrock AgentCore Gateway supplies a standardized /mcp endpoint secured with JWT tokens. Testing the deployment with mcp_cmds.sh reveals the ability of this transformation:

Software abstract:
================
Whole instruments discovered: 21

Software names:
• x_amz_bedrock_agentcore_search
• k8s-api___get_cluster_events
• k8s-api___get_deployment_status
• k8s-api___get_node_status
• k8s-api___get_pod_status
• k8s-api___get_resource_usage
• logs-api___analyze_log_patterns
• logs-api___count_log_events
• logs-api___get_error_logs
• logs-api___get_recent_logs
• logs-api___search_logs
• metrics-api___analyze_trends
• metrics-api___get_availability_metrics
• metrics-api___get_error_rates
• metrics-api___get_performance_metrics
• metrics-api___get_resource_metrics
• runbooks-api___get_common_resolutions
• runbooks-api___get_escalation_procedures
• runbooks-api___get_incident_playbook
• runbooks-api___get_troubleshooting_guide
• runbooks-api___search_runbooks

Common agent framework compatibility

This MCP-standardized gateway can now be configured as a Streamable-HTTP server for MCP shoppers, together with AWS Strands, Amazon’s agent improvement framework, LangGraph, the framework utilized in our SRE agent implementation, and CrewAI, a multi-agent collaboration framework.

The benefit of this strategy is that current APIs require no modification—solely OpenAPI specs. Amazon Bedrock AgentCore Gateway handles the next:

• Protocol translation – Between REST APIs to MCP
• Authentication – JWT token validation and credential injection
• Safety – TLS termination and entry management
• Standardization – Constant software naming and parameter dealing with

This implies you’ll be able to take current infrastructure APIs (Kubernetes, monitoring, logging, documentation) and immediately make them obtainable to AI agent frameworks that help MCP—via a single, safe, standardized interface.

Implement persistent intelligence with Amazon Bedrock AgentCore Reminiscence

Whereas Amazon Bedrock AgentCore Gateway supplies seamless API entry, Amazon Bedrock AgentCore Reminiscence transforms the SRE agent from a stateless system into an clever, studying assistant. The reminiscence implementation demonstrates how just a few strains of code can allow subtle personalization and cross-session information retention.

Initialize reminiscence methods

The SRE agent reminiscence element is constructed on Amazon Bedrock AgentCore Reminiscence’s event-based mannequin with automated namespace routing. Throughout initialization, the answer creates three reminiscence methods with particular namespace patterns:

from sre_agent.reminiscence.shopper import SREMemoryClient
from sre_agent.reminiscence.methods import create_memory_strategies

# Initialize reminiscence shopper
memory_client = SREMemoryClient(
    memory_name="sre_agent_memory",
    area="us-east-1"
)

# Create three specialised reminiscence methods
methods = create_memory_strategies()
for technique in methods:
    memory_client.create_strategy(technique)

The three methods every serve distinct functions:

• Consumer preferences (/sre/customers/{user_id}/preferences) – Particular person investigation types and communication preferences
• Infrastructure Information: /sre/infrastructure/{user_id}/{session_id} – Area experience accrued throughout investigations
• Investigation Summaries: /sre/investigations/{user_id}/{session_id} – Historic incident patterns and resolutions

Load consumer personas and preferences

The answer comes preconfigured with consumer personas that show customized investigations. The manage_memories.py script masses these personas:

# Load Alice - Technical SRE Engineer
alice_preferences = {
    "investigation_style": "detailed_systematic_analysis",
    "communication": ["#alice-alerts", "#sre-team"],
    "escalation": {"contact": "alice.supervisor@firm.com", "threshold": "15min"},
    "reviews": "technical_exposition_with_troubleshooting_steps",
    "timezone": "UTC"
}

# Load Carol - Govt/Director
carol_preferences = {
    "investigation_style": "business_impact_focused",
    "communication": ["#carol-executive", "#strategic-alerts"],
    "escalation": {"contact": "carol.director@firm.com", "threshold": "5min"},
    "reviews": "executive_summary_without_technical_details",
    "timezone": "EST"
}

# Retailer preferences utilizing reminiscence shopper
memory_client.store_user_preference("Alice", alice_preferences)
memory_client.store_user_preference("Carol", carol_preferences)

Computerized namespace routing in motion

The facility of Amazon Bedrock AgentCore Reminiscence lies in its automated namespace routing. When the SRE agent creates occasions, it solely wants to offer the actor_id—Amazon Bedrock AgentCore Reminiscence robotically determines which namespaces the occasion belongs to:

# Throughout investigation, the supervisor agent shops context
memory_client.create_event(
    memory_id="sre_agent_memory-abc123",
    actor_id="Alice",  # AgentCore Reminiscence routes this robotically
    session_id="investigation_2025_01_15",
    messages=[("investigation_started", "USER")]
)

# Reminiscence system robotically:
# 1. Checks technique namespaces <!-- "all" is important right here for technical accuracy -->
# 2. Matches actor_id "Alice" to /sre/customers/Alice/preferences
# 3. Shops occasion in Consumer Preferences Technique
# 4. Makes occasion obtainable for future retrievals

Validate the customized investigation expertise

The reminiscence element’s influence turns into clear when each Alice and Carol examine the identical problem. Utilizing similar technical findings, the answer produces fully totally different shows of the identical underlying content material.

Alice’s technical report comprises detailed systematic evaluation for technical groups:

Technical Investigation Abstract

Root Trigger: Cost processor reminiscence leak inflicting OOM kills

Evaluation:
- Pod restart frequency elevated 300% at 14:23 UTC
- Reminiscence utilization peaked at 8.2GB (80% of container restrict)
- JVM rubbish assortment latency spiked to 2.3s

Subsequent Step:
1. Implement heap dump evaluation (`kubectl exec payment-pod -- jmap`)
2. Overview latest code deployments for reminiscence administration modifications
3. Think about rising reminiscence limits and implementing sleek shutdown

Carol’s govt abstract comprises enterprise influence targeted for govt stakeholders:

Enterprise Affect Evaluation
Standing: CRITICAL - Buyer fee processing degraded
Affect: 23% transaction failure charge, $47K income in danger
Timeline: Challenge detected 14:23 UTC, decision ETA 45 minutes
Enterprise Actions: - Buyer communication initiated through standing web page - Finance group alerted for income influence monitoring - Escalating to VP Engineering if not resolved by 15:15 UTC

The reminiscence element permits this personalization whereas repeatedly studying from every investigation, constructing organizational information that improves incident response over time.

Deploy to manufacturing with Amazon Bedrock AgentCore Runtime

Amazon Bedrock AgentCore makes it simple to deploy current brokers to manufacturing. The method entails three key steps: containerizing your agent, deploying to Amazon Bedrock AgentCore Runtime, and invoking the deployed agent.

Containerize your agent

Amazon Bedrock AgentCore Runtime requires ARM64 containers. The next code exhibits the entire Dockerfile:

# Use uv's ARM64 Python base picture
FROM --platform=linux/arm64 ghcr.io/astral-sh/uv:python3.12-bookworm-slim

WORKDIR /app

# Copy uv recordsdata
COPY pyproject.toml uv.lock ./

# Set up dependencies
RUN uv sync --frozen --no-dev

# Copy SRE agent module
COPY sre_agent/ ./sre_agent/

# Set setting variables
# Be aware: Set DEBUG=true to allow debug logging and traces
ENV PYTHONPATH="/app" 
    PYTHONDONTWRITEBYTECODE=1 
    PYTHONUNBUFFERED=1

# Expose port
EXPOSE 8080

# Run utility with OpenTelemetry instrumentation
CMD ["uv", "run", "opentelemetry-instrument", "uvicorn", "sre_agent.agent_runtime:app", "--host", "0.0.0.0", "--port", "8080"]

Current brokers simply want a FastAPI wrapper (agent_runtime:app) to change into suitable with Amazon Bedrock AgentCore, and we add opentelemetry-instrument to allow observability via Amazon Bedrock AgentCore.

Deploy to Amazon Bedrock AgentCore Runtime

Deploying to Amazon Bedrock AgentCore Runtime is simple with the deploy_agent_runtime.py script:

import boto3

# Create AgentCore shopper
shopper = boto3.shopper('bedrock-agentcore', region_name=area)

# Surroundings variables to your agent
env_vars = {
    'GATEWAY_ACCESS_TOKEN': gateway_access_token,
    'LLM_PROVIDER': llm_provider,
    'ANTHROPIC_API_KEY': anthropic_api_key  # if utilizing Anthropic
}

# Deploy container to AgentCore Runtime
response = shopper.create_agent_runtime(
    agentRuntimeName=runtime_name,
    agentRuntimeArtifact={
        'containerConfiguration': {
            'containerUri': container_uri  # Your ECR container URI
        }
    },
    networkConfiguration={"networkMode": "PUBLIC"},
    roleArn=role_arn,
    environmentVariables=env_vars
)

print(f"Agent Runtime ARN: {response['agentRuntimeArn']}")

Amazon Bedrock AgentCore handles the infrastructure, scaling, and session administration robotically.

Invoke your deployed agent

Calling your deployed agent is simply as easy with invoke_agent_runtime.py:

# Put together your question with user_id and session_id for reminiscence personalization
payload = json.dumps({
    "enter": {
        "immediate": "API response occasions have degraded 3x within the final hour",
        "user_id": "Alice",  # Consumer for customized investigation
        "session_id": "investigation-20250127-123456"  # Session for context
    }
})

# Invoke the deployed agent
response = agent_core_client.invoke_agent_runtime(
    agentRuntimeArn=runtime_arn,
    runtimeSessionId=session_id,
    payload=payload,
    qualifier="DEFAULT"
)

# Get the response
response_data = json.masses(response['response'].learn())
print(response_data)  # Full response contains output with agent's investigation

Key advantages of Amazon Bedrock AgentCore Runtime

Amazon Bedrock AgentCore Runtime provides the next key advantages:

• Zero infrastructure administration – No servers, load balancers, or scaling to configure
• Constructed-in session isolation – Every dialog is totally remoted
• AWS IAM integration – Safe entry management with out customized authentication
• Computerized scaling – Scales from zero to 1000’s of concurrent classes

The whole deployment course of, together with constructing containers and dealing with AWS permissions, is documented within the Deployment Guide.

Actual-world use circumstances

Let’s discover how the SRE agent handles frequent incident response situations with an actual investigation.

When dealing with a manufacturing problem, you’ll be able to question the system in pure language. The answer makes use of Amazon Bedrock AgentCore Reminiscence to personalize the investigation based mostly in your function and preferences:

export USER_ID=Alice
sre-agent --prompt "API response occasions have degraded 3x within the final hour"

The supervisor retrieves Alice’s preferences from reminiscence (detailed systematic evaluation model) and creates an investigation plan tailor-made to her function as a Technical SRE:

Investigation Plan
1. Use metrics_agent to research API efficiency metrics together with response occasions, error charges, and useful resource utilization to establish the extent and sample of slowdown
2. Use logs_agent to look at utility logs for errors associated to sluggish API responses, specializing in database connection points and reminiscence errors
3. Use kubernetes_agent to test pod standing and useful resource constraints, particularly for web-service and database pods, on the lookout for CrashLoopBackOff states and lacking ConfigMaps
Complexity: Easy
Auto-execute: Sure
Brokers concerned: Metrics Agent, Logs Agent, Kubernetes Agent

The brokers examine sequentially in response to the plan, every contributing their specialised evaluation. The answer then aggregates these findings right into a complete govt abstract:

Govt Abstract
Key Insights
- Root Trigger: Database service failure attributable to lacking ConfigMap 'database-config' in manufacturing namespace, inflicting database pod to crash repeatedly
- Affect: Extreme efficiency degradation with API response occasions elevated from 150ms to 5000ms (33x slower)
- Severity: Excessive - Database unavailability, reminiscence exhaustion (100%), and CPU saturation (95%) inflicting 75% error charge
Subsequent Steps
1. Quick (< 1 hour): Create/replace ConfigMap 'database-config' in manufacturing namespace and restart database pod
2. Brief-term (< 24 hours): 
   - Repair permissions on '/var/lib/postgresql/information' listing
   - Improve Java heap area for web-service to deal with OutOfMemoryErrors
   - Optimize UserService.loadAllUsers technique inflicting reminiscence points
3. Lengthy-term (< 1 week): 
   - Implement useful resource monitoring with alerts for CPU (>80%), reminiscence (>90%)
   - Optimize sluggish database queries, notably "SELECT * FROM customers WHERE standing="lively""
   - Scale up sources or implement autoscaling for web-service
Important Alerts
- Database pod (database-pod-7b9c4d8f2a-x5m1q) in CrashLoopBackOff state
- Net-service experiencing OutOfMemoryErrors in UserService.loadAllUsers(UserService.java:45)
- Node-3 experiencing reminiscence stress (>85% utilization)
- Net-app-deployment displaying readiness probe failures with 503 errors
Troubleshooting Steps
1. Confirm ConfigMap standing: `kubectl get configmap database-config -n manufacturing`
2. Verify database pod logs: `kubectl logs database-pod-7b9c4d8f2a-x5m1q -n manufacturing`
3. Create/replace ConfigMap: `kubectl create configmap database-config --from-file=database.conf -n manufacturing`
4. Repair information listing permissions: `kubectl exec database-pod-7b9c4d8f2a-x5m1q -n manufacturing -- chmod -R 700 /var/lib/postgresql/information`
5. Restart database pod: `kubectl delete pod database-pod-7b9c4d8f2a-x5m1q -n manufacturing`

This investigation demonstrates how Amazon Bedrock AgentCore primitives work collectively:

• Amazon Bedrock AgentCore Gateway – Gives safe entry to infrastructure APIs via MCP instruments
• Amazon Bedrock AgentCore Id – Handles ingress and egress authentication
• Amazon Bedrock AgentCore Runtime – Hosts the multi-agent resolution with automated scaling
• Amazon Bedrock AgentCore Reminiscence – Personalizes Alice’s expertise and shops investigation information for future incidents
• Amazon Bedrock AgentCore Observability – Captures detailed metrics and traces in CloudWatch for monitoring and debugging

The SRE agent demonstrates clever agent orchestration, with the supervisor routing work to specialists based mostly on the investigation plan. The answer’s reminiscence capabilities ensure that every investigation builds organizational information and supplies customized experiences based mostly on consumer roles and preferences.

This investigation showcases a number of key capabilities:

• Multi-source correlation – It connects database configuration points to API efficiency degradation
• Sequential investigation – Brokers work systematically via the investigation plan whereas offering stay updates
• Supply attribution – Findings embody the particular software and information supply
• Actionable insights – It supplies a transparent timeline of occasions and prioritized restoration steps
• Cascading failure detection – It will possibly assist present how one failure propagates via the system

Enterprise influence

Organizations implementing AI-powered SRE help report vital enhancements in key operational metrics. Preliminary investigations that beforehand took 30–45 minutes can now be accomplished in 5–10 minutes, offering SREs with complete context earlier than diving into detailed evaluation. This dramatic discount in investigation time interprets on to sooner incident decision and decreased downtime.The answer improves how SREs work together with their infrastructure. As a substitute of navigating a number of dashboards and instruments, engineers can ask questions in pure language and obtain aggregated insights from related information sources. This discount in context switching permits groups to take care of focus throughout vital incidents and reduces cognitive load throughout investigations.Maybe most significantly, the answer democratizes information throughout the group. All group members can entry the identical complete investigation strategies, decreasing dependency on tribal information and on-call burden. The constant methodology offered by the answer makes positive investigation approaches stay uniform throughout group members and incident varieties, enhancing general reliability and decreasing the prospect of missed proof.

The robotically generated investigation reviews present precious documentation for post-incident opinions and assist groups be taught from every incident, constructing organizational information over time. Moreover, the answer extends current AWS infrastructure investments, working alongside companies like Amazon CloudWatch, AWS Systems Manager, and different AWS operational instruments to offer a unified operational intelligence system.

Extending the answer

The modular structure makes it simple to increase the answer to your particular wants.

For instance, you’ll be able to add specialised brokers to your area:

• Safety agent – For compliance checks and safety incident response
• Database agent – For database-specific troubleshooting and optimization
• Community agent – For connectivity and infrastructure debugging

You may as well change the demo APIs with connections to your precise techniques:

• Kubernetes integration – Connect with your cluster APIs for pod standing, deployments, and occasions
• Log aggregation – Combine along with your log administration service (Elasticsearch, Splunk, CloudWatch Logs)
• Metrics platform – Connect with your monitoring service (Prometheus, Datadog, CloudWatch Metrics)
• Runbook repository – Hyperlink to your operational documentation and playbooks saved in wikis, Git repositories, or information bases

Clear up

To keep away from incurring future costs, use the cleanup script to take away the billable AWS sources created in the course of the demo:

# Full cleanup - deletes AWS sources and native recordsdata
./scripts/cleanup.sh

This script robotically performs the next actions:

• Cease backend servers
• Delete the gateway and its targets
• Delete Amazon Bedrock AgentCore Reminiscence sources
• Delete the Amazon Bedrock AgentCore Runtime
• Take away generated recordsdata (gateway URIs, tokens, agent ARNs, reminiscence IDs)

For detailed cleanup directions, discuss with Cleanup Instructions.

Conclusion

The SRE agent demonstrates how multi-agent techniques can rework incident response from a guide, time-intensive course of right into a time-efficient, collaborative investigation that gives SREs with the insights they should resolve points shortly and confidently.

By combining the enterprise-grade infrastructure of Amazon Bedrock AgentCore with standardized software entry in MCP, we’ve created a basis that may adapt as your infrastructure evolves and new capabilities emerge.

The whole implementation is obtainable in our GitHub repository, together with demo environments, configuration guides, and extension examples. We encourage you to discover the answer, customise it to your infrastructure, and share your experiences with the group.

To get began constructing your individual SRE assistant, discuss with the next sources:

In regards to the authors

Amit Arora is an AI and ML Specialist Architect at Amazon Net Companies, serving to enterprise prospects use cloud-based machine studying companies to quickly scale their improvements. He’s additionally an adjunct lecturer within the MS information science and analytics program at Georgetown College in Washington, D.C.

Dheeraj Oruganty is a Supply Marketing consultant at Amazon Net Companies. He’s obsessed with constructing modern Generative AI and Machine Studying options that drive actual enterprise influence. His experience spans Agentic AI Evaluations, Benchmarking and Agent Orchestration, the place he actively contributes to analysis advancing the sector. He holds a grasp’s diploma in Knowledge Science from Georgetown College. Exterior of labor, he enjoys geeking out on automobiles, bikes, and exploring nature.