AI-Powered Infrastructure Cost Optimization — How LLMs Are Cutting Cloud Bills in 2026

# AWS Cost and Usage Report
aws ce get-cost-and-usage \
  --time-period Start=2026-03-01,End=2026-03-25 \
  --granularity DAILY \
  --metrics "UnblendedCost" "UsageQuantity" \
  --group-by Type=DIMENSION,Key=SERVICE
 
# CloudWatch metrics for resource utilization
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-1234567890 \
  --start-time 2026-03-18T00:00:00Z \
  --end-time 2026-03-25T00:00:00Z \
  --period 3600 \
  --statistics Average Maximum

# Prometheus query for actual CPU usage vs requests
# cpu_usage_ratio = rate(container_cpu_usage_seconds_total[5m]) / container_spec_cpu_quota
kubectl top pods -n production --containers

import pandas as pd
from sklearn.ensemble import IsolationForest
 
# Load daily cost data
costs = pd.read_csv('daily_costs.csv')
 
# Train anomaly detection model
model = IsolationForest(contamination=0.05, random_state=42)
costs['anomaly'] = model.fit_predict(costs[['daily_cost']])
 
# Flag anomalous days
anomalies = costs[costs['anomaly'] == -1]
print(f"Cost anomalies detected on {len(anomalies)} days:")
print(anomalies[['date', 'daily_cost', 'service']])

import openai
 
def analyze_costs(resource_data: dict, metrics: dict) -> str:
    prompt = f"""You are a cloud cost optimization expert. Analyze this AWS resource
    and provide specific cost-saving recommendations.
 
    Resource: {resource_data['type']} ({resource_data['id']})
    Region: {resource_data['region']}
    Current cost: ${resource_data['monthly_cost']}/month
 
    Utilization metrics (last 30 days):
    - Average CPU: {metrics['avg_cpu']}%
    - Peak CPU: {metrics['peak_cpu']}%
    - Average Memory: {metrics['avg_memory']}%
    - Network In: {metrics['network_in_gb']} GB/month
    - Network Out: {metrics['network_out_gb']} GB/month
    - Disk IOPS (avg): {metrics['avg_iops']}
 
    Current instance type: {resource_data['instance_type']}
 
    Provide:
    1. Whether this resource is right-sized
    2. Recommended instance type (if change needed)
    3. Estimated monthly savings
    4. Risk level of the change (low/medium/high)
    5. Any caveats or prerequisites before making the change
    """
 
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1
    )
 
    return response.choices[0].message.content

{
  "resource_id": "i-0abc123def456",
  "resource_type": "EC2",
  "current_type": "m5.4xlarge",
  "recommended_type": "c6g.xlarge",
  "current_monthly_cost": 560.64,
  "projected_monthly_cost": 122.40,
  "monthly_savings": 438.24,
  "confidence": 0.92,
  "risk": "low",
  "reasoning": "Average CPU is 12%, peak is 34%. Workload is compute-bound (low memory usage at 18%). Graviton instance provides better price-performance for this pattern.",
  "prerequisites": [
    "Verify application supports ARM64 architecture",
    "Test in staging environment first"
  ]
}

# Cast AI analyzes your cluster and suggests:
# Before: 5x m5.2xlarge nodes ($1,840/month)
# After: 3x c6g.xlarge + 2x spot m6g.large ($620/month)
# Savings: 66%

# What teams set (defensive):
resources:
  requests:
    cpu: "2"
    memory: 4Gi
  limits:
    cpu: "4"
    memory: 8Gi
 
# What the app actually uses (average):
# CPU: 200m, Memory: 800Mi

# AI recommendation based on P95 usage + 20% buffer:
resources:
  requests:
    cpu: 300m
    memory: 1Gi
  limits:
    cpu: 600m
    memory: 2Gi

import boto3
import openai
import json
from datetime import datetime, timedelta
 
def get_underutilized_instances():
    """Find EC2 instances with low CPU utilization."""
    ec2 = boto3.client('ec2')
    cloudwatch = boto3.client('cloudwatch')
 
    instances = ec2.describe_instances(
        Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
    )
 
    recommendations = []
 
    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            instance_id = instance['InstanceId']
 
            # Get 14-day average CPU
            stats = cloudwatch.get_metric_statistics(
                Namespace='AWS/EC2',
                MetricName='CPUUtilization',
                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                StartTime=datetime.utcnow() - timedelta(days=14),
                EndTime=datetime.utcnow(),
                Period=86400,
                Statistics=['Average', 'Maximum']
            )
 
            if stats['Datapoints']:
                avg_cpu = sum(d['Average'] for d in stats['Datapoints']) / len(stats['Datapoints'])
                max_cpu = max(d['Maximum'] for d in stats['Datapoints'])
 
                if avg_cpu < 20:
                    recommendations.append({
                        'instance_id': instance_id,
                        'instance_type': instance['InstanceType'],
                        'avg_cpu': round(avg_cpu, 2),
                        'max_cpu': round(max_cpu, 2),
                        'launch_time': instance['LaunchTime'].isoformat()
                    })
 
    return recommendations
 
# Get underutilized instances and analyze with LLM
instances = get_underutilized_instances()
for inst in instances:
    analysis = analyze_costs(inst, {'avg_cpu': inst['avg_cpu'], 'peak_cpu': inst['max_cpu']})
    print(f"\n--- {inst['instance_id']} ({inst['instance_type']}) ---")
    print(analysis)