
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

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_pctSample — 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

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 serviceDesign 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
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_center10.20.0.0/16,claims-platform,CC-402110.30.0.0/16,payments,CC-408810.40.0.0/16,shared-services,CC-4000Sample — 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.jsonDesign 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
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 retentiontags = { 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
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 > 3Sample — 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_platformDesign 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

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 Decryptat 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 withsynthetics:GetCanarypermission (they see plaintext at read time)Client-side encrypt + runtime decryptAll of the above + console exposureCompromised canary execution role (it must holdkms: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
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-4021Sample — 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-alertsDesign 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
teamandcost_centerfrom 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:
- 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.
- 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.
- 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, orawscc) for anything you need in IaC on day one, and verify parameter names against the current API reference before scripting into a pipeline.
Sources
- CloudWatch Application Signals: Service Events Jul 6, 2026
- Amazon CloudWatch announces coding agent insights Jul 20, 2026
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.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article