AWS Builder Center
From Logs to AI Agents: Seven CloudWatch Releases That Define Modern Observability

From Logs to AI Agents: Seven CloudWatch Releases That Define Modern Observability

Introduction Between July 1 and July 20, 2026, CloudWatch shipped seven updates that don’t read like scattered feature drops. Read together, they’re a roadmap — for what an architect should change about how they design logging, application monitoring, and observability for AI workloads.

CloudWatch has shipped constantly since 2020 — synthetics, RUM, Application Signals, cross-account observability, an entire second life as a log analytics engine. Most of it arrives as a trickle of press releases that don’t obviously connect. July 2026 is different: seven announcements landed in twenty days, and three of them touch the exact same subsystem (Logs), two touch APM and synthetics, and one is CloudWatch turning its instruments on a workload it has never measured before — the AI agents writing your code.

This piece walks all seven in ship order, each with the architectural “so what” and a runnable sample. The running example throughout is a fictional regulated bank, Meridian Trust, whose claims-processing estate is a fleet of JBoss and WebSphere nodes on Windows EC2, stood up with Terraform and configured with Ansible — a shape a lot of enterprise Java estates on AWS still take in 2026.

The Three Threads

01 · Alarms Directly from Log Queries


Jul 1, 2026 —  announcement 

What changed

Until this release, alerting on something you could only see in logs meant a three-hop chain: write a metric filter to extract a number from the log stream, publish it as a custom metric, then attach an alarm to that metric. Each hop is a resource to provision, a place for drift, and — because metric filters process log data with their own latency — a place alerting lags behind the actual event.
CloudWatch now lets you point an alarm straight at a Logs Insights query and a threshold. No intermediate metric. Standard alarm actions apply: SNS, EventBridge, the works.

At Meridian Trust

The claims-adjudication service on the WebSphere cluster emits structured JSON per request, including an  outcome  field. The SRE team wants a page when the five-minute error rate on  /claims/submit  crosses 2% — previously a metric filter plus a math expression alarm. Now it's the query, a threshold, and nothing in between.

Sample — the query the alarm evaluates

fields @timestamp, outcome, endpoint
| filter endpoint = "/claims/submit"
| stats
count(*) as total,
sum(outcome = "error") as errors
by bin(5m)
| fields errors / total * 100 as error_rate_pct

Sample — notification path (Terraform)

resource "aws_sns_topic" "claims_paging" {
name = "meridian-claims-submit-errors"
}
resource "aws_sns_topic_subscription" "oncall" {
topic_arn = aws_sns_topic.claims_paging.arn
protocol = "https"
endpoint = var.pagerduty_events_url
}
# The alarm-on-log-query resource is new (Jul 1 2026) and not yet exposed
# by the Terraform AWS provider. Provision via console, CloudFormation, or
# CLI until provider support lands, then import into state.

Design consideration: query cost replaces metric cost

Log-query alarms are billed as log queries, not as metrics. When migrating existing metric-filter alarms, budget for query execution volume, not just ingestion.
Quick math:  (number of alarms) x (evaluation frequency) x (query cost per GB scanned)  — run this before migrating at scale. A high-frequency alarm on a large log group can cost more than the metric filter it replaces.

02 · Application Signals Service Events


Jul 6, 2026 —  announcement 

What changed

Application Signals already gave you a service map and SLOs. Service Events goes further: once a service is instrumented via the ADOT SDK or the CloudWatch Observability EKS add-on, CloudWatch automatically captures exception snapshots, latency-anomaly events, function-level performance data, and deployment markers — with zero additional code. Java, Python, and JavaScript are supported at launch.

At Meridian Trust

The platform team ADOT-instrumented the claims API earlier this year. After this release,  Application Signals -> claims-api -> Errors  shows a new  NullPointerException  cluster starting at the exact deployment marker — surfaced before the first support ticket, with no dashboard built by hand to catch it.

Sample — enabling Application Signals discovery

resource "aws_iam_role_policy_attachment" "app_signals" {
role = aws_iam_role.claims_api_task.name
policy_arn = "arn:aws:iam::aws:policy/CloudWatchApplicationSignalsFullAccess"
}
# Enable discovery once per account/Region.
resource "null_resource" "enable_app_signals_discovery" {
provisioner "local-exec" {
command = "aws application-signals start-discovery --region ${var.region}"
}
}

Sample — ADOT auto-instrumentation on Windows JBoss (Ansible)

- name: Configure JBoss service JVM options for ADOT + Application Signals
ansible.windows.win_regedit:
path: HKLM:\SYSTEM\CurrentControlSet\Services\JBossEAP\Parameters
name: JVMOptions
data: >-
-javaagent:C:\adot\aws-opentelemetry-agent.jar
-Dotel.aws.application.signals.enabled=true
-Dotel.resource.attributes=service.name=claims-api,deployment.environment=prod
type: string
notify: restart jboss service

Design consideration: instrumentation coverage is the new bottleneck

Service Events is opt-in by capability, not by dashboard. You don’t build the exception view; you enable the SDK and it appears. This shifts platform-team effort from “build the golden dashboard” to “get every service correctly instrumented” — the harder, more durable problem.
Action item: Audit your service catalog for ADOT coverage gaps. Services without instrumentation get zero benefit from this release — and they’re now visibly behind the ones that have it.

03 · Lookup Processor for Log Enrichment

Jul 14, 2026 —  announcement 

What changed

CloudWatch Pipelines (the log transformation layer) gains a lookup processor: upload a reference CSV, match an incoming log field against it, and stamp matching rows with extra columns — at ingestion time, before the log ever hits a query or dashboard.

At Meridian Trust

VPC Flow Logs previously required a join against a spreadsheet to answer “which team owns this traffic” during an incident. With the lookup processor, every flow log record already carries  owning_team  and  cost_center  by the time it lands — no query-time join, no stale spreadsheet passed around in Slack.

Sample — reference data

cidr,owning_team,cost_center
10.20.0.0/16,claims-platform,CC-4021
10.30.0.0/16,payments,CC-4088
10.40.0.0/16,shared-services,CC-4000

Sample — pipeline transformation config

{
"processors": [
{
"type": "lookup",
"lookup": {
"source": {
"type": "s3",
"bucket": "meridian-log-enrichment",
"key": "ip-ownership.csv"
},
"matchField": "srcAddr",
"lookupKey": "cidr",
"matchType": "cidr",
"addFields": ["owning_team", "cost_center"]
}
}
]
}
aws logs put-transformer --log-group-name /vpc/flow-logs \
--transformer-config file://pipeline.json

Design consideration: enrichment is permanent — scope it tightly

Every field added at ingestion is stored and billed on every matching log line for the life of the retention policy. This is a one-way cost door.
Do: Enrich log groups that incident responders actively query (VPC flow logs for specific subnets, application error logs).
Don’t: Blanket-enrich high-volume firehose groups (CloudTrail data events, ELB access logs) unless per-record cost is justified by query-time savings.

04 · Intelligent Tiering for Logs Storage

Jul 15, 2026 —  announcement 

What changed

Log groups now move automatically across three storage tiers based on access, not age:
Query anything, on any tier, in the same Logs Insights experience — no rehydration step, no separate export/import pipeline. Touch an old log line and it promotes back to Standard for another 30 days.

At Meridian Trust

Regulatory retention on claims and GC logs is seven years, but nobody queries anything past 90 days outside of an audit. The old pattern was export-to-S3-Glacier plus a home-grown Athena setup just to stay queryable during an audit. Intelligent tiering removes the second system entirely — the logs never leave CloudWatch; they just get cheaper the longer nobody looks at them.

Sample — log group with regulatory retention (Terraform)

resource "aws_cloudwatch_log_group" "claims_gc_logs" {
name = "/meridian/jboss/gc-logs"
retention_in_days = 2557 # 7-year regulatory retention
tags = {
data-classification = "regulatory-retained"
}
}

Sample — enabling intelligent tiering (CLI)

# Account-level setting — enable once per account.
aws logs put-account-policy \
--policy-name meridian-intelligent-tiering \
--policy-type LOG_GROUP_STORAGE_TIERING \
--policy-document '{"tiering":"ENABLED"}'
# Note: Terraform provider support may lag. Verify the exact policy-type
# and document shape against the CLI reference before scripting into CI.

Design consideration: native retention vs. S3 export — a new calculus

This is the first time CloudWatch Logs genuinely competes with “export to S3 for cost” as a long-term retention play.
ApproachProsConsIntelligent tiering (native)Single query interface, no rehydration, zero pipeline maintenanceHigher per-GB floor than GlacierS3 Glacier + AthenaLowest storage cost at scaleRehydration delay, separate query tooling, pipeline to maintain
Decision heuristic: If your compliance team queries retained logs fewer than 5 times per year, intelligent tiering likely wins on total cost of ownership once you factor in the Athena/Glacier pipeline’s operational overhead.

05 · 25 New Logs Insights Commands and Functions

Jul 15, 2026 —  announcement 

What changed

The densest release of the month. Logs Insights picks up:
Together, these close the gap between “our log query tool” and a real analytical query language — the kind of thing that used to send a query to Athena.

At Meridian Trust

The SRE team needs login-velocity anomalies per account, a smoothed latency trend that doesn’t gap out during low-traffic windows, and automatic team tagging by source IP — all without leaving Logs Insights.

Sample — session-based anomaly detection on logins

fields @timestamp, accountId, sourceIp
| filter eventName = "Login"
| sessionize accountId, gapDuration=15m as session_id
| stats count(*) as attempts_per_session by session_id, accountId
| stats outlier(attempts_per_session) as anomaly_score by accountId
| filter anomaly_score > 3

Sample — gap-free latency trend + CIDR tagging

fields @timestamp, latency_ms, sourceIp
| stats avg(latency_ms) as p_latency by bin(1m)
| fillmissing p_latency = 0
| filldown p_latency
| cidrlookup sourceIp against "10.20.0.0/16" as is_claims_platform

Design consideration: retire your Lambda log processors

Confirm exact argument syntax against the QL reference before shipping saved queries — several commands are days old.
Decommission candidate: Teams running custom Lambda-based log post-processors for sessionization, outlier detection, or gap-filling now have a native alternative. Fewer moving parts, lower invocation cost, and no cold-start latency in the query path. Evaluate retiring that code.

06 · Synthetics Customer-Managed KMS Keys


Jul 16, 2026 —  announcement 

What changed

Canary environment variables were previously encrypted at rest with an AWS-owned key only. Synthetics now accepts:
  • Customer-managed KMS key for at-rest encryption (via a grant CloudWatch manages transparently).
  • Client-side encryption — you encrypt a value yourself before storage, and your canary script calls  KMS Decrypt  at runtime.
  • Per-Region keys for multi-location canaries.

At Meridian Trust

A canary logs into the customer portal every five minutes using a service-account password stored as an environment variable. Compliance previously blocked this pattern because the encryption key wasn’t under Meridian’s KMS key policy. A customer-managed key with defined rotation and CloudTrail-audited grants clears that objection.

Sample — Terraform

resource "aws_kms_key" "synthetics_canary" {
description = "CMK for Meridian portal-login canary env vars"
enable_key_rotation = true
}
resource "aws_synthetics_canary" "portal_login" {
name = "meridian-portal-login"
artifact_s3_location = "s3://${aws_s3_bucket.canary_artifacts.id}/portal-login"
execution_role_arn = aws_iam_role.canary_exec.arn
runtime_version = "syn-nodejs-puppeteer-9.0"
handler = "index.handler"
zip_file = "canary/portal-login.zip"
run_config {
environment_variables = {
PORTAL_SERVICE_ACCOUNT_PW = var.encrypted_service_account_pw
}
}
# kms_key_arn is the newly announced argument (Jul 16 2026).
# Verify it has landed in your pinned provider version; if not,
# set via `aws synthetics update-canary` post-apply.
kms_key_arn = aws_kms_key.synthetics_canary.arn
}

Design consideration: pick the right encryption layer for your threat model

Two encryption options are now available — they protect against different things:
OptionProtects againstDoesn’t protect againstAt-rest CMKUnauthorized access to stored data; satisfies key-rotation audit requirementsConsole viewers with  synthetics:GetCanary  permission (they see plaintext at read time)Client-side encrypt + runtime decryptAll of the above + console exposureCompromised canary execution role (it must hold  kms:Decrypt )
Rule of thumb: Client-side encryption for anything that would cause harm in a console screenshot or support-session screen share. At-rest CMK for non-secret but sensitive config (internal URLs, non-prod tokens).

07 · Coding Agent Insights

Jul 20, 2026 —  announcement 

What changed

The most structurally novel release of the month. CloudWatch now ingests OpenTelemetry metrics emitted by coding agents and renders them alongside normal operational data. Supported agents at launch:
  • Claude Code (zero-instrumentation via the Claude apps gateway for AWS)
  • Codex
  • GitHub Copilot
The dashboard answers questions a platform lead gets asked before a renewal: which teams would benefit from wider access, where is agent use correlating with faster delivery, and which model gives the best cost-to-output ratio.

At Meridian Trust

The platform team rolled Claude Code out to 40 engineers six months ago. The engineering director wants a defensible answer before signing off on 200 more seats: is it moving commit throughput and PR velocity, or just token spend? Coding agent insights is built to answer exactly that.

Sample — OTel exporter configuration (illustrative)

Note: The YAML below is illustrative of the expected configuration shape. Confirm the exact schema against the Claude apps gateway documentation before use.
otel:
exporters:
awsCloudWatch:
region: us-east-1
namespace: CodingAgents/ClaudeCode
metrics:
exporter: awsCloudWatch
resourceAttributes:
team: claims-platform
cost_center: CC-4021

Sample — alarm on token spend velocity

aws cloudwatch put-metric-alarm \
--alarm-name meridian-claude-code-token-spend-spike \
--namespace CodingAgents/ClaudeCode \
--metric-name TokenSpendUSD \
--dimensions Name=team,Value=claims-platform \
--statistic Sum --period 3600 --evaluation-periods 3 \
--threshold 500 --comparison-operator GreaterThanThreshold \
--alarm-actions arn:aws:sns:us-east-1:123456789012:platform-cost-alerts

Design consideration: tag from day one or regret it forever

Availability: Excludes Middle East (UAE), Middle East (Bahrain), and Israel (Tel Aviv) at launch. Billing follows standard CloudWatch OTel metric-ingestion pricing — cost scales with telemetry cardinality.
Day-one tagging checklist:
  • Namespace by tool:  CodingAgents/ClaudeCode ,  CodingAgents/Copilot 
  • Dimension by  team  and  cost_center  from the first metric emitted
  • Set a spend alarm per team before the first invoice, not after
Retrofitting attribution onto untagged agent telemetry is exactly as painful as it is for every other metric source. You’ve done this cleanup before on EC2 or Lambda costs — don’t repeat it here.

Putting It Together

Three takeaways for architects reading all seven as a set:
  1. CloudWatch Logs is no longer a place to dump text and forget it. With alarms, enrichment, tiering, and a genuinely deep query language landing in the same two weeks, it’s a competitive log analytics platform on its own economics. Re-evaluate anything you built to work around its former limits — Lambda post-processors, external export pipelines — against what shipped this month.
  1. APM and synthetic monitoring both moved toward “configure once, CloudWatch keeps explaining itself.” Service Events and CMK-backed canaries reduce dashboard-building effort and audit friction respectively. These features reward services that are properly ADOT-instrumented and canaries that are properly key-managed; they do nothing for the ones that aren’t.
  1. Coding agent insights is a preview of where observability is heading next. CloudWatch measuring the tools your engineers use to write code, not just the systems that code runs on. Instrument early and tag by team/cost-center from day one — retrofitting attribution onto agent telemetry is exactly as painful as it is for every other metric source.
IaC note: Several of this month’s new arguments and API shapes are days old. Terraform AWS provider coverage lags service launches by design. Plan a bridge (CLI in a bootstrap step, CloudFormation, or  awscc ) for anything you need in IaC on day one, and verify parameter names against the current API reference before scripting into a pipeline.

Sources

Meridian Trust is an illustrative composite, not a real institution. Code samples reference APIs or arguments that shipped within days of publication — verify exact parameter names against current AWS documentation before use in production automation.

About the Author

Ashish Kasaudhan is a DevSecOps Architect with 17 years of experience across cloud infrastructure, containerization, CI/CD, and enterprise automation. He is an AWS Community Builders member and Ambassador. He writes regularly about cloud, DevOps, AIOps, and MLOps.
If this post was useful, connect on LinkedIn — he writes about this stuff regularly, and it’s worth having in your feed: 👉  linkedin.com/in/ashish-kasaudhan-713a4225 
And if you’re reading this on Medium — a clap (or ten) helps this reach more engineers dealing with the same untested IaC problem.
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