The next developer interface is ambient intelligence

We’re witnessing a fundamental shift in how developers interact with their tools. Rather than clicking through dashboards, typing commands into terminals, or navigating complex UI menus, the next wave of developer interfaces uses AI, voice, and physical controls to let you simply express what you want to build. GitHub’s recent insights highlight that this isn’t science fiction—it’s happening now, and it fundamentally changes how you stay in flow while coding.

Staying Evergreen: How we automated secure access and repo hygiene in a shared org

Managing a shared GitHub organization is like maintaining a house—without regular upkeep, things get messy fast. Forgotten repositories accumulate, outside collaborator permissions drift from their original intent, and security gaps widen silently. GitHub’s recent engineering post tackles this exact problem by showing how to use native GitHub features to automatically review outside collaborator access and archive stale repositories. The result is a cleaner, more secure organization without manual overhead.

The technical approach here is straightforward but powerful. Instead of relying on manual quarterly audits (which inevitably slip), GitHub’s solution uses GitHub Actions workflows to programmatically check repository age, activity status, and collaborator permissions. The workflows query repository metadata through the GitHub API, identify repositories with no commits in a set timeframe, and flag collaborators who no longer need access. When conditions match—say, a repo hasn’t been touched in 12 months—the system can either trigger an archive workflow or open an issue for review. For access control, the automation checks collaborator relationships against teams and removes permissions that fall outside documented access policies. This runs on a schedule, meaning security decisions aren’t forgotten between audits.

The Shift to cgroup v2 in Kubernetes: What You Need to Know

If you’ve been running Kubernetes for a while, you’ve probably never thought much about cgroups. They work quietly in the background, making sure your containers get their fair share of CPU and memory without stepping on each other’s toes. But with Kubernetes v1.31, the landscape is shifting. The older cgroup v1 implementation is moving into maintenance mode, and cgroup v2 is becoming the standard. If you’re managing clusters—whether on AWS EKS or elsewhere—it’s worth understanding what’s changing and why it matters for your infrastructure.

GitHub's model for secret detection: Finding more secrets with less noise

Keeping secrets out of your repositories is one of the most critical security practices in cloud-native development, yet it remains surprisingly difficult at scale. Every day, thousands of credentials—API keys, database passwords, OAuth tokens—accidentally slip into version control systems. GitHub recently announced improvements to its secret detection system that use machine learning to identify real secrets while filtering out the false positives that plague traditional pattern-matching approaches. The result: 11.5% more genuine secrets detected with significantly less noise for developers to investigate.

AWS Lambda Web Functions

Amazon Web Services just announced Lambda Web Functions, a new serverless compute option designed specifically for running web applications and APIs at scale. Unlike traditional Lambda functions that handle individual requests in isolation, Web Functions natively support HTTP frameworks like Flask, Django, and Express, allowing you to deploy existing web applications without significant refactoring. This is a meaningful shift in how you can approach serverless architecture—rather than breaking your application into tiny function handlers, you can now run a full framework instance that handles multiple concurrent requests.

GitHub Copilot app for Beginners: How to teach Copilot about your codebase

GitHub Copilot has evolved beyond a simple autocomplete tool. The platform now lets you create custom applications that understand your specific codebase, follow your coding standards, and integrate with external services. Instead of Copilot making generic suggestions based on public code patterns, you can teach it about your project’s architecture, naming conventions, and business logic. This shift from one-size-fits-all AI assistance to personalized, context-aware coding help addresses a real problem: existing AI tools often don’t understand your internal frameworks, custom libraries, or the unique constraints of your infrastructure.

Restart EC2 and on-premises fleets faster with AWS CodeDeploy RESTART deployment mode

When you need to restart a fleet of servers, you typically face a choice: do it manually with SSH commands (risky and slow) or trigger a full redeployment (safe but overkill). AWS CodeDeploy now offers a middle ground with its new RESTART deployment mode, which reapplies your last successful application revision without waiting for a complete deployment pipeline. In testing, this approach ran up to 6.1x faster than standard deployments—a significant improvement when you’re troubleshooting production issues or recovering from a service degradation.

Building Git infrastructure for agent-scale development

GitHub just shared how they’re overhauling their Git infrastructure—and this matters more than it might initially seem. They’re essentially rebuilding the foundation that powers millions of repositories while keeping the platform running 24/7. Think of it like replacing the engine in a car while driving it down the highway. The scope here is massive: they’re preparing for a world where AI agents and automated systems will be committing code, running tests, and managing repositories at scales that would overwhelm today’s architecture.

Scaling Kubernetes Workloads with Node Swap

Memory constraints have become a silent bottleneck in modern Kubernetes deployments. Unlike CPU, which is easily divisible and throttleable, RAM is a hard limit—when a node runs out, pods get evicted. For teams running AI agents, large language models, or memory-intensive batch jobs, this constraint hits particularly hard. A single agent might need several gigabytes just to load its model weights, then sit idle consuming that memory while waiting for the next inference request. Multiply that across dozens of pods per node, and you’ve quickly hit a ceiling that prevents better resource utilization.

ReviewBench: An open benchmark for AI code review

Code review is one of those tasks that seems perfect for AI automation—it’s repetitive, rule-based, and something experienced developers do thousands of times. Yet evaluating whether an AI system actually performs well at code review has been surprisingly difficult. GitHub just released ReviewBench, an open benchmark designed to solve exactly this problem. If you’re working with AI code review tools or building automation for your development pipeline, understanding what makes this benchmark useful is worth your time.

AWS Weekly Roundup: Amazon Bedrock Managed Agents powered by OpenAI, Q3 service availability updates, Kiro workflows, and more (October 5, 2026)

Amazon Web Services announced a public preview of Bedrock Managed Agents powered by OpenAI this week, marking a significant development in how organizations can deploy AI agents within AWS. At its core, this offering combines OpenAI’s agent capabilities with AWS’s native infrastructure, allowing you to build autonomous AI systems that stay within your AWS environment rather than making external API calls. The service is built on a customized version of OpenAI’s Agents API, specifically engineered to integrate seamlessly with AWS resources like databases, Lambda functions, S3, and IAM permissions.

FabCon and SQLCon 2026 in Barcelona: Building the data foundation for Microsoft Copilot and agents

If you’ve been following the AI agent space, you know that even the best AI model is only as useful as the data it can access. Microsoft’s recent announcements at FabCon and SQLCon 2026 in Barcelona underscore this reality: they’re doubling down on data infrastructure as the critical foundation for enterprise AI. The focus here isn’t flashy AI features—it’s the plumbing. Microsoft Fabric and SQL innovations are designed to help organizations structure, govern, and prepare their data so that AI agents and Copilot instances can actually work reliably at scale.

SQL Server on Azure Local is now generally available

Azure just made a significant move for organizations that need database flexibility without abandoning the cloud. SQL Server on Azure Local is now GA, and it’s worth understanding what this means for your infrastructure decisions.

At its core, SQL Server on Azure Local lets you run SQL Server instances on your own hardware while still being part of the Azure ecosystem. Think of it as a hybrid approach—your database stays physically on-premises or in your own data center, but you get Azure management tools, licensing benefits, and the ability to integrate with cloud services. Technically, this works through Azure Arc, which extends Azure’s management plane to servers outside of Microsoft’s data centers. Your SQL Server instances communicate back to Azure, sending telemetry and receiving policy updates, while your actual data never leaves your infrastructure. It’s similar to how you might use Azure Arc for Linux or Windows servers, but purpose-built for database workloads.

Integrate AWS DevOps Agent with third-party tools using Amazon EventBridge

When something breaks in production, the clock starts ticking. Your team needs to investigate, communicate, and coordinate across multiple systems—often juggling Slack messages, Jira tickets, incident management platforms, and runbooks simultaneously. AWS DevOps Agent is designed to help teams investigate issues faster by automating the collection of troubleshooting data. But if those investigation events stay isolated within AWS, you’re missing an opportunity to automate downstream actions in the tools your team already uses daily. Amazon EventBridge bridges this gap, letting you automatically push DevOps Agent events to Jira, ServiceNow, PagerDuty, and other third-party platforms in real time.

Closed-loop incident response: connect AWS DevOps Agent to OpenSearch

We’ve all experienced it: an alert fires at 2 AM, you wake up, log in, and spend thirty minutes digging through logs to find what broke. By then, your team is already in the incident channel. What if that entire investigation—log searches, metric correlation, error pattern matching—happened automatically before a human ever saw the alert? AWS DevOps Agent now supports exactly this through integration with Amazon OpenSearch Service via the Model Context Protocol (MCP). Instead of receiving a symptom, you get context: the root cause, affected services, and correlated events, all waiting when you open your laptop.

Announcing AWS Well-Architected Agent, an AI-powered intelligence to optimize your cloud environment (preview)

AWS just released the Well-Architected Agent in public preview, and it’s solving a real problem many teams face: keeping up with optimization across a growing cloud environment. Instead of manually reviewing your architecture against best practices or hiring expensive consultants, this AI-powered service automatically analyzes your AWS setup and delivers actionable recommendations tailored to your specific workloads and business goals.

Here’s how it works under the hood. The Agent connects to your AWS environment through standard IAM permissions and uses machine learning to examine your resources—EC2 instances, RDS databases, Lambda functions, storage configurations, and more. It evaluates your setup against the five pillars of the AWS Well-Architected Framework: operational excellence, security, reliability, performance efficiency, and cost optimization. Rather than generic advice, the Agent understands your specific context—your application type, traffic patterns, compliance requirements—and surfaces recommendations that actually make sense for your situation. Think of it as having an AWS architect reviewing your account 24/7, catching inefficiencies you might miss.

Amazon S3 Tables now support all Apache Iceberg V3 data types

If you’ve been working with Apache Iceberg on AWS, you’ve probably noticed that data type support felt a bit inconsistent. That’s changing. Amazon S3 Tables—AWS’s managed implementation of Iceberg—now supports the complete set of data types defined in the Apache Iceberg V3 specification. This includes nested complex types like structs, lists, and maps, plus new capabilities like column default values, deletion vectors, and row lineage tracking. For teams building data lakes on S3, this is a meaningful step toward better schema flexibility and data management without the operational overhead.

Amazon S3 Vectors now supports metadata pre-filtering for higher recall on filtered searches

Vector databases have become essential infrastructure for AI applications, but they’ve had a consistent pain point: filtering. Traditionally, most vector search systems would find similar items first, then apply filters to results—meaning you’d lose potentially relevant matches if they didn’t make the initial similarity cut. Amazon S3 Vectors just changed that approach. The service now supports metadata pre-filtering, which evaluates your filter conditions before the similarity search happens. According to AWS, this delivers up to 5x higher recall on filtered searches, which is significant when you’re building applications where missing relevant results can degrade user experience.

Amazon Aurora PostgreSQL now supports direct querying of Apache Iceberg and Parquet data in your data lake

If you’ve ever built a data pipeline, you know the frustration: your operational database has real-time transaction data, but your analytics team needs to query historical data sitting in S3. Traditionally, this meant building ETL jobs to synchronize data between systems, maintaining duplicate copies, and dealing with consistency headaches. Amazon Aurora PostgreSQL just eliminated that problem. You can now query Apache Iceberg and Parquet files directly from your data lake alongside your live operational data—all in a single query, using standard PostgreSQL syntax.

How we found 24 Android vulnerabilities using our open source AI security agent

If you’ve been following the intersection of AI and security, you’ve probably noticed a shift: instead of AI being used primarily to detect threats after the fact, teams are now using it proactively to hunt for vulnerabilities before attackers do. GitHub recently demonstrated this approach by deploying an open-source AI security agent that uncovered 24 previously unknown vulnerabilities in Android apps. This isn’t just another security scanner—it’s a practical example of how AI agents can augment human expertise by performing targeted, intelligent code analysis at scale.

Building a Slack-powered AI development agent with Kiro CLI and headless authentication

Every code review discussion, incident response thread, and standup happens in Slack. But when an engineer needs to analyze a service or debug a failing test, they leave Slack, open a terminal, navigate to the repository, run commands, and paste the output back. That context switch—even if it only takes 30 seconds—breaks flow and creates friction. What if those development tasks could happen right where the conversation is already happening?

How Property Finder automated incident management with AWS DevOps Agent

Imagine receiving an alert about a production issue, having it automatically analyzed, a ticket created, the on-call engineer paged, and a fix deployed—all before most teams would finish their morning coffee. That’s the reality at Property Finder, a major property marketplace, which built an end-to-end autonomous incident management system using AWS DevOps Agent. What once took 2-3 days from initial detection to resolution now completes in 14 minutes. This isn’t science fiction; it’s what’s possible when you combine observability, automation, and AI-powered agents working together.

Audit trails for autonomous agents with AWS DevOps Agent

Autonomous agents are reshaping how teams respond to production incidents. AWS DevOps Agent can investigate issues, propose fixes, and even apply changes automatically—but this power comes with a responsibility: understanding exactly what happened and why. Every action an agent takes needs to be traceable, auditable, and explainable. This is where audit trails become essential infrastructure rather than a compliance checkbox.

The challenge is straightforward: when an autonomous system makes decisions and takes actions in your production environment, you need a complete record. Not just what changed, but what the agent observed, how it reasoned about the problem, and what it decided to do about it. AWS provides the building blocks to construct this audit trail through three interconnected components. The agent journal captures the agent’s internal reasoning and decision-making process. Amazon EventBridge lifecycle events track when the agent starts, completes, or fails specific tasks. AWS CloudTrail records the actual API calls the agent makes to modify your infrastructure. Together, these three create a complete narrative of agent activity that you can query, analyze, and reference during incident reviews.

Introducing enhanced custom event buses in Amazon EventBridge for enterprise-scale event-driven applications

Blank line

When your organization grows beyond a handful of teams, managing event-driven architectures becomes complicated. Different teams need to publish and consume events, but they operate across separate AWS accounts for isolation and billing purposes. Amazon EventBridge just addressed this pain point with enhanced custom event buses that let you deploy a single shared event bus across your entire AWS organization. Instead of managing separate event buses per account and building custom routing logic between them, you now get a unified bus with built-in support for event ordering, simplified subscriber management, and better pricing at scale.

GitHub Copilot app for Beginners: How to build custom workflows with canvases

GitHub has released a new feature that lets you describe what you need in plain English and have Copilot generate a working interface on the fly. Instead of fighting with UI frameworks or learning yet another tool’s documentation, you tell Copilot what you want—“I need a form that collects AWS region, instance type, and spot price”—and it builds an interactive canvas you can immediately use and refine. This shifts the bottleneck away from tool friction and toward actual problem-solving.

Docker and CNCF partner on an open spec for agent permissions

Imagine deploying an AI agent that needs to call your AWS APIs, access a database, or interact with your Kubernetes cluster. Right now, you probably handle permissions the same way you would for a human user—IAM policies, service accounts, API tokens. But AI agents operate differently. They make autonomous decisions and need fine-grained, revocable permissions that can change mid-execution. Docker and the Cloud Native Computing Foundation are addressing this gap by standardizing how AI agent permissions work through the Sandbox Kit Spec, a vendor-neutral standard built on existing OCI (Open Container Initiative) foundations.

Ship agents faster with expanded model choice, voice agents, and continuous optimization

The AI model landscape shifts constantly. What powers your chatbot today might have a cheaper, faster, or more capable replacement next month. Microsoft’s latest Azure updates address a real pain point: how do you adopt better models without tearing down your entire agent architecture? The short answer is abstraction—building systems flexible enough to swap underlying models without rewriting application logic.

Think of it like database migration strategies you might already know. Just as you can move from PostgreSQL to DynamoDB without rewriting your entire application (if you’ve abstracted your data layer properly), you should be able to swap from GPT-4 to a specialized smaller model without rebuilding your agent. Azure’s expanded model choice means you can deploy agents with Claude, Gemini, open-source models, or Azure’s own models through a consistent interface. Technically, this works through standardized API contracts and prompt templating—your agent’s decision logic stays the same whether you’re calling a 7B parameter model or a 70B one. The runtime handles the differences. This matters because smaller models cost less to run, some excel at specific domains (like code generation or math), and open-source options let you run models on your own infrastructure if you need it.

AI-powered fuzzing with the GitHub Security Lab Taskflow Agent

Finding security vulnerabilities before attackers do is one of the hardest problems in software development. Traditional fuzzing—bombarding code with random or semi-random inputs to find crashes and bugs—requires significant computational resources and expertise to set up effectively. GitHub’s Security Lab has released a new approach that combines AI with fuzzing, making it more accessible to developers who want to strengthen their application security without becoming fuzzing experts.

The Taskflow Agent framework handles the repetitive work of setting up and running fuzzing campaigns. Instead of manually crafting fuzzing configurations, writing input generators, and analyzing crash dumps, you describe what you want to test and let the AI coordinate the fuzzing workflow. Technically, the agent works by breaking down your fuzzing goals into discrete tasks: identifying entry points in your code, generating appropriate test cases, executing them against your application, and triaging the results. It integrates with GitHub’s existing infrastructure and leverages machine learning to learn which fuzzing strategies work best for your specific codebase. If you’ve written automation scripts in Python to orchestrate multiple tools, you’ll recognize the pattern—this does that orchestration intelligently, using AI instead of hardcoded logic.

Designing agent-first platforms: What changes when agents do the work

The software architecture decisions you made five years ago probably don’t fit the AI-powered world your organization is entering now. According to recent insights from Microsoft Azure, organizations that are actually pulling ahead aren’t just bolting AI onto their existing systems—they’re rethinking the fundamental structure of how applications work. When you shift from human-directed tasks to AI agents autonomously completing work, almost everything changes: how you design APIs, structure data, handle errors, and measure success.

From Dockerfile to Kit: the Docker Sandboxes Kit Specification

Docker just released the Sandbox Kit Specification v3, and it’s a quiet but meaningful shift in how we can package and deploy AI agents safely. Instead of thinking of sandboxes as temporary, throwaway environments, this spec treats them like first-class artifacts—complete with networking rules, credentials, and storage volumes baked into a standard OCI image. That means you can version, share, and reproduce an entire agent sandbox the same way you’d handle any containerized application.

Rendering huge pull requests in the GitHub Copilot app

GitHub recently shared how they tackled a significant engineering challenge: making the Copilot app capable of handling enormous pull requests—we’re talking million-line diffs with hundreds of inline comments. Most developers work with reasonably-sized PRs, but in large organizations, monorepos, and automated refactoring scenarios, you encounter PRs that would choke traditional interfaces. The team at GitHub had to completely rebuild how the Copilot app renders diffs to make this possible without degrading performance for typical use cases.

Introducing Amazon CloudWatch Omni: AI-powered observability for generative AI and agentic workloads

If you’ve been building with large language models or AI agents lately, you’ve probably hit a frustrating wall: traditional observability tools weren’t designed for this. You can see that your Lambda function executed in 200ms, but you can’t see why your AI agent made a particular decision, which retrieval-augmented generation (RAG) source it used, or whether the model’s response was actually correct. CloudWatch Omni changes that. AWS’s new observability solution is purpose-built to trace, evaluate, and debug generative AI workloads—giving you visibility into the exact decisions and reasoning your agents make, not just whether they ran successfully.

Introducing Amazon CloudWatch Omni: collaborative AI-powered observability for your applications

The observability landscape has become increasingly fragmented. Teams juggle metrics from CloudWatch, traces from X-Ray, logs from multiple sources, and topology information scattered across dashboards. When something breaks at 2 AM, piecing together the story of what happened requires jumping between tools and correlating data manually. Amazon CloudWatch Omni addresses this fragmentation by creating a unified observability platform where your applications and AI agents work together to diagnose issues faster.

Kubernetes v1.37: Tracking When a PersistentVolumeClaim Was Last Used (Beta)

Storage costs in Kubernetes can quietly spiral out of control. You provision a PersistentVolumeClaim (PVC) for a service, the service gets updated or removed, but the storage claim lingers—still incurring charges, still consuming quota. Until now, figuring out which PVCs were actually in use meant writing custom scripts to cross-reference pods with their volume mounts. Kubernetes v1.37 changes this with the promotion of PersistentVolumeClaimUnusedSinceTime to Beta, a feature that automatically tracks whether any running pod is currently using a PVC.

The Economics of Agent Optimization: How AI agent governance controls cost and proves ROI

AI agents sound great in theory—autonomous systems that handle tasks without human intervention. But in practice, they can become expensive black boxes. A poorly managed agent might run redundant API calls, retry failed operations unnecessarily, or spin up compute resources that sit idle. This is where governance comes in. Microsoft’s latest installment on agent economics tackles the unsexy but critical problem: how to actually control what your agents spend and prove they’re worth the investment.

AWS Elastic Beanstalk introduces Cluster Mode

If you’ve ever felt caught between the simplicity of managed platforms and the control of managing your own infrastructure, AWS just released something worth your attention. Elastic Beanstalk’s new Cluster Mode removes the middle-ground friction by letting you deploy containerized applications without worrying about the underlying compute layer. You bring the container image or source code; Elastic Beanstalk handles provisioning, scaling, and operating the infrastructure automatically.

Here’s what’s happening under the hood. In traditional Elastic Beanstalk, you still make decisions about EC2 instance types, Auto Scaling Groups, and load balancer configuration. With Cluster Mode, that responsibility shifts entirely to AWS. You define your application (via container image or buildpack-based source code), set scaling policies based on metrics you care about, and Elastic Beanstalk orchestrates the compute resources for you. It’s similar conceptually to how Lambda abstracts away servers, but for longer-running, stateful applications that need persistent compute. Technically, this sits between serverless and traditional IaaS—you get the operational simplicity without sacrificing the application model flexibility that containers provide.

Kubernetes v1.37: Hardening Container Storage with Bind Mount Options and EmptyDir Permissions

Kubernetes v1.37 introduces two significant storage security features that give you finer control over how containers access shared volumes. The release adds permission modes for emptyDir volumes and configurable bind mount options, letting you enforce stricter access controls directly in your pod specifications. These aren’t flashy features, but they address a real gap: until now, your options for restricting what containers could do with mounted storage were limited. You could use network policies and RBAC for API access, but storage security often relied on external solutions or manual enforcement.

Migrating the GitHub Copilot runtime to Rust, using Copilot

GitHub’s recent migration of their Copilot agent runtime from Node.js to Rust represents a significant shift in how large-scale infrastructure rewrites happen in the AI era. The project involved converting roughly 800,000 lines of production code—a task that would have been prohibitively expensive and time-consuming just a few years ago. What makes this story relevant to you isn’t just the technical achievement, but the process: GitHub used AI agents to automate much of the heavy lifting, demonstrating a practical pattern for modernizing legacy systems that’s becoming increasingly viable for mid-to-large engineering teams.

Kubernetes v1.37: Pod-Level Resource Managers graduated to Beta

Kubernetes v1.37 marks an important milestone with Pod-Level Resource Managers moving from Alpha to Beta status. While the feature remains disabled by default, this graduation signals that the Kubernetes community considers it stable enough for wider testing and real-world evaluation. If you’re running Kubernetes clusters and struggling with resource contention between containers in the same pod, this feature deserves your attention.

Pod-Level Resource Managers addresses a fundamental challenge in Kubernetes: managing CPU and memory resources across containers that share the same pod. Previously, you could set resource requests and limits at the container level, but you had limited control over how those resources were actually allocated and managed when multiple containers competed for them. This new feature lets you define policies at the pod level that govern how the Linux kernel distributes CPU cycles and memory among containers. Under the hood, it works by leveraging Linux cgroups v2 and kernel resource control mechanisms—when enabled, Kubernetes automatically configures the cgroup hierarchy to enforce your pod-level policies before applying container-level constraints. This two-tier approach gives you finer-grained control without requiring changes to your application code.

Microsoft named a Leader in the 2026 Gartner® Magic Quadrant™ for Container Management

Container management has become critical infrastructure for modern cloud deployments, and Microsoft’s recognition as a Leader in Gartner’s 2026 Magic Quadrant reflects its growing maturity in this space. For teams evaluating container platforms, this distinction signals that Azure’s container offerings—particularly Azure Kubernetes Service (AKS), Azure Arc, and Azure Container Apps—have reached a level of capability and execution that rivals established competitors. If you’re building on AWS or exploring multi-cloud strategies, understanding what makes Microsoft’s approach different matters for your architecture decisions.

Marketing ops as code: Automating events from planning to follow-up on GitHub

When GitHub’s APAC marketing team needed to scale their event operations, they faced a familiar problem: repetitive manual tasks eating up engineering and operations time. The solution? Treating marketing operations like software infrastructure. By documenting their event workflows and codifying them on GitHub—using issues, pull requests, and automation—they transformed a labor-intensive process into a streamlined, repeatable system. This approach demonstrates how ops-as-code principles extend far beyond infrastructure management into business operations.

Kubernetes v1.37: Native Histograms Graduates to Beta

If you’ve ever tried to troubleshoot performance issues in Kubernetes, you know the pain of piecing together metrics to understand what’s actually happening. You might see average latency is fine, but suspect something’s wrong with outliers. Or you’re drowning in cardinality from high-dimensional metrics that make your monitoring system groan. Kubernetes v1.37 addresses this head-on by graduating native histogram support to Beta—and enabling it by default. This is a meaningful shift in how you’ll be able to observe your clusters.

GitHub Copilot app for Beginners: Using the diff, terminal, and browser

If you’ve started using GitHub Copilot for code generation, you’ve probably noticed the workflow friction: AI suggests a change, you review it in one tab, switch to terminal to test it, then jump to a browser tab to see if the web app actually works. The GitHub Copilot app aims to eliminate this context-switching by bringing diffs, terminal output, and live previews into a unified interface. For developers working on automation scripts, cloud infrastructure code, or full-stack applications, this consolidation saves real time and reduces the cognitive load of tracking changes across multiple windows.

Kubernetes v1.37: Scheduler Preemption for In-Place Pod Resize (Alpha)

Kubernetes v1.37 introduces a significant enhancement to how the scheduler manages resources: preemption support for in-place pod resizing. This new alpha feature builds on the in-place pod resize capability that reached general availability in v1.35, allowing the scheduler to automatically free up resources by evicting lower-priority pods when a higher-priority pod needs to grow within its current node. Instead of waiting for a pod to be rescheduled elsewhere, the scheduler can now make smarter decisions about which workloads should give up resources right away—a meaningful shift in how Kubernetes handles dynamic resource allocation.

Introducing Amazon EBS Volume Clones across AWS accounts

AWS has rolled out a new capability that simplifies how teams share and replicate storage across organizational boundaries: Amazon EBS Volume Clones now support cross-account copying. If you’ve managed multiple AWS accounts—whether for different teams, environments, or business units—you know that moving data between them traditionally meant either creating snapshots, copying them across accounts, and then restoring them, or using more complex workarounds. This new feature streamlines that workflow significantly. You can now create direct copies of your EBS volumes in other AWS accounts and optionally re-encrypt them using a KMS key in the target account, all without leaving the AWS console or API calls.

How GPT-5.6 Sol helps run quantum computing experiments

Quantum computing is notoriously difficult to work with. Qubits are fragile, calibration is complex, and experimentation requires constant iteration. An MIT researcher recently demonstrated how GPT-5.6 Sol—paired with Codex for code generation—can autonomously manage this entire workflow. Instead of manually writing scripts, debugging calibration issues, and analyzing results, researchers can now describe their experimental goals in natural language and let the AI handle the technical execution. This represents a meaningful shift in how scientists interact with quantum hardware: less time wrestling with infrastructure, more time asking interesting questions.

Kubernetes v1.37: Advancing Workload-Aware Scheduling

If you’ve ever deployed machine learning training jobs or complex batch processing on Kubernetes, you’ve probably run into the same frustration: your workload gets scattered across the cluster in inefficient ways, or worse, it partially schedules and then stalls because not all its components can run together. Kubernetes v1.37 tackles this head-on with significant improvements to Workload-Aware Scheduling (WAS), a capability designed specifically for AI/ML and batch workloads that have interdependent components. The release brings the core Workload and PodGroup APIs into stable territory, making gang scheduling—where multiple pods must be scheduled together or not at all—a first-class citizen in Kubernetes rather than an experimental feature you have to enable separately.

Amazon EC2 R9g and R9gd instances powered by AWS Graviton5 processors are now generally available

AWS just released the R9g and R9gd instances, which are memory-optimized EC2 instances built on the latest AWS Graviton5 processors. These new instances deliver up to 25% better compute performance compared to their R8g predecessors, making them a notable upgrade for workloads that demand both raw processing power and large amounts of RAM. The R9g comes with local NVMe storage options via the R9gd variant, giving you flexibility depending on whether you need persistent local disk performance alongside your memory capacity.

AWS Weekly Roundup: Claude Fable 5.1 on AWS, Amazon Linux 2027 preview, AWS Certified AI Business Strategist, and more (September 7, 2026)

Last week brought several significant updates to the AWS ecosystem that deserve your attention. The headline news is Claude Fable 5.1’s arrival on AWS through Amazon Bedrock, Anthropic’s newest frontier AI model designed for complex, long-running tasks. Alongside this, AWS previewed Amazon Linux 2027, its next-generation operating system, and introduced the AWS Certified AI Business Strategist certification—signaling AWS’s push to democratize AI skills beyond pure engineering roles. If you’re building on AWS, keeping tabs on these releases matters for staying competitive.

Generative AI to quantify uncertainty in weather forecasting

Weather forecasting has always been a probability game. Meteorologists know that tomorrow’s forecast is more reliable than next week’s, but quantifying how much uncertainty exists at each prediction point has remained challenging. Google Research recently published work on using generative AI to measure this uncertainty, moving beyond simple confidence scores to provide detailed, probabilistic forecasts that better reflect the actual range of possible outcomes.

The approach leverages diffusion models—the same generative AI architecture behind image generation tools—to learn the distribution of possible weather outcomes rather than just predicting a single “best guess.” Here’s how it works technically: the model is trained on historical weather data to understand how atmospheric conditions evolve and what variations are plausible. When making a forecast, instead of outputting one temperature or precipitation value, the AI generates multiple possible scenarios, each representing a different but realistic weather trajectory. By sampling many scenarios, forecasters get a full probability distribution. This means you don’t just see “80°F tomorrow,” but understand whether that’s a likely outcome with 90% confidence or a possible outcome with 40% confidence—a critical distinction for decision-making.

Kubernetes v1.37: Scale Workloads to Zero with HorizontalPodAutoscaler

Kubernetes v1.37 just shipped a feature that could meaningfully reduce your cloud bill: the ability to scale workloads down to zero replicas using HorizontalPodAutoscaler (HPA). Previously, HPA would scale your deployments down to a minimum of 1 replica, keeping at least one pod running at all times. Now in Beta and enabled by default, HPA can completely remove pods when they’re not needed, then spin them back up instantly when demand returns.

GPT-6 Astra: Frontier intelligence for work, now available in Microsoft Foundry

OpenAI’s latest frontier model, GPT-6 Astra, is rolling out today through Microsoft’s Foundry platform, marking another step in making advanced AI accessible to enterprise users. If you’ve been following the AI space, you know that each generation of these models brings meaningful improvements in reasoning, context understanding, and task execution. GPT-6 Astra is designed specifically for work—think document analysis at scale, complex decision support, and multi-step automation workflows. The Limited Access Program means early adopters can start testing it now, with broader availability expanding over the coming days.

Kubernetes v1.37: KubeletInUserNamespace (aka Rootless mode) Graduates to Beta

Kubernetes v1.37 has moved the KubeletInUserNamespace feature to beta, marking a significant step toward more secure container orchestration. This feature allows all node-level components—the kubelet, container runtimes, CNI plugins, and kube-proxy—to run without root privileges by leveraging Linux user namespaces. If you’ve been following Kubernetes security best practices, you know that running workloads as non-root is standard advice for containers. With this feature, that same principle now extends to the infrastructure managing those containers. This shift from alpha to beta means the Kubernetes maintainers consider it stable enough for production use, though it still requires explicit opt-in via a feature gate.

Project HydraFusion: Frontier quality via multi-model orchestration

GitHub’s new Project HydraFusion represents a meaningful shift in how AI coding assistants can deliver better results without necessarily paying for the most expensive models. Instead of always routing requests to the largest, most capable model available, HydraFusion intelligently selects which AI model to use based on the specific coding task at hand. Think of it like having different specialized tools in your toolkit—you wouldn’t use a sledgehammer to hang a picture frame, and you shouldn’t always route simple variable naming questions to your most expensive inference engine.

GitHub Copilot app for Beginners: Run several agents at once

The GitHub Copilot app is evolving beyond a single AI assistant into a multi-agent orchestration platform. While many developers use Copilot as a code autocomplete tool, the newer capability of running parallel agents opens up new possibilities for automating complex workflows. Think of agents as specialized AI workers—one might focus on code generation, another on testing, and another on documentation. Instead of doing these tasks sequentially, you can spin up multiple agents simultaneously to tackle different aspects of your project at the same time. This shift from single-threaded assistance to parallel processing is where AI tooling becomes genuinely useful at scale.

Automate planned lifecycle upgrades with AWS DevOps Agent and Kiro

Running managed services on AWS means staying on top of version lifecycles. When RDS reaches end of standard support for PostgreSQL 14, or your Elasticsearch cluster hits the upgrade deadline, you need a plan—and you need it soon. AWS Health Planned Lifecycle Events notify you when this happens, but notification alone doesn’t solve the problem. Someone still needs to investigate compatibility, test the upgrade path, update your infrastructure code, and push it through review. That’s where automation comes in. Using AWS DevOps Agent paired with Kiro, you can transform these notifications into automatic pull requests with validated code changes, cutting the manual investigation work from hours to minutes.

Automating the Experimentation Lifecycle with Kiro, AWS DevOps Agent, and LaunchDarkly

Continuous improvement lives or dies by experimentation. Every team wants to test changes against real users, measure outcomes, and iterate quickly—but the operational overhead often kills momentum. Setting up experiments, managing feature flags, analyzing results, and rolling back failed changes requires coordination across multiple tools and manual handoffs. What if that entire cycle could be automated?

AWS DevOps Agent (Kiro) integrated with LaunchDarkly offers a practical answer to this problem. At its core, Kiro acts as an orchestrator that connects your development workflow to feature management infrastructure. When you propose an experiment, instead of manually spinning up environments, toggling flags, and monitoring metrics, Kiro can automate those steps by coordinating with LaunchDarkly’s feature flag API. You define the experiment parameters—target audience segment, traffic allocation, success metrics—and Kiro handles the sequencing: deploying code, gradually rolling out the feature flag to your specified cohort, collecting telemetry, and executing rollback logic if defined thresholds aren’t met. For teams using AWS infrastructure, this integrates naturally into your existing DevOps pipelines and observability tools like CloudWatch.

Building Reproducible AI Evaluation Workflows with Docker Sandboxes

When you’re evaluating AI models in production, consistency matters. You might train a model that performs beautifully on your laptop, but when it runs in a different environment—different Python versions, missing dependencies, or varying system libraries—results diverge. This is where Docker Sandboxes come in. They provide isolated, containerized execution environments that ensure your AI evaluation workflows produce identical results every time, regardless of where they run. For teams building on AWS, this means you can evaluate models locally, then confidently deploy that same evaluation pipeline to production with the assurance that nothing will break due to environmental drift.

Kubernetes v1.37: etcd RangeStream Cuts Memory Use on Large List Reads

If you’ve managed a large Kubernetes cluster, you’ve probably experienced that moment when listing all resources—pods, services, configmaps—suddenly spikes memory usage on your API server. That’s about to get easier to handle. Kubernetes v1.37 is bringing etcd RangeStream to beta, a feature that fundamentally changes how the API server retrieves large collections of objects from etcd. Working in tandem with etcd v3.7, RangeStream reduces memory consumption and makes resource usage more predictable, which matters a lot when you’re running thousands of resources across multiple namespaces.

Kubernetes v1.37: Storage Version Migration Enabled by Default

Kubernetes v1.37 marks a significant milestone with Storage Version Migration (SVM) graduating to General Availability. This means the built-in StorageVersionMigration API and its control plane controller are now stable and enabled by default across all v1.37 clusters. If you’ve been running Kubernetes in production, you’ve likely encountered the challenge of updating how data is stored in etcd—the distributed database backing your cluster. SVM automates what was previously a manual, error-prone process, letting you update storage formats without downtime or data loss.

Optimize EKS operations with agents: Reduce MTTR with AWS DevOps Agent and a Kubernetes Operator

Managing Amazon EKS clusters at scale introduces a familiar problem: when something breaks at 2 AM, your team needs answers now, but critical diagnostic data vanishes the moment a pod restarts or a node becomes unhealthy. Engineers spend precious minutes collecting pod logs, tracing events across namespaces, and correlating node metrics—all before they can even begin fixing the actual issue. This diagnostic overhead directly impacts Mean Time To Resolution (MTTR), especially during off-hours when context-switching costs are highest. AWS DevOps Agent, combined with a Kubernetes operator, automates this entire collection phase, letting you focus on solving problems instead of gathering information.

The Economics of Agent Optimization: Four ways to lower the cost

AI agents are becoming central to enterprise automation, but their operational costs can spiral quickly. Every API call, token processed, and model invocation adds up—especially when agents run at scale. Microsoft’s recent exploration of agent optimization through Azure Foundry highlights a practical reality: you don’t always need to rewrite your agent logic to reduce expenses. Instead, there are four systematic levers you can pull that apply to every request, before your agent even executes a single line of code.

From clickops to governed IaC: CloudFormation drift detection in practice

Most AWS environments start clean. You provision a VPC, spin up an EC2 instance or two, maybe add a database. But six months later, after late-night hotfixes, quick security patches, and those “temporary” changes that never got reverted, your infrastructure has drifted far from your original templates. A security group rule got added manually. An RDS parameter was tweaked through the console. Suddenly, you’re not sure what your actual infrastructure looks like anymore—and neither is your IaC template. This is ClickOps: infrastructure changes made outside of version control, and it’s one of the most common pain points teams face at scale.

Kubernetes v1.37: Metrics API graduates to stable

The Kubernetes project just moved the Metrics API to stable status in version 1.37, marking a significant milestone for observability and resource management in Kubernetes clusters. The metrics.k8s.io API has been a critical component of Kubernetes operations for years, but living under beta status meant it could change without warning. Now that it’s reached v1 stability, cluster operators and platform teams can rely on it as a permanent fixture of the Kubernetes API landscape. This graduation removes uncertainty from production deployments and gives organizations confidence that their monitoring and autoscaling workflows won’t break with future Kubernetes upgrades.

AI-driven software delivery with Kiro, AWS DevOps Agent and Bluebox by Dynatrace

As AI tools become standard in development workflows, teams face a new challenge: generated code works great in isolation, but production environments have their own demands. Your services handle real traffic patterns, depend on other systems that might fail, and run within compute limits that can’t scale infinitely. A smart code generation tool needs to understand these constraints, not just write syntactically correct Python or deploy-ready infrastructure. That’s the gap that AI-driven software delivery—powered by tools like Kiro, AWS DevOps Agent, and Dynatrace’s Bluebox—is designed to close.

GitHub Copilot app for Beginners: Automate Dependabot pull request triage

Managing dependencies is one of those necessary-but-tedious tasks that eats up developer time. Every week, your repositories get new pull requests from Dependabot—a tool that automatically detects outdated libraries and security vulnerabilities. Each one needs review: Does this library have breaking changes? Is this security update urgent? Can we batch updates together? When you’re maintaining multiple projects, this repetitive triage work can consume hours that you’d rather spend on feature development.

Kubernetes v1.37: Garhwal

Kubernetes v1.37, nicknamed Garhwal, represents another steady iteration in the world’s most widely used container orchestration platform. Released as part of Kubernetes’ predictable three-month release cycle, this version brings a mix of stable features moving out of beta, new experimental capabilities in alpha, and refinements to existing functionality. For teams running production workloads on Kubernetes—whether on AWS EKS, self-managed clusters, or other platforms—understanding what’s new helps you plan upgrades and take advantage of improvements that can enhance reliability, observability, and resource efficiency.

How to evaluate LLMs before production

When GitHub decided to enhance their secret scanning capabilities with large language models, they faced a critical question: How do you know if an LLM is actually ready for production? This isn’t just an academic concern—deploying an LLM that misses secrets or generates false positives can have real security implications. GitHub’s engineering team shared their evaluation framework, and it offers practical guidance for anyone considering LLMs in their own systems. The core insight is straightforward but often overlooked: benchmark testing against your specific use case matters far more than raw model size or hype.

AWS Glue 6.0 now available with 30% lower price and full Apache Iceberg v3 support

AWS Glue 6.0 is here, and it brings meaningful improvements to your data pipeline economics. Built on Apache Spark 4.1, Python 3.12, and Scala 2.13, the new runtime delivers a 30% cost reduction compared to previous Glue versions—a significant win if you’re running data transformation jobs at scale. Beyond pricing, native Apache Iceberg v3 support means your data lake architecture gains better performance, schema evolution, and time-travel capabilities without additional workarounds.

Running AI agents in GitHub Actions with Docker Sandboxes

The intersection of AI and automation is reshaping how development teams handle repetitive tasks. One particularly practical application is using AI agents within GitHub Actions—your existing CI/CD pipeline—to automatically fix failing tests, improve code, and even open pull requests. Docker Sandboxes provide the isolation layer that makes this safe and manageable. Instead of granting AI agents direct access to your codebase, they operate in containerized environments where their actions are controlled, monitored, and reversible. This approach lets you leverage AI capabilities without the anxiety of autonomous systems making uncontrolled changes to production code.

Automate SageMaker HyperPod incident triage and root-cause-analysis with AWS DevOps Agent

Managing large-scale machine learning infrastructure is like herding cats—except the cats are GPU instances, there are hundreds of them, and they’re training models worth millions of dollars. When you’re running multi-week training jobs across thousands of GPUs, hardware failures, node crashes, and resource contention don’t just happen occasionally; they’re guaranteed. The challenge isn’t whether problems will occur—it’s how quickly you can identify what went wrong and get your cluster back online. AWS DevOps Agent, now integrated with SageMaker HyperPod, automates the tedious work of incident triage and root-cause analysis, turning hours of manual investigation into minutes of automated diagnostics.

How canvases make agentic workflows visible, steerable, and cost-efficient

If you’ve spent the last few months experimenting with AI agents—whether that’s Claude, ChatGPT, or custom Lambda functions orchestrating AWS services—you’ve probably hit the same wall: chat interfaces collapse under complexity. Your agent makes ten decisions, runs five API calls, generates three artifacts, and by the time something goes wrong, you’re scrolling back through dozens of messages trying to reconstruct what actually happened. GitHub’s canvas feature addresses this directly by giving agentic workflows a dedicated workspace instead of burying them in conversation history. For teams building automation on AWS or deploying multi-step AI workflows, this changes how you monitor, adjust, and optimize agent behavior in production.

Streamline your GitHub journey with AWS CodePipeline and AWS DevOps Agent

The frustration is familiar: your CI/CD pipeline fails at 2 AM. Your team gets paged. Someone spends the next three hours jumping between CloudWatch logs, CodePipeline stages, GitHub commits, and various AWS service consoles trying to piece together what went wrong. Meanwhile, your deployment sits blocked, and the clock keeps ticking. This is where AWS DevOps Agent comes in—a tool designed to cut through that investigation nightmare by automating the detective work that typically eats up hours of your team’s time.

How to bring your software delivery workflow into GitHub with agent apps

GitHub has introduced Agent Apps, a new category of AI-powered tools designed to automate key stages of software delivery directly within GitHub. Rather than context-switching between multiple platforms, these agents handle scoping, security, rollout planning, and shipping—keeping your entire workflow in one place. This represents a practical shift in how teams can streamline their SDLC without abandoning their existing GitHub-centered processes.

From a technical perspective, GitHub Agent Apps operate as specialized AI assistants that integrate with GitHub’s API and understand the context of your repositories, pull requests, and deployment pipelines. When you invoke an agent, it analyzes your codebase, examines existing issues and PRs, and can even interact with external systems through API calls. For example, a scoping agent might automatically break down a feature request into actionable tasks by examining your code structure and suggesting implementation paths. A security agent could scan your dependencies and PRs for vulnerabilities before they reach production, while a rollout agent helps orchestrate deployments by understanding your infrastructure setup and suggesting safe deployment strategies. Under the hood, these agents leverage large language models combined with retrieval-augmented generation (RAG) to ground their suggestions in your actual code and organizational context.

What 50 open source projects taught us about security in the AI era

GitHub’s Secure Open Source Fund just wrapped Session 4, bringing together 50 open source projects to tackle a problem that keeps security teams up at night: how to maintain code quality and catch vulnerabilities when your maintainers are stretched thin. The initiative combined AI-assisted workflows, expert guidance, and actual funding to see what actually works in the real world. The results? A practical playbook for securing open source projects without burning out the people running them.

Write your first prompt with the GitHub Copilot app

GitHub Copilot has evolved beyond an IDE extension into a standalone app that brings AI-assisted coding into a more flexible workflow. If you’ve been curious about leveraging AI for code generation but weren’t sure where to start, the Copilot app offers a more approachable entry point than ever before. At its core, it’s a conversational interface where you describe what you want to build, and the AI suggests code implementations based on patterns it learned from billions of lines of public code. For developers working in cloud infrastructure, automation scripts, or data processing workflows, this can significantly reduce boilerplate writing and accelerate prototyping.

Extending AWS Transform custom with MCP Servers for End-to-End Code Modernization

When you’re managing a large codebase migration—say, upgrading from Python 2 to Python 3, or refactoring monolithic applications into microservices—the bottleneck isn’t usually the code transformation itself. It’s everything around it: tracking what changed, running tests, updating your repository, notifying teams. AWS Transform custom already handles the transformation logic, but it operates in isolation. By integrating Model Context Protocol (MCP) servers, you can connect it to your entire development workflow. MCP acts as a bridge, letting your transformation tool communicate directly with project management systems, CI/CD pipelines, version control, and testing frameworks. This means a single transformation job can automatically update tickets, push changes to Git, run test suites, and log results—all without manual handoffs.

Using the GitHub Copilot SDK for Java

GitHub has released an official SDK for Java that lets developers integrate GitHub Copilot directly into their applications through idiomatic Java code. Instead of relying solely on the web interface or IDE extensions, Java developers can now programmatically access Copilot’s AI capabilities—whether they’re building enterprise tools, automation platforms, or custom development workflows. This represents a significant shift in how enterprises can operationalize AI-assisted code generation at scale.

The technical implementation leverages modern Java features to keep the API clean and intuitive. The SDK uses annotations to configure Copilot requests, virtual threads for efficient async operations, and structured APIs that feel natural to Java developers accustomed to frameworks like Spring. Under the hood, it communicates with GitHub’s Copilot backend services, handling authentication, rate limiting, and response streaming—details you don’t need to manage manually. If you’ve worked with other AWS SDKs or REST API clients, the pattern will feel familiar: configure credentials, instantiate a client, make requests, handle responses. The difference here is that Copilot handles the heavy lifting of understanding code context and generating suggestions.

Scaling organizational knowledge in Kiro with Amazon Bedrock Knowledge Bases, LangChain, and MCP

The scenario is familiar: a code review comment points you to an Architectural Decision Record (ADR) that exists somewhere in your team’s wiki. You spend ten minutes searching, scrolling past irrelevant results, and context-switching between tools before you finally understand what pattern you need to implement. This friction multiplies across your organization. New team members spend weeks learning undocumented patterns. Senior engineers repeat explanations. Critical knowledge lives in scattered documents, Slack threads, and someone’s head. Kiro, a platform focused on knowledge management, tackles this problem by combining Amazon Bedrock Knowledge Bases, LangChain, and Model Context Protocol (MCP) to make organizational knowledge instantly accessible and conversational.

A guide to slash commands in the GitHub Copilot app

GitHub Copilot has evolved beyond simple code completion into a conversational AI assistant embedded directly in your development environment. While the chat interface is useful for asking general questions, slash commands take this further by providing targeted, workflow-specific actions. Think of them as shortcuts that let you invoke Copilot’s capabilities with precision—similar to how you’d use commands in Unix shells or Discord bots. Instead of writing out a full question in natural language, you type a forward slash followed by a command keyword, and Copilot knows exactly what you’re trying to accomplish. This reduces friction in your development cycle because you’re not context-switching between your editor and a separate chat window for every task.

Scaling Autonomous Operations with AWS DevOps Agent and ServiceNow

The problem is familiar to anyone managing production systems at scale: an alert fires in CloudWatch, you context-switch to your observability dashboard, then back to ServiceNow to update the ticket, then into AWS to actually fix the problem. Each handoff introduces delay, potential for error, and cognitive overhead. AWS DevOps Agent addresses this by creating a direct bridge between your AWS infrastructure and ServiceNow, allowing intelligent automation to handle routine operations without manual intervention. This represents a meaningful shift toward what enterprises call “autonomous operations”—where systems can detect, diagnose, and remediate common issues while keeping humans in the loop for judgment calls.

Runtime instances: persistent compute for production AI agents on Amazon Bedrock AgentCore

Amazon Web Services has announced runtime instances for Bedrock AgentCore, a feature that addresses a significant gap in production AI deployments. Until now, running stateful AI agents at scale required teams to manage their own infrastructure or accept limitations imposed by serverless constraints. Runtime instances provide a middle ground: managed, persistent compute environments purpose-built for AI agents that need to maintain context and collaborate over extended periods.

Here’s what’s actually happening under the hood. Runtime instances are essentially dedicated EC2 environments provisioned and managed by AWS specifically for your agents. They maintain state across multiple interactions, support GPU acceleration for computationally intensive tasks, and allow multiple agents to collaborate within the same session. Sessions can persist for up to 14 days, which matters significantly for workflows like multi-step research tasks, ongoing customer support scenarios, or iterative data analysis where breaking context becomes expensive or impossible. You interact with them through the same Bedrock APIs you already know, but now your agents have persistent memory and computational resources without you managing EC2 directly.

Amazon DynamoDB now supports real-time vector search at any scale

Vector search has become essential for modern AI applications, but implementing it at scale has traditionally required separate infrastructure. If you’ve built RAG (Retrieval-Augmented Generation) systems or semantic search features, you know the complexity: managing a dedicated vector database like Pinecone or Milvus, syncing data between systems, and handling scalability yourself. AWS is simplifying this with native vector search built directly into DynamoDB. The service now supports single-digit millisecond query latency with 99%+ recall—meaning you can search trillions of vectors stored in DynamoDB without deploying additional infrastructure.

Turn one giant AI-generated pull request to a reviewable stack

AI coding agents are becoming incredibly useful for tackling large refactoring tasks, migrating dependencies, or implementing complex features across your codebase. But they have a frustrating habit: they generate one massive pull request that changes hundreds of files, making it nearly impossible for your team to review effectively. A 5,000-line PR with changes scattered across 50 files doesn’t just slow down your code review process—it increases the risk of bugs slipping through because reviewers can’t realistically absorb everything at once. GitHub’s solution is stacked pull requests, which breaks that monolithic change into a logical, sequential chain of smaller, reviewable PRs.

Accelerate CloudFormation development with the IaC MCP Server

The AWS IaC MCP Server represents a meaningful shift in how infrastructure-as-code developers interact with CloudFormation. Rather than context-switching between your editor, AWS CLI, and documentation, this Model Context Protocol integration lets you author, validate, deploy, and troubleshoot infrastructure templates directly within AI assistants like Claude. For teams managing multi-account AWS environments or handling frequent template iterations, this eliminates friction in the development cycle and catches errors earlier.

Here’s how it works technically: The IaC MCP Server acts as a bridge between your AI assistant and AWS CloudFormation APIs. When you’re writing a template in your assistant, you can ask it to validate the syntax, check for policy violations, or preview what resources will be created—all without leaving the chat. The server translates your requests into CloudFormation API calls, handling the authentication and formatting behind the scenes. This means the AI gets real-time feedback from AWS about your infrastructure code, not just pattern-matching against its training data. For example, you might ask “does this security group allow overly permissive access?” and the assistant can actually analyze your template against AWS best practices, then propose fixes that align with your specific architecture.

Analyze and remediate technical debt autonomously with AWS Transform – continuous modernization

Technical debt is the silent killer of development velocity. While your team ships features faster, the codebase accumulates deprecated dependencies, outdated frameworks, and inefficient patterns. Left unaddressed, this debt compounds—each new feature takes longer to implement, bugs multiply, and security vulnerabilities hide in aging code. AWS Transform addresses this fundamental problem by automatically analyzing your applications and generating code changes that modernize your stack. The tool is now generally available, meaning organizations can start using it in production workflows rather than just experimenting in preview environments.

Gateway API v1.6: TCPRoute and UDPRoute Graduate to Standard

Kubernetes Gateway API just reached a significant milestone with version 1.6.0, moving TCP and UDP routing capabilities from experimental to standard status. If you’ve been working with Kubernetes ingress controllers, you’ve probably felt the friction of managing different tools for HTTP traffic versus everything else. Gateway API aims to solve this fragmentation by providing a unified, role-based approach to handling all types of network traffic—and this release signals that the community is confident enough in TCP/UDP support to make it stable.

Kubernetes v1.37 Sneak Peek

Kubernetes is preparing for another release cycle, and like any maturing open-source project, that means deprecations, removals, and API changes are coming. The Kubernetes v1.37 release will bring important shifts to how you manage clusters, and understanding these changes now will save you from scrambling with updates later. If you’re running production Kubernetes environments—whether on AWS EKS, self-managed clusters, or hybrid setups—this is worth paying attention to. The release team publishes these notices early precisely so teams like yours have time to plan migrations rather than facing breaking changes after upgrade day.

Tame Dependabot: Group your updates, slow the cadence, keep security fast

Dependabot is one of those tools that solves a real problem—keeping your dependencies updated—but can quickly become a victim of its own success. When enabled with default settings, it can bombard your repository with dozens of pull requests each week, each one requiring review, testing, and merge decisions. For teams managing infrastructure-as-code on AWS, Python applications, or any modern stack, this notification fatigue can actually slow down security work rather than accelerate it. GitHub recently shared how a Microsoft open source project tackled this exact problem by rethinking Dependabot’s configuration to be smarter about when and how updates arrive.

Docker OIDC connections for GitHub Actions available for Docker Orgs

If you’ve been managing Docker credentials in GitHub Actions workflows, you’re probably familiar with that nagging feeling: somewhere in your secrets manager is a Personal Access Token (PAT) or Organization Access Token (OAT) that needs rotating, could accidentally get logged, or might outlive its usefulness. Docker’s new OIDC support for GitHub Actions eliminates that problem entirely. Instead of storing long-lived credentials, your GitHub Actions workflows can now exchange GitHub’s OIDC token for short-lived Docker credentials—tokens that exist only for the duration of your workflow run and are automatically invalidated when it completes.

How Company 3 Streamlines Studio Image Management with EC2 Image Builder and AWS CDK

Company 3, a powerhouse in post-production for major film and television studios, faced a challenge that many media companies encounter: managing consistent, reliable machine images across their global infrastructure. Their teams—scattered across multiple regions and working on everything from color grading to visual effects—needed standardized environments that could scale quickly without manual configuration creep. The solution came from combining two AWS services that don’t always get the spotlight together: EC2 Image Builder for automating image creation and AWS CDK for infrastructure as code. What emerged was a streamlined pipeline that reduced their image management overhead while improving consistency across their sprawling production infrastructure.

Stacked sessions and pull requests in the GitHub Copilot app

GitHub Copilot’s new stacked sessions feature addresses a common pain point in software development: managing multiple related code changes that build on each other. Instead of creating one massive pull request that’s difficult to review, stacked sessions let you organize related changes into a logical sequence of smaller, focused PRs. This mirrors how many experienced developers already work—breaking down large refactoring efforts or feature implementations into digestible chunks that are easier to test, review, and understand.

Add security context to operational investigations with AWS DevOps Agent and Wiz

At 2 AM, your on-call engineer gets paged. CPU is spiking on a critical service, latency is climbing, and customers are starting to complain. Before diving into logs and metrics, they face a crucial question: Is this a legitimate operational problem, or am I looking at a security incident? Without proper context, investigating the wrong angle wastes precious time. The collaboration between AWS DevOps Agent and Wiz security platform addresses exactly this problem by automatically enriching operational alerts with security intelligence, helping teams distinguish between performance issues and potential breaches faster.

Disrupting supply chain attacks on npm and GitHub Actions

Supply chain attacks have become one of the most sophisticated threats in software development. Rather than targeting your code directly, attackers compromise the dependencies and automation tools you trust. GitHub has recently rolled out several security features designed to make these attacks significantly harder to execute. If you’re building applications on modern cloud platforms, understanding these protections—and how to leverage them—is essential for securing your software delivery pipeline.

The core problem is straightforward: developers rely on thousands of third-party packages and automated workflows to build applications quickly. An attacker who can slip malicious code into a popular npm package or GitHub Action reaches potentially millions of projects. GitHub’s recent updates address two critical attack vectors: typosquatting (registering packages with names similar to legitimate ones), unauthorized package publishing, and compromised Actions that exfiltrate secrets. On the npm side, GitHub has implemented enhanced verification requirements for package publishers, including stronger authentication and package provenance checks. For GitHub Actions, they’ve added new controls around which Actions can access repository secrets, and improved audit logging so you can see exactly which workflows accessed what credentials. These aren’t just policy changes—they’re enforced at the platform level, meaning malicious actors can’t bypass them with a clever script.

The harness is all you need (mostly)

The AI tool landscape keeps expanding, and every week brings another promising platform promising to revolutionize your workflow. But GitHub’s recent post on their practical Copilot workflow makes a compelling argument: you might already have what you need. Rather than chasing the latest AI models and specialized tools, their approach demonstrates how to build a complete development lifecycle—from prototyping to code review—using GitHub Copilot as a central “harness” that ties everything together.

GitHub Copilot app for Beginners: Getting started

GitHub Copilot has evolved from a code completion extension into a full-featured application that brings AI-assisted development directly into your workflow. If you’ve been curious about how AI can accelerate your development process but weren’t sure where to start, the new GitHub Copilot app removes friction from that learning curve. Instead of jumping into complex AI agent setups, you can begin with straightforward code generation and gradually explore more advanced features like autonomous agents and multi-file workspaces.

GPT-5.6 now available in Microsoft Foundry

Microsoft has made OpenAI’s latest frontier model, GPT-5.6, generally available through Microsoft Foundry, alongside new regional deployment options and product agent capabilities. This release represents a significant milestone for teams building AI-powered applications on Azure, particularly those working with large-scale data processing and autonomous task execution. The availability of GPT-5.6 means enterprises can now access cutting-edge language model capabilities without managing their own model infrastructure, reducing operational overhead while maintaining security and compliance within Microsoft’s ecosystem.

AT&T and Microsoft scale trillion-token workloads with Microsoft Foundry and AMD

When you’re processing a trillion tokens—that’s roughly equivalent to reading Shakespeare’s complete works 2 million times over—you need infrastructure that can keep up without breaking the bank. AT&T recently did exactly that while developing OTel2.0 (OpenTelemetry 2.0), a critical observability framework, using Microsoft Foundry’s Managed Compute platform paired with AMD and NVIDIA GPUs. This wasn’t a one-off experiment; it represents a fundamental shift in how enterprises approach large-scale AI workloads in production environments. The story here isn’t just about the size of the computation—it’s about the flexibility and cost-effectiveness that made it possible.

The case for a cooldown: Why Dependabot now waits before issuing version updates

Dependency management has always been a balancing act. Keep your packages outdated and you risk missing security patches. Update too aggressively and you might pull in a newly-released version that breaks your application—or worse, introduce a vulnerability that hasn’t been discovered yet. GitHub’s Dependabot is addressing this tension with a sensible change: a default three-day cooldown before issuing pull requests for version updates. This shift reflects a growing understanding of how supply chain security actually works in practice.

How to build interactive experiences with canvases

GitHub Copilot Canvases represent a meaningful shift in how developers interact with AI-assisted tools. Rather than treating AI as a text-based conversational interface, canvases create dedicated workspaces where code, documentation, and visualizations coexist in a structured environment. This approach addresses a real pain point: complex tasks involving multiple files, workflows, or architectural decisions often get lost in conversational chat threads. With canvases, you get a persistent, organized space where AI can help you explore, iterate, and execute without constantly re-explaining context.

Building a Custom Metrics Exporter for Kubernetes

Kubernetes’ built-in autoscaling is powerful, but it only sees two things: CPU and memory usage. In practice, most applications need to scale based on entirely different signals—queue depth, active WebSocket connections, batch job latency, or database connection pool utilization. A metrics exporter fills this gap by collecting application-specific data and exposing it in a format that Kubernetes’ Horizontal Pod Autoscaler (HPA) can actually consume. Without this bridge, you’re left either over-provisioning resources or implementing custom scaling logic outside the cluster orchestrator entirely.

Frontier models and production agents: Advancing Microsoft Foundry for the agentic era

Microsoft has made three significant updates to its Foundry platform that deserve your attention if you’re building AI solutions at scale. The company is now offering frontier models from OpenAI, expanding its infrastructure with an Asia Pacific Data Zone, and making production-grade agent capabilities generally available. These aren’t incremental improvements—they represent a shift toward what Microsoft calls the “agentic era,” where AI systems move beyond single-task completion to handle complex, multi-step workflows autonomously.

Automated Incident Remediation with AWS DevOps Agent and Kiro CLI

The 2 AM incident page is a rite of passage for ops teams. Your monitoring system wakes you up, you SSH into CloudWatch, correlate logs across three services, identify that a deployment introduced a memory leak, then manually roll back and kick off a new build. It’s hours of context-switching and manual toil. But what if your infrastructure could handle that entire chain without waiting for a human to wake up, read dashboards, and type commands?

Operating AI/ML Workloads on Kubernetes: A Headlamp Plugin for Kubeflow

Kubernetes has become the go-to platform for running AI and machine learning workloads at scale. If you’re managing data science teams, you’ve probably noticed that model training jobs, hyperparameter tuning experiments, and inference pipelines increasingly run on Kubernetes clusters alongside your other containerized applications. Kubeflow, an open-source project that extends Kubernetes with ML-specific capabilities, has emerged as the dominant way to orchestrate these workflows. However, managing Kubeflow deployments introduces operational complexity—developers and DevOps teams need visibility into distributed training jobs, pipeline execution, and resource allocation. A new Headlamp plugin for Kubeflow addresses this gap by bringing visual monitoring and management directly into a Kubernetes dashboard, making it easier to operate ML workloads without jumping between multiple tools.

How CloudFormation express mode accelerates your development cycle

Building cloud infrastructure used to mean clicking through AWS consoles for hours—creating VPCs, configuring security groups, setting up databases, one resource at a time. CloudFormation changed that by letting you define your entire infrastructure as code, but even with templates, there’s friction. You write YAML, validate syntax, troubleshoot errors, and wait for stacks to create. AWS CloudFormation express mode cuts through that friction. It’s a simplified deployment path designed for developers who need fast feedback loops, not just operators managing production infrastructure.

Meet Brain: The AI system behind Azure reliability

Microsoft just unveiled Brain, an AI-powered system that creates a digital twin of Azure Service Health. If you’ve ever wondered how Microsoft keeps their massive cloud infrastructure running smoothly across regions and datacenters, this is the technology working behind the scenes. Rather than waiting for problems to cascade into outages, Brain learns patterns from Azure’s infrastructure and anticipates issues before they impact customers. It’s a practical example of how hyperscale cloud providers are shifting from reactive firefighting to predictive reliability.

Better tools made Copilot code review worse. Here's how we actually improved it.

You’d think better tools always mean better results. GitHub’s experience with Copilot code review proved otherwise. When they upgraded their tooling, they initially made the problem worse—the AI agent became less effective at catching issues and reviewing pull requests. What sounds like a paradox actually reveals something important about how AI agents work: the tools available shape not just performance, but the entire decision-making process. GitHub’s solution involved stepping back and rebuilding their approach around Unix-style code exploration tools, ultimately reducing costs while improving quality.

Building and running custom code transformations without leaving your editor

Every engineering team has them: those repetitive code changes that don’t fit neatly into what commercial tools handle. Maybe you’re migrating away from a deprecated internal library across fifty microservices. Maybe your team standardized on a new error-handling pattern and needs it applied consistently. Maybe logging formats need updating across your entire codebase. These aren’t one-off tasks—they’re recurring work that generic tools simply weren’t designed to address. AWS Transform custom lets you define and execute these changes programmatically, directly from your IDE, automating work that otherwise requires manual review and refactoring across your entire repository.

How GitHub gave every repository a durable owner

GitHub’s internal infrastructure had a problem that many fast-growing organizations face: repository sprawl. With over 14,000 repositories across the company, fewer than half had clearly assigned owners. This lack of ownership created a cascade of issues—security vulnerabilities went unpatched, deprecated code lingered indefinitely, and incident response became chaotic because nobody knew who to contact. GitHub realized that without establishing clear ownership, scaling their security practices would be nearly impossible. They needed a systematic way to assign validated owners to every active repository in under 45 days.

Automating cross-repo documentation with GitHub Agentic Workflows

One of the most frustrating gaps in software development is the lag between shipping features and documenting them. The .NET Aspire team recently tackled this problem head-on using GitHub’s agentic workflows—autonomous AI agents that can execute multi-step tasks across repositories without human intervention. Instead of relying on developers to manually write documentation after merging code, they built a workflow that detects changes, generates documentation drafts, and opens pull requests for subject matter experts to review. It’s a practical example of how AI agents can bridge the gap between velocity and documentation accuracy.

How GitHub Copilot enables zero DNS configuration for GitHub Pages

GitHub has quietly solved one of the most friction-heavy parts of deploying static sites: managing DNS records. Traditionally, pointing a custom domain to GitHub Pages required manually creating CNAME, A, or ALIAS records in your registrar’s DNS settings—a process prone to typos and frustrating troubleshooting. Now, with GitHub Copilot’s assistance, you can go from an empty repository to a live site with HTTPS on a custom domain in roughly 14 minutes, without touching DNS settings at all. This represents a meaningful shift in how automation and AI can simplify cloud infrastructure tasks for developers who aren’t infrastructure specialists.

Proving application resilience on Azure with Chaos Studio

Production outages are inevitable. Network latency spikes, database connections fail, entire availability zones go down—and when they do, your application either handles it gracefully or it doesn’t. Most teams don’t know which until it’s too late. Azure Chaos Studio addresses this by letting you deliberately break things in a controlled way. It’s essentially a testing framework that simulates infrastructure failures before they happen for real, giving you confidence that your application can actually recover from the disasters you’ve designed it to handle.

Claude in Microsoft Foundry is now generally available

Microsoft has made Claude, Anthropic’s AI model, generally available through Azure’s AI Foundry platform. This means teams can now access Claude at production scale without building custom infrastructure, with the models running on NVIDIA’s latest Blackwell Ultra GPUs. If you’ve been experimenting with Claude through Anthropic’s API or other providers, this announcement matters because it gives you another deployment path—one that’s tightly integrated with Azure’s broader AI stack and governance tools.

How GitHub used secret scanning to reach inbox zero

GitHub recently shared how they tackled a sprawling security problem: 20,000+ secret scanning alerts across 15,000 repositories. The challenge wasn’t just the volume—it was figuring out which alerts actually mattered versus false positives that waste engineering time. Their solution offers a practical playbook for any organization drowning in security noise, and the approach reveals something important about how modern development security actually works at scale.

Secret scanning automatically detects credentials, API keys, and tokens that accidentally get committed to repositories. GitHub’s scanner runs on every push, looking for patterns that match known secret formats—AWS access keys, GitHub tokens, Slack webhooks, and hundreds of other credential types. When the system flags something, it generates an alert. This is powerful: you catch leaks before they leave your codebase. But here’s the problem GitHub faced: when you have thousands of repositories and years of accumulated commits, you also get thousands of alerts, many from old repositories, inactive projects, or credentials that were already rotated months ago. Engineers start ignoring alerts because reviewing them feels like busy work. That’s when your security tool stops being useful.

Upgrade Amazon EKS clusters with confidence using Kubernetes version rollbacks

Kubernetes upgrades have traditionally been a nail-biting experience. You schedule maintenance, cross your fingers, and hope nothing breaks in production. AWS just made that process significantly less stressful by introducing Kubernetes version rollbacks for Amazon EKS—a feature that lets you undo a cluster upgrade within seven days if things go wrong. This transforms upgrades from a one-way door into a reversible operation, which is a meaningful shift in how teams approach cluster maintenance.

Ship infrastructure faster with CloudFormation and CDK pre-deployment validation on every stack operation

Infrastructure as Code (IaC) has become standard practice, but the feedback loop between writing a template and discovering errors can still be painfully slow. AWS CloudFormation lets you define cloud resources as code using JSON or YAML, while CDK takes it further by letting you write infrastructure in Python, TypeScript, or other languages. The problem? A single syntax error, missing property, or invalid parameter type can derail your deployment—whether you’re deploying directly, using change sets for previews, or running automated deployments through CI/CD pipelines or AI agents. AWS has now extended CloudFormation’s validation capabilities to catch these issues earlier in the development process, before they consume deployment time and developer attention.

Accelerate your infrastructure deployments by up to 4x with AWS CloudFormation Express mode

AWS CloudFormation just got faster. The new Express mode can cut deployment times down to seconds instead of minutes, which might not sound like much until you’re iterating on infrastructure changes dozens of times a day. Whether you’re building AI applications that need rapid experimentation or managing DevOps workflows that demand quick feedback loops, this feature addresses a real pain point: waiting for CloudFormation stacks to create or update before you can validate your changes.

Previewing GPT-5.6 Sol: a next-generation model

OpenAI has announced GPT-5.6 Sol, a new large language model that represents a meaningful step forward in AI capabilities, particularly for technical domains. If you’re working with AI in production environments, this preview gives us a window into what’s coming and what you should be thinking about now.

So what makes Sol different? The model shows substantial improvements in three areas that directly impact cloud and automation work: coding, scientific reasoning, and cybersecurity analysis. When OpenAI says “stronger capabilities in coding,” they’re not just talking about generating boilerplate—Sol appears to handle complex multi-step problems, debugging logic, and architectural decisions with better accuracy than its predecessors. For those of us writing infrastructure-as-code, Lambda functions, or automation scripts, this means better code generation assistance and fewer hallucinations when asking the model to help with tricky logic. The science and cybersecurity improvements matter too, especially if you’re working with security scanning, threat analysis, or using AI to help parse technical documentation and research papers.

How to Generate an SBOM for Container Workflows

If you’re deploying containers at any scale, you’ve probably encountered security audits asking for a complete list of what’s inside your images. That’s where SBOMs come in. A Software Bill of Materials (SBOM) is essentially an inventory of all dependencies, libraries, and packages bundled into your container image. Think of it like a nutrition label for your software—it tells you exactly what ingredients are present. As container security becomes a core requirement for compliance frameworks like SLSA and regulations such as the Executive Order on Cybersecurity, understanding how to generate and integrate SBOMs into your CI/CD pipeline is becoming a table-stakes skill for DevOps and platform engineers.

Evaluating performance and efficiency of the GitHub Copilot agentic harness across models and tasks

GitHub recently published findings on their Copilot agentic harness—a framework designed to run AI agents across different models while measuring performance and efficiency. If you’re building AI-assisted workflows or considering which models to use for your development tasks, this is worth understanding. The research essentially answers a practical question many teams face: which combination of model and task setup gives you the best results without burning through your token budget?

Spotlight on WG Device Management

Kubernetes has become the go-to orchestration platform for cloud workloads, but it was originally designed for stateless applications that only needed CPU and memory. Today, that’s changing rapidly. As AI models, edge computing, and telecommunications services move to Kubernetes, operators face a new challenge: how do you allocate and manage specialized hardware like GPUs, TPUs, and network interface cards (NICs)? This is where the Kubernetes Device Management working group steps in, developing standards for hardware resource allocation that go far beyond traditional CPU and memory constraints.

From insight to action: The next phase of agentic cloud operations

Cloud operations have traditionally worked in cycles: you monitor your environment, get alerts, analyze what’s wrong, and then manually decide what to do next. But what if that entire decision-making loop could happen automatically? Microsoft’s vision of agentic cloud operations moves beyond dashboards and alerts to create systems that don’t just tell you what’s broken—they fix it themselves. This represents a meaningful shift in how we approach cloud management, turning cloud platforms from reactive tools into proactive decision-makers.

I automated my job (and it made me a better leader)

There’s a persistent myth in tech leadership that automation is something you delegate to junior engineers. But what if the best person to automate your own workflow is you? A senior leader at GitHub recently shared how they implemented 40 automations across their daily tasks—and the outcome wasn’t burnout prevention, though that was a nice side effect. Instead, it fundamentally changed how they lead their team.

The technical foundation here is straightforward but powerful. These automations likely combine GitHub Actions workflows, API integrations, and cloud-based task runners to eliminate repetitive manual work: automatically summarizing pull requests, routing code reviews to the right people, aggregating metrics from multiple dashboards, and flagging blockers before they become problems. The magic isn’t in any single tool—it’s in the workflow orchestration. When a pull request lands, a workflow can trigger status checks, post summaries to Slack, update tracking systems, and notify stakeholders without human intervention. For Python-savvy engineers, this might mean writing Lambda functions on AWS that trigger on CloudWatch events, or using boto3 to manage resources at scale. The infrastructure is already there; the missing piece is usually just connecting the dots.

Run isolated sandboxes with full lifecycle control: AWS Lambda introduces MicroVMs

AWS just announced Lambda MicroVMs, a new compute primitive that shifts how you think about serverless isolation and state management. Instead of sharing kernel resources across functions, each MicroVM gives you a dedicated, lightweight virtual machine with full isolation. This sits somewhere between traditional Lambda containers and full EC2 instances—you get the isolation guarantees of a VM without managing infrastructure or waiting for boot times.

Here’s what makes this technically different: traditional Lambda functions run in a shared sandbox environment within a container, which means the kernel and some system resources are technically shared across invocations (though AWS handles security isolation at the application level). MicroVMs flip this model. Each function gets its own isolated kernel and resource namespace, similar to how you’d think about separate machines. They launch in milliseconds and can maintain state for up to 8 hours, meaning you can pause, resume, and reconnect without losing your session. There’s no need to rebuild state from scratch on every invocation. Practically, this matters because you have explicit control over the VM lifecycle—you decide when to pause, resume, or terminate, rather than relying on Lambda’s default timeout and cleanup model.

Accelerate Incident Resolution with PagerDuty and AWS DevOps Agent

Every ops engineer knows the scenario: your phone buzzes at 2 a.m. with a critical alert. Your heart sinks. The notification tells you that something is broken, but not why. You’re now scrambling through CloudWatch logs, SSH-ing into instances, and running diagnostics while your application hemorrhages traffic and your customers watch their requests timeout. This context gap—between detection and understanding—is where SRE teams waste the most time during incidents. AWS and PagerDuty have partnered to close that gap with the AWS DevOps Agent, a tool designed to automatically gather diagnostic data and surface it directly in PagerDuty incidents, cutting mean-time-to-resolution (MTTR) significantly.

Feature Flag Orchestration with AWS DevOps Agent and LaunchDarkly

When an outage hits at 2 AM, your team’s response speed determines whether customers experience a five-minute blip or a cascading disaster. Yet many organizations still manage feature flags and incident response separately—meaning engineers waste precious minutes hunting through dashboards, deciding which flags matter, and coordinating manual changes across teams. AWS DevOps Agent paired with LaunchDarkly bridges this gap by automating the connection between your incident response workflows and feature flag management, letting engineers respond to emergencies with a single action instead of a dozen.

Supercharge your cloud operations with the Kiro power for AWS DevOps Agent

The 2 AM alert is a rite of passage in cloud engineering. Your phone buzzes. Your service is down or degrading. You stumble out of bed and start the familiar ritual: SSH into the bastion host, grep through CloudWatch logs, check the deployment history, trace through your code to understand what changed. Meanwhile, crucial context is scattered across a dozen browser tabs—your monitoring dashboard, X-Ray traces, infrastructure diagrams, configuration files. By the time you’ve assembled the full picture, you’ve already lost 20 minutes you didn’t have to spare.

Announcing Amazon EC2 G7 instances accelerated by NVIDIA RTX PRO 4500 Blackwell Server Edition GPUs

AWS has released Amazon EC2 G7 instances into general availability, marking a significant upgrade for workloads that demand serious GPU power. These instances pack NVIDIA’s RTX PRO 4500 Blackwell Server Edition GPUs—a processor designed specifically for data centers rather than gaming or consumer applications. If you’ve been running inference models, rendering graphics pipelines, or processing large datasets, G7 instances represent a meaningful leap forward in performance-per-dollar compared to their predecessors.

Amazon ECS introduces new high-resolution metrics for faster service auto scaling

Container applications need to respond quickly to traffic spikes. If your ECS service waits minutes to scale up during a sudden surge, users experience slowdowns and timeouts. Amazon’s new high-resolution metrics feature addresses this timing challenge by allowing ECS auto scaling policies to react based on metrics collected at one-second intervals instead of the default one-minute intervals. This tighter feedback loop means your containers can scale up faster when demand increases and scale down more efficiently during quiet periods.

How we built an internal data analytics agent

GitHub recently shared how they built Qubot, an internal analytics agent that lets employees ask questions about company data using plain language instead of writing SQL queries. It’s a practical example of how AI can reduce friction in data workflows—something that applies far beyond GitHub’s walls.

At its core, Qubot solves a common problem: data exists in databases, but accessing it requires SQL expertise. Not everyone on a team has that skill, and even those who do spend time writing boilerplate queries. GitHub’s approach uses Claude (via Bedrock or similar) to translate natural language questions into SQL queries that run against their internal data warehouse. An employee can ask “How many pull requests were merged last quarter?” and get results without touching a database client. The agent handles schema understanding, query generation, and result formatting—essentially acting as a smart intermediary between human questions and structured data.

Production-Ready Autonomous Incident Resolution with AWS DevOps Agent (now GA) and Datadog MCP Server

The partnership between AWS and Datadog has matured into something genuinely useful: a system that can detect, diagnose, and fix infrastructure problems with minimal human intervention. AWS DevOps Agent, now generally available, works alongside Datadog’s Model Context Protocol (MCP) Server to turn monitoring alerts into actionable resolutions. Instead of waiting for on-call engineers to wake up, correlate logs, check configurations, and apply fixes, this integration handles the routine work automatically—and does it in minutes instead of hours.

Getting more from each token: How Copilot improves context handling and model routing

If you’ve been using GitHub Copilot, you’ve probably noticed that your credit usage can add up quickly. Every code suggestion, chat conversation, and model inference consumes tokens—the small units that AI models use to process and generate text. GitHub’s latest improvements focus on making those tokens work harder for you, reducing waste and ensuring your credits stretch further while actually improving code quality. This matters because in a world where AI assistance is becoming essential to development workflows, efficiency directly impacts both your wallet and your team’s productivity.

Announcing Web Search on Amazon Bedrock AgentCore: Ground your AI agents in current, accurate web knowledge

One of the biggest challenges when deploying AI agents in production is keeping them accurate. Language models have knowledge cutoffs—they don’t know about events after their training data ends. If your customer service agent is answering questions about your latest product launch or an agent needs real-time pricing information, it’s working with stale information. AWS is addressing this with Web Search on Amazon Bedrock AgentCore, a managed capability that lets your agents pull current information directly from the web without you having to build and maintain the infrastructure yourself.

Introducing Amazon Bedrock Managed Knowledge Base for faster, more accurate enterprise AI applications

Enterprise AI teams face a familiar pain point: building retrieval-augmented generation (RAG) systems is complex. You need to connect to multiple data sources, parse different file formats, orchestrate embeddings, manage vector databases, and chain everything together—all while keeping your application accurate and performant. AWS’s new Fully Managed Knowledge Bases for Amazon Bedrock aims to eliminate much of this infrastructure work, letting your team focus on what actually matters: delivering business value.

Amazon S3 annotations: attach rich, queryable context directly to your objects

Amazon S3 just added a feature called annotations that fundamentally changes how you can work with object metadata at scale. Instead of managing metadata in separate databases or systems, you can now attach up to 1 GB of rich, queryable context directly to S3 objects. For teams building AI agents and automation workflows, this is a practical shift that simplifies data discovery and context management in ways that single-key/value tag systems simply can’t match.

GitHub Copilot CLI for Beginners: Overview of common slash commands

GitHub Copilot has expanded beyond code editors into the terminal itself. Copilot CLI brings AI-assisted command suggestions directly to your shell, making it easier to construct complex commands without memorizing syntax or hunting through documentation. For developers working with AWS, building automation scripts, or managing cloud infrastructure from the command line, this tool can significantly reduce friction when dealing with unfamiliar tools or verbose command syntax.

Copilot CLI works by accepting natural language descriptions of what you want to accomplish, then translating them into actual shell commands. When you type a slash command like ?? or git!, you’re signaling to Copilot that you need help. The tool analyzes your input, considers the context of your current shell environment and recent commands, and suggests appropriate commands to run. It understands common cloud CLI tools like the AWS CLI, kubectl, Terraform, and others—meaning you can ask for help with complex flags and arguments without needing to reference man pages. The suggestions appear inline or in a prompt, letting you review before executing.

Now available: Amazon EC2 M9g and M9gd instances powered by new AWS Graviton5 processors

AWS has released new EC2 instance types—M9g and M9gd—built on the latest AWS Graviton5 processor. If you’ve been following the evolution of AWS-custom silicon, this is a meaningful step forward. Graviton5 delivers up to 25% better compute performance than its Graviton4 predecessor while maintaining AWS’s focus on energy efficiency. For teams running containerized workloads, microservices, or general-purpose applications, this means more capability per dollar and per watt consumed.

The technical improvement comes from a redesigned processor architecture. Graviton5 increases clock speeds, improves instruction throughput, and enhances memory bandwidth compared to Graviton4. The M-series instances are general-purpose machines—they balance compute, memory, and network resources—making them suitable for a wide range of workloads. The key distinction: M9g instances come with local NVMe SSD storage (the “d” in M9gd), which helps if your application needs fast, temporary storage without making extra API calls to EBS. For Python-based batch jobs, Node.js APIs, or containerized applications using Docker and Kubernetes, these instances fit naturally into existing architectures.

Claude Fable 5 available today in Microsoft Foundry: Powering the next era of autonomous agents

Anthropic has released Claude Fable 5, their latest frontier AI model, through Microsoft Foundry—marking a significant milestone in making advanced AI capabilities available to enterprise developers. This release represents a shift toward practical, production-grade autonomous agents that can handle complex workflows without constant human intervention. If you’ve been experimenting with Claude’s API or watching the AI space evolve, this is worth understanding because it affects the tools you’ll be building with over the next year.

How we made GitHub Copilot CLI more selective about delegation

GitHub recently shared insights into improving how GitHub Copilot CLI decides when to hand off tasks to other AI agents or tools. The core problem they were solving is surprisingly common: when an AI system can delegate work, it often does so too eagerly, creating unnecessary handoffs that slow things down and introduce failure points. By making Copilot CLI smarter about when to delegate, they reduced overhead while keeping the benefits of task specialization.

Making secret scanning more trustworthy: Reducing false positives at scale

Secret scanning is one of those security tools that sounds simple in theory but gets complicated fast. The idea is straightforward: scan your codebase for accidentally committed credentials like API keys, database passwords, or AWS access tokens before they reach production. But here’s the problem that GitHub tackled—these scanners generate tons of false positives. A developer commits a test string that looks like a secret, or includes a placeholder in documentation, and suddenly your security team is flooded with alerts that waste time and erode trust in the tool itself. When people ignore 90% of alerts because they’re noise, they’ll miss the real threats hiding in the remaining 10%.

Diagnose EKS Node Issues Faster with AWS DevOps Agent and Custom MCP

When your Kubernetes cluster starts throwing CrashLoopBackOff errors at 3 AM, you don’t want to manually SSH into nodes, grep through logs, and cross-reference timestamps with CloudWatch metrics. AWS DevOps Agent automates exactly this kind of troubleshooting by investigating production incidents autonomously. It can diagnose pod failures, trace configuration changes through AWS CloudTrail audit logs, and correlate metrics with cluster events—all without waking up your on-call engineer. But here’s the catch: it only works well when your troubleshooting data lives in AWS services it knows about. When critical diagnostics are scattered across custom monitoring tools, proprietary observability platforms, or internal systems, DevOps Agent hits a wall.

Give GitHub Copilot CLI real code intelligence with language servers

GitHub Copilot CLI has been a useful tool for developers working in terminal environments, offering AI-powered suggestions for commands and code snippets. However, its effectiveness has been limited by how it understands your codebase. Traditionally, Copilot CLI relied on grep searches and basic text parsing to gather context about your project—essentially pattern matching without true code comprehension. GitHub has now addressed this limitation by integrating Language Server Protocol (LSP) support, enabling Copilot CLI to tap into the same sophisticated code analysis that powers modern IDEs like VS Code.

From one-off prompts to workflows: How to use custom agents in GitHub Copilot CLI

GitHub Copilot CLI has evolved beyond answering random terminal questions. The latest addition—custom agents—lets you teach Copilot about your specific tech stack, infrastructure patterns, and team processes. Instead of explaining your deployment pipeline every time you ask for help, you can set it up once and have Copilot understand your context automatically. This shift from one-off prompts to repeatable workflows is particularly valuable for teams managing complex cloud environments or standardized deployment procedures.

Anthropic Claude Fable 5 on AWS: Mythos-class capabilities with built-in safeguards now available

AWS has quietly expanded what’s possible for enterprises building AI applications by making Claude Fable 5 available through Amazon Bedrock and the Claude Platform on AWS. This release democratizes what Anthropic calls “Mythos-class” AI capabilities—essentially the high-performance reasoning and generation you’d expect from their most advanced model—while maintaining the safety-focused architecture that’s become Anthropic’s calling card. If you’ve been hesitant about deploying sophisticated AI models in regulated environments, this development deserves your attention.

Microsoft Build 2026: Building agentic apps with Microsoft Fabric and Microsoft Databases

Microsoft’s latest announcements at Build 2026 center on making it easier to develop AI agents that can autonomously handle business tasks. The company is positioning Microsoft Fabric and Microsoft Databases as a unified foundation for these applications—essentially creating an integrated platform where your data infrastructure, AI models, and application logic live together rather than scattered across separate services. This matters because building effective AI agents requires tight coupling between data access, model intelligence, and real-time decision-making. When these components are fragmented, you’re fighting latency issues, consistency problems, and operational complexity.

Announcing Microsoft Discovery general availability and Microsoft Discovery app preview

Microsoft has released Microsoft Discovery as a generally available platform, marking a significant shift in how organizations can build and manage agentic AI workflows. If you’ve been following the AI space, you know that autonomous agents—AI systems that can plan, execute, and adapt without constant human intervention—are becoming increasingly central to enterprise automation. Microsoft Discovery is designed to solve one of the biggest challenges teams face: how to actually build these agents responsibly and at scale, not just experiment with them in isolated prototypes.

Try the new console experience in Amazon Bedrock, optimized for Anthropic- and OpenAI-compatible APIs

Amazon Bedrock just rolled out a redesigned console that makes it easier to explore, test, and deploy foundation models without leaving the AWS interface. If you’ve found yourself juggling multiple browser tabs to compare models, copy-paste API documentation, or remember which code snippets work with which services, this update addresses those friction points directly. The new experience is specifically optimized for Anthropic and OpenAI-compatible APIs, meaning whether you’re using Claude, GPT models, or others in the compatible ecosystem, you’ll find a more cohesive workflow.

Debug deployment failures faster with the Deployments tab in AWS Elastic Beanstalk

Deployment failures are frustrating. One moment your application is ready to ship, the next you’re hunting through logs trying to figure out what went wrong. Traditionally, when an Elastic Beanstalk deployment fails, you’d wait for it to finish, request a log bundle, download it locally, and then manually search through files like eb-engine.log, cfn-init.log, and platform.log hoping to spot the error. If you’re new to Beanstalk’s logging structure, this process can feel like finding a needle in a haystack. AWS has streamlined this workflow with the Deployments tab in the Elastic Beanstalk console, which surfaces error messages directly without requiring you to dig through bundled logs.

Claude Opus 4.8 is now available in Microsoft Foundry

Microsoft has made Claude Opus 4.8, Anthropic’s most advanced reasoning model, available through Azure AI Foundry. This marks another important step in multi-model AI accessibility, giving teams working in the Microsoft ecosystem direct access to a frontier-class LLM without leaving their familiar Azure environment. For organizations already invested in Azure infrastructure, this eliminates friction in model selection and deployment.

From a technical perspective, Azure AI Foundry handles the integration through its managed API endpoints. Rather than managing separate connections to Anthropic’s systems, you authenticate through Azure’s identity layer and make standard REST API calls—the same pattern you’d use for other Azure AI services. This means your existing error handling, rate limiting logic, and monitoring dashboards work seamlessly. The model supports both synchronous requests for real-time applications and batch processing APIs for large-scale workloads, giving you flexibility in how you structure applications.

GitHub Copilot app: The agent-native desktop experience

At Microsoft Build 2026, GitHub announced a significant shift in how AI agents integrate into developer workflows. The new GitHub Copilot app represents a move away from browser-based AI assistants toward native desktop experiences designed specifically for autonomous agents. Rather than forcing agents into existing chat interfaces, this approach builds tools that let agents interact with your development environment the way they naturally need to—running commands, accessing files, and integrating with your existing tools without friction.

Get started with OpenAI GPT-5.5, GPT-5.4 models, and Codex on Amazon Bedrock

Amazon Bedrock just made OpenAI’s latest frontier models available to everyone. GPT-5.5 and GPT-5.4 are now generally available alongside Codex, OpenAI’s specialized coding agent. If you’ve been waiting to integrate cutting-edge language models into your applications without managing infrastructure yourself, this is worth your attention. Bedrock handles the heavy lifting—you focus on building.

Here’s what’s actually happening under the hood. Bedrock is a managed service that abstracts away model infrastructure. Instead of running your own API calls to OpenAI’s servers, you’re making requests through AWS’s infrastructure with their “high performance inference engine.” This matters because it means lower latency, tighter integration with your AWS environment, and unified billing. You pay per token consumed, not monthly subscriptions. If you’re building a document analysis pipeline in Python, for example, you can now invoke GPT-5.5 via a simple boto3 call, get the response back, and immediately pass it to other AWS services like S3 or Lambda for post-processing—all within a single VPC and with CloudTrail logging every request.

Automate root cause analysis across Datadog and Elasticsearch with AWS DevOps Agent

When your microservices architecture spans dozens of applications and infrastructure components, a single failed transaction becomes a needle-in-a-haystack debugging problem. A payment might fail because of a timeout in Service A, a queue overflow in Service B, a network misconfiguration in AWS, or degraded database performance—and the clues are scattered across Elasticsearch logs, Datadog metrics, and CloudTrail events. Manually correlating these signals is slow, error-prone, and exactly the kind of repetitive work that makes on-call rotations exhausting. AWS DevOps Agent addresses this by automating the collection and correlation of observability data across your entire stack, turning fragmented signals into coherent root cause analysis.

Introducing the next generation of AWS Resilience Hub for generative AI-based SRE resilience journey

AWS has released a significantly enhanced version of Resilience Hub that fundamentally changes how Site Reliability Engineers (SREs) approach application resilience. The new generation combines automated dependency discovery, AI-powered failure analysis, and organizational-scale reporting into a unified platform. For teams managing complex distributed systems on AWS, this represents a meaningful shift from manual resilience assessment to data-driven, AI-assisted resilience planning.

The technical foundation centers on four key capabilities working together. First, the improved application model gives you finer-grained control over how you define application components and their interconnections. Second, dependency discovery automatically maps relationships between your AWS resources—think EC2 instances, RDS databases, load balancers, and Lambda functions—without requiring manual configuration. Third, generative AI analyzes potential failure modes across your architecture and suggests specific resilience improvements. Finally, modular resilience policies let you define and enforce standards across your organization rather than managing resilience individually per application. Practically speaking, when you add an application to Resilience Hub, the system automatically discovers your AWS infrastructure, generates a dependency graph, and uses AI to identify weaknesses like single points of failure or missing redundancy.

Introducing the next generation of Amazon OpenSearch Serverless for building your agentic AI applications

AWS has rebuilt Amazon OpenSearch Serverless from the ground up to handle the demands of agentic AI workloads and dynamic applications. This matters because AI agents—systems that autonomously make decisions and take actions—have fundamentally different resource needs than traditional applications. They spike unpredictably, require sub-second latency for decision-making, and need vector search capabilities to understand context from documents and data. The previous generation of OpenSearch Serverless wasn’t designed with these patterns in mind. The new version changes that with instant autoscaling that responds in milliseconds rather than minutes, meaning your AI agents never wait for infrastructure to catch up.

How AWS DevOps Agent uses multi-agent reasoning to find root causes

Confirmation bias is the silent killer of incident response. You get paged at 2 AM, spot elevated CPU on your API server, assume that’s the problem, find one log line that seems to confirm it, and spend the next three hours chasing a dead end. Meanwhile, the real culprit—a memory leak in a dependency, a poorly optimized database query in a different service, or a configuration drift somewhere else entirely—keeps causing damage. AWS DevOps Agent tackles this exact problem by using multiple independent AI agents that reason through incidents together, each approaching the problem from a different angle before reaching a consensus on root cause.

Powering multi-cluster workloads with seamless cross-cluster networking for Azure Kubernetes Fleet Manager

Running Kubernetes at scale often means distributing workloads across multiple clusters—whether for high availability, disaster recovery, or geographic distribution. But managing networking across clusters has traditionally been complex and fragmented. Microsoft’s latest announcement brings Cilium-based cross-cluster networking to Azure Kubernetes Fleet Manager, creating a unified network fabric that treats multiple clusters as a single, logical system. This addresses a real pain point: teams previously had to cobble together networking solutions or accept the operational burden of managing cluster-to-cluster communication manually.

GitHub recognized as a Leader in the Gartner® Magic Quadrant™ for Enterprise AI Coding Agents for the third year in a row

GitHub’s third consecutive recognition as a Leader in Gartner’s Magic Quadrant for Enterprise AI Coding Agents reflects the maturity of AI-assisted development tools in production environments. This isn’t just industry validation—it signals that AI coding agents have moved beyond experimental features into tools that enterprises genuinely depend on for shipping code. The recognition acknowledges both GitHub’s technical capabilities and its ability to execute at scale, serving millions of developers across organizations of all sizes.

AWS Weekly Roundup: AWS Transform at 1 year, Claude Platform on AWS, EC2 M3 Ultra Mac instances, and more (May 18, 2026)

AWS Transform has quietly become one of the most practical tools for enterprises sitting on aging codebases. A year after its launch, AWS is celebrating the service’s growth by introducing AWS Transform custom—a feature that lets you define your own transformation rules alongside AWS-managed ones. If you’ve worked with legacy systems, you know the pain: upgrading a .NET application from version 4.7 to 8.0, migrating a mainframe workload to cloud-native architecture, or refactoring VMware-dependent code feels like an endless manual process. AWS Transform uses agentic AI to automate this at scale, analyzing your codebase, identifying patterns, and executing transformations across thousands of files simultaneously.

Meet Gordon: Docker's AI Agent For Your Entire Container Workflow

Developers have gotten used to AI handling the tedious parts of their work. GitHub Copilot finishes your functions, automation tools merge pull requests, and CI/CD pipelines catch most errors before they hit production. But there’s still a stubborn gap: when something breaks in your container environment, you’re often back to manual troubleshooting, digging through logs, and waiting for someone with deep Docker expertise. Docker’s new Gordon agent aims to close that gap by bringing AI-powered intelligence directly into your container workflow, handling everything from problem diagnosis to automated fixes.

Modernizing Excel VBA to Python at Scale with AWS Transform Custom

Legacy Excel VBA applications are a silent IT burden at many organizations. These macro-heavy spreadsheets often contain critical business logic—financial calculations, data pipelines, reporting workflows—but they’re difficult to maintain, hard to test, and increasingly risky as security vulnerabilities emerge. The problem gets worse at scale: a company might have dozens or hundreds of these applications spread across departments, each one a potential technical debt landmine. Rewriting them manually would take months or years of developer time. AWS Transform Custom offers a practical path forward by using AI to automatically convert VBA code to modern Python while preserving the original functionality—a process that typically takes hours instead of weeks.

Announcing AWS CDK Mixins: Composable Abstractions for AWS Resources

AWS just released CDK Mixins, and if you’ve ever found yourself copying boilerplate code across multiple CDK constructs, this feature deserves your attention. Mixins are a programming pattern that let you apply reusable behaviors to any construct—whether it’s a low-level L1, high-level L2, or your own custom resource—without forcing you into a rigid class hierarchy. Think of them as a way to bolt on functionality like monitoring, encryption, or compliance tagging to existing resources without rewriting them from scratch.

Building Self-Extending CLI Tools with Strands Agent

Imagine describing a new command to your CLI tool in plain English and having it instantly available—no code commits, no deployments, no waiting for your team to implement it. That’s the premise behind self-extending CLI tools built with Amazon Bedrock and the Strands Agents SDK. Instead of treating command-line interfaces as static artifacts that require development cycles to modify, this pattern enables them to dynamically generate, refine, and version new capabilities at runtime through conversational interaction. It’s a shift from “tools that do things” to “tools that learn and grow.”

Kubernetes v1.36: Mixed Version Proxy Graduates to Beta

Kubernetes just reached a significant reliability milestone. The Mixed Version Proxy (MVP) feature has graduated from Alpha to Beta in version 1.36, which means it’s moving closer to becoming a stable production feature. If you’ve ever sweated through a cluster upgrade wondering if your applications would survive the transition, this feature is designed to be your safety net. MVP addresses a real pain point in Kubernetes operations: ensuring backward compatibility when your control plane and nodes are running different versions during an upgrade.

Simplify cross-account and cross-Region stack output references with AWS CloudFormation and CDK's new Fn::GetStackOutput

If you’ve managed infrastructure across multiple AWS accounts or regions, you know the pain: CloudFormation stack outputs live in isolated silos. Want to reference a VPC ID from a stack in a different account? You’re stuck manually copying values, storing them in Parameter Store, or building custom Lambda functions to bridge the gap. AWS just made this significantly easier with Fn::GetStackOutput, a new CloudFormation function that lets you directly reference stack outputs across account and region boundaries. This is a small feature with surprisingly large practical implications for how teams organize and scale their infrastructure-as-code.

Custom MCP Catalogs and Profiles: Advancing Enterprise MCP Adoption

The Model Context Protocol (MCP) has quietly become essential infrastructure for connecting AI applications to custom tools and data sources. Docker’s announcement of Custom Catalogs and Profiles moving to general availability addresses a real pain point: how do enterprises standardize, distribute, and manage MCP servers at scale? If you’ve been experimenting with MCP servers locally, you’ve probably packaged them ad-hoc—copying configurations, managing dependencies, and hoping everything works across different environments. Custom Catalogs and Profiles solve this by providing a structured way to package and distribute MCP tooling across your organization, similar to how you might manage container registries or package repositories.

Amazon Bedrock introduces new advanced prompt optimization and migration tool

Prompt engineering has become a critical skill in the AI era, but getting it right remains challenging. AWS is addressing this pain point with Amazon Bedrock’s Advanced Prompt Optimization—a new feature that automates what previously required manual trial-and-error. The tool lets you systematically optimize prompts for your current foundation model or quickly migrate them to new models, with built-in evaluation feedback to guide the process. If you’ve ever spent hours tweaking prompt wording only to get marginal improvements, this feature directly tackles that problem.

Kubernetes v1.36: Advancing Workload-Aware Scheduling

If you’ve run machine learning training jobs or batch processing on Kubernetes, you’ve probably noticed something frustrating: the scheduler treats every Pod the same way. It doesn’t understand that your distributed TensorFlow training job needs all its worker nodes to start together, or that your batch processing pipeline requires specific resources across multiple containers. Kubernetes v1.36 takes a meaningful step toward fixing this with improved workload-aware scheduling capabilities that let the scheduler understand what your applications actually need to run efficiently.

GitHub Copilot individual plans: Introducing flex allotments in Pro and Pro+, and a new Max plan

GitHub has restructured its Copilot individual subscription tiers starting June 1st, introducing more flexibility in how developers consume AI-assisted coding features. The new lineup includes updated Pro and Pro+ plans with flexible token allotments, plus a new Max tier for heavy users. This shift reflects how GitHub has been listening to user feedback about pricing and usage patterns—recognizing that developers don’t all code the same way, and neither should their billing.

Agentic application modernization at scale with Strands and Amazon Transform custom

Application modernization is one of those necessary-but-painful tasks most large organizations face. You’ve got hundreds of repositories still running on outdated Python versions, legacy SDKs, or frameworks that nobody really supports anymore. Each one needs analysis, custom transformation logic, validation, and careful deployment. Without automation, you’re looking at months of manual work spread across multiple teams. Amazon Transform custom addresses this by combining AI-powered code analysis with intelligent automation—letting you tackle modernization at scale rather than one repository at a time. Paired with Strands’ agentic capabilities, it offers a genuinely different approach to a problem that’s been tedious for too long.

Amazon Redshift introduces AWS Graviton-based RG instances with an integrated data lake query engine

Last month, AWS announced a significant upgrade to Amazon Redshift with the introduction of RG instances powered by AWS Graviton processors. If you’ve been working with Redshift’s RA3 instances, this matters to you: RG instances deliver up to 2.4x faster performance on the same workloads while costing 30% less per vCPU. But the performance bump isn’t the only story here—the integrated data lake query engine fundamentally changes how you can structure your analytics infrastructure.

Kubernetes v1.36: Moving Volume Group Snapshots to GA

Kubernetes v1.36 marks an important milestone for storage management with Volume Group Snapshots reaching General Availability (GA). This feature, which has progressed through Alpha (v1.27) and Beta (v1.32) phases, is now stable enough for production workloads. For teams running stateful applications on Kubernetes, this means you can now reliably snapshot multiple persistent volumes at the same time—a capability that was previously fragmented and difficult to coordinate.

Volume Group Snapshots solve a real problem: coordinating consistent snapshots across multiple storage volumes. In Kubernetes, applications often use multiple PersistentVolumes (think a database with separate volumes for data, logs, and backups). Previously, you had to manually snapshot each volume individually, which created timing gaps where your snapshots wouldn’t be truly consistent. Now, the VolumeGroupSnapshot API lets you define multiple volumes as a group and capture them atomically. The feature works by leveraging your underlying storage provider’s snapshot capabilities—whether that’s AWS EBS, Google Cloud Persistent Disks, or other CSI-compatible storage systems. When you create a VolumeGroupSnapshot resource, Kubernetes communicates with the storage provider to snap all volumes simultaneously, ensuring consistency at a specific point in time.

AWS Weekly Roundup: Amazon Bedrock AgentCore payments, Agent Toolkit for AWS, and more (May 11, 2026)

One of the most significant updates from AWS this week introduces managed payment capabilities to Amazon Bedrock AgentCore—a feature that fundamentally changes how AI agents can operate autonomously. Until now, building agents that could independently purchase services, call paid APIs, or pay for compute resources required you to build custom payment infrastructure from scratch. This meant handling credential management, billing reconciliation, PCI compliance, and integration with payment processors yourself. Bedrock AgentCore now abstracts away this complexity with built-in payment capabilities, developed in partnership with Coinbase and Stripe.

Kubernetes v1.36: More Drivers, New Features, and the Next Era of DRA

If you’ve struggled with allocating GPUs, TPUs, or other specialized hardware in Kubernetes, you’re not alone. Platform teams have long faced a frustrating reality: the standard resource request model (CPU and memory) doesn’t capture the complexity of modern hardware accelerators. Kubernetes v1.36 tackles this head-on with significant maturity improvements to Dynamic Resource Allocation (DRA), a feature that’s reshaping how teams manage specialized hardware at scale. This release marks a pivotal moment where DRA moves from experimental territory into something platform administrators can seriously consider for production workloads.

Building an end-to-end agentic SRE using AWS DevOps Agent

The traditional SRE workflow hasn’t fundamentally changed in years: something breaks, a human gets paged, they log into multiple dashboards, correlate logs and metrics across tools, hypothesize what went wrong, and manually execute remediation steps. This process works fine when you’re managing a handful of servers, but modern cloud architectures—with their distributed microservices, serverless functions, and event-driven systems—generate so much data and complexity that manual incident response becomes a bottleneck. AWS’s new DevOps Agent represents a shift in how we can approach this problem: instead of waiting for humans to react, we can automate the entire investigation and remediation workflow using agentic AI that understands your infrastructure.

Improving token efficiency in GitHub Agentic Workflows

If you’ve been experimenting with AI agents in your CI/CD pipelines, you’ve probably noticed something: those token counts add up fast. GitHub recently shared how they tackled this exact problem in their own production workflows, and the lessons are worth understanding whether you’re running agents on every pull request or planning to.

Agentic workflows—automated systems that use AI models to reason through tasks, make decisions, and take actions—have become a practical way to automate code review, testing, and deployment tasks. The problem is that each agent invocation can consume significant API tokens, especially when running on high-frequency events like pull requests. A small inefficiency in how you’re prompting your agents or structuring their context can multiply across thousands of runs, turning what seemed like a reasonable automation into an unexpectedly expensive bill. GitHub’s team discovered they were passing redundant information to their models, making unnecessary API calls, and regenerating context that could have been cached or reused. For a company running agents at scale, these inefficiencies weren’t just costly—they were slowing down feedback loops and adding latency to their development process.

Kubernetes v1.36: Server-Side Sharded List and Watch

Kubernetes clusters are getting bigger, and bigger clusters create bigger problems. When you’re running tens of thousands of nodes, controllers that need to watch resources like Pods start hitting a scaling wall. Every instance of a horizontally scaled controller receives the complete stream of events from the API server—and that’s expensive. Each replica deserves to deserialize every single object, even though most of them don’t belong to that replica’s slice of responsibility. This redundancy multiplies CPU, memory, and network costs across your entire control plane. Kubernetes v1.36 introduces server-side sharded list and watch to fix this inefficiency.

Validating agentic behavior when correct isn't deterministic

The challenge of validating AI agents cuts to the heart of modern development workflows. When GitHub Copilot or similar coding agents generate solutions, how do you know if they’re actually correct? Unlike traditional unit tests where inputs map to deterministic outputs, agentic systems can arrive at valid solutions through multiple legitimate paths. A function might be refactored differently, use alternative libraries, or follow different architectural patterns—all while being functionally correct. This ambiguity makes validation incredibly difficult, and it’s why many teams struggle to trust autonomous agents in their CI/CD pipelines.

The AWS MCP Server is now generally available

AWS has released the AWS MCP Server as a generally available service, marking a significant step in making AI agents and coding assistants more practical for enterprise AWS environments. If you’ve been following the evolution of AI tooling, you’ve probably noticed a growing gap: AI agents and coding assistants are getting smarter, but they often lack secure, authenticated access to your actual infrastructure. The AWS MCP Server fills that gap by implementing the Model Context Protocol (MCP)—an open standard that lets these AI tools safely interact with AWS services without requiring complex custom integrations.

Kubernetes v1.36: Declarative Validation Graduates to GA

If you’ve ever deployed a Kubernetes manifest and gotten a cryptic validation error, you’ve encountered the limitations of the old way Kubernetes validates your resources. With Kubernetes v1.36, Declarative Validation—a feature that’s been in beta for a while—has now reached General Availability. This might sound like an internal implementation detail, but it’s actually a meaningful shift in how Kubernetes handles validation, and it matters if you’re building reliable infrastructure.

Here’s what’s changed under the hood: traditionally, Kubernetes validation rules for native resources (like Pods, Services, and Deployments) were hardcoded directly into the API server using Go. This approach works, but it’s rigid and difficult to extend. Declarative Validation moves these rules into a declarative format called Common Expression Language (CEL) rules, which are stored alongside the resource definitions themselves. Think of it as shifting from validation logic buried in source code to validation rules that live in your OpenAPI schema. For you as a user, this means validation errors become clearer and more consistent across different tools. Instead of mysterious rejection messages, you’ll see exactly which field violated which rule and why. The validation rules are also now documented as part of the API spec, so tools like kubectl and the Kubernetes dashboard can surface that information directly.

Modernize your workflows: Amazon WorkSpaces now gives AI agents their own desktop (preview)

The gap between legacy systems and modern AI has always been one of the trickiest problems in enterprise automation. You’ve got decades-old desktop applications that run critical business processes, but they were never designed to talk to AI agents. Until now, bridging that gap meant either ripping and replacing the entire system or building custom integrations—both expensive and risky propositions. AWS is tackling this differently with a preview feature that lets AI agents operate desktop applications directly through Amazon WorkSpaces, the managed virtual desktop service. Instead of modernizing your backend, you’re giving the AI agent its own desktop environment to interact with applications the way a human would.

Enforcing trust and transparency: Open-sourcing the Azure Integrated HSM

When you’re building AI systems or automation pipelines in the cloud, you’re making a fundamental bet: that your encryption keys—the digital equivalent of your master password—stay secure. Microsoft’s recent move to open-source the Azure Integrated HSM signals a shift in how cloud providers are approaching this problem. Rather than asking you to simply trust that keys are protected behind closed doors, Azure is pulling back the curtain. By open-sourcing the HSM (Hardware Security Module) design, Microsoft is letting security teams and researchers verify exactly how cryptographic trust flows from the silicon level all the way up through Azure services.

AWS Transform custom: Enterprise Code Modernization with the Learn-Scale-Improve Flywheel

There’s a fundamental difference between modernizing one codebase and modernizing fifty. When you’re dealing with a single repository, the challenge is mostly technical—you pick a tool, run it, review the output, and iterate. But at enterprise scale, the bottleneck shifts. You’re no longer asking “can we modernize this code?” but rather “how do we coordinate teams, share learnings, and maintain quality across hundreds of repositories while keeping velocity high?” AWS Transform custom addresses this reality by treating code modernization not as a one-time event, but as a continuous learning system.

Kubernetes v1.36: Pod-Level Resource Managers (Alpha)

Kubernetes v1.36 introduces Pod-Level Resource Managers as an alpha feature, marking a significant shift in how the platform handles resource allocation for performance-sensitive workloads. Previously, resource management policies in Kubernetes were set at the node level through kubelet configuration—a one-size-fits-all approach that often forced teams into uncomfortable compromises. The new feature allows you to define resource management strategies at the pod level, giving you granular control over CPU pinning, memory management, and topology-aware scheduling without requiring node-level changes or multiple kubelet configurations.

A Virtual Agent team at Docker: How the Coding Agent Sandboxes team uses a fleet of agents to ship faster

At Docker, the Coding Agent Sandboxes team (internally known as “sbx”) is solving a problem that’s becoming increasingly important as AI coding agents proliferate: how do you safely give autonomous AI agents the freedom to write, test, and deploy code without risking your host system? The answer is a fleet of lightweight, containerized sandboxes that provide each AI agent—whether it’s Claude Code, Gemini, Codex, Docker Agent, or Kiro—complete isolation with full autonomy. Think of it like giving each agent its own isolated development environment where it can do whatever it needs without consequences bleeding back to your infrastructure.

OpenAI's GPT-5.5 in Microsoft Foundry: Frontier intelligence on an enterprise ready platform

When a new frontier AI model becomes available, most developers ask the same question: can I actually use this in production? Microsoft’s announcement that OpenAI’s GPT-5.5 is now generally available through Microsoft Foundry answers that with a clear yes. This isn’t just about access to cutting-edge AI—it’s about getting enterprise-grade infrastructure, compliance tooling, and support wrapped around it. For teams building agents and automation workflows on Azure, this means you can now deploy GPT-5.5 with the same reliability and governance frameworks you’d use for mission-critical applications.

Kubernetes v1.36: In-Place Vertical Scaling for Pod-Level Resources Graduates to Beta

The Kubernetes community has reached another milestone with v1.36: In-Place Pod-Level Resources Vertical Scaling is now graduating to Beta status and enabled by default. If you’ve been following the feature’s journey through earlier versions, this represents a meaningful step toward stability. For those new to the concept, this feature addresses one of Kubernetes’ long-standing operational challenges—adjusting CPU and memory requests and limits for running pods without forcing a restart. Previously, if you realized a pod needed more resources, you had to terminate it and redeploy it with new specifications, causing service interruption. In-place vertical scaling eliminates that painful workflow.

GitHub Copilot CLI for Beginners: Interactive v. non-interactive mode

GitHub Copilot CLI is an AI-powered tool that brings code suggestions directly to your terminal. Instead of switching between your code editor and documentation, you can describe what you need and get intelligent command suggestions right where you’re working. It integrates with your shell environment and uses natural language processing to understand your intent—whether you need a complex AWS CLI command, a Python one-liner, or a system administration task. For teams managing cloud infrastructure or building automation scripts, this can significantly reduce context-switching and the time spent hunting through documentation.

Kubernetes v1.36: Tiered Memory Protection with Memory QoS

Memory management has always been one of the trickier aspects of running containers at scale. You set resource requests and limits, hope nothing goes wrong, and then debug mysterious OOM (out-of-memory) kills at 3 AM. Kubernetes v1.36 is making this situation materially better with significant updates to Memory QoS, a feature that’s been evolving since v1.22. The new tiered memory protection system gives the Linux kernel much more nuanced guidance about which containers deserve memory when resources get tight, moving beyond the blunt instrument of hard limits.

Top announcements of the What's Next with AWS, 2026

AWS just wrapped their What’s Next event with three major announcements that signal where enterprise AI is heading. If you’re building on AWS or planning to, these updates deserve your attention because they’re reshaping how teams integrate AI into their workflows and operations.

The headline grab is Amazon Quick, a new AI assistant designed specifically for work. Think of it as AWS’s answer to the enterprise AI assistant problem—it’s built to understand context across your AWS environment, internal tools, and documentation. What makes it technically interesting is the desktop app approach combined with expanded integrations. Rather than forcing everything through a chat interface, Quick can natively connect to your existing tools and APIs. For a development team, this means asking Quick to help debug CloudFormation templates, explain your architecture decisions, or even scaffold boilerplate code without bouncing between windows. Under the hood, this likely leverages foundational models through Amazon Bedrock with retrieval-augmented generation (RAG) to pull context from your actual infrastructure and documents. The practical win here is reduced context-switching and faster onboarding for teams learning your specific setup.

Kubernetes v1.36: Staleness Mitigation and Observability for Controllers

If you’ve ever debugged a Kubernetes controller that mysteriously took the wrong action at the worst possible time, you’ve probably encountered staleness. Staleness happens when a controller makes decisions based on outdated information about your cluster’s state. A controller might read that a pod exists, but by the time it acts on that information, the pod has already been deleted. Or it might see an old version of a ConfigMap and roll out stale configuration to your services. These race conditions are notoriously difficult to catch during testing because they depend on precise timing—they often only surface under production load, after they’ve already caused damage.

Microsoft Discovery: Advancing agentic R&D at scale

Microsoft has expanded preview access to Microsoft Discovery, a new set of enterprise-grade AI capabilities designed specifically for research and development teams. This platform brings autonomous AI agents into the R&D workflow, allowing teams to automate complex, iterative processes that typically require significant manual effort. For organizations managing large-scale research projects—whether in pharmaceuticals, materials science, or software development—this represents a meaningful shift in how teams can approach experimentation and data analysis.

Kubernetes v1.36: Mutable Pod Resources for Suspended Jobs (beta)

Kubernetes v1.36 is promoting a useful feature to beta: the ability to modify container resource requests and limits while a Job is suspended. If you’re managing workloads at scale, this sounds like a niche feature—but it solves a real operational headache. Previously, once you created a Job with specific CPU and memory requests, those values were locked in. If you needed to adjust resources before the job ran, you had to delete and recreate it. Now you can modify the pod template of a suspended Job, adjust CPU, memory, GPU, and custom resources, then resume it without losing your place in the queue or restarting from scratch.

AWS Weekly Roundup: Anthropic & Meta partnership, AWS Lambda S3 Files, Amazon Bedrock AgentCore CLI, and more (April 27, 2026)

This week’s AWS announcements showcase a continued push toward making AI development more accessible and practical for enterprise teams. The major highlights—including a strategic partnership between Anthropic and Meta, new Lambda integrations for S3, and expanded Bedrock tooling—signal AWS’s focus on reducing friction in the AI development lifecycle. For teams building on AWS, these updates mean fewer workarounds and more direct paths from experimentation to production.

The Anthropic and Meta partnership represents a significant shift in how foundational models are being integrated into AWS services. Rather than competing in isolation, these companies are aligning to improve model accessibility and interoperability across platforms. From a technical standpoint, this means AWS customers will have more options when selecting which AI models power their applications through Amazon Bedrock. If you’re currently locked into a single model provider, this partnership creates leverage—you can test multiple models against the same workload without rebuilding your integration layer. The practical benefit? Better price negotiation, model redundancy for reliability, and the ability to choose the best tool for specific tasks (like Claude for complex reasoning or Meta’s models for cost-sensitive applications).

Introducing GPT-5.5

OpenAI just released GPT-5.5, their latest large language model, and it’s worth paying attention to if you’re building with AI in the cloud. This model improves on previous versions with better speed and reasoning capabilities, particularly for tasks that require sustained focus like writing production code, analyzing datasets, and conducting research. If you’ve been experimenting with GPT-4 or Claude, GPT-5.5 represents a meaningful step forward in handling the kind of complex, multi-step problems you actually encounter in real projects.

Kubernetes v1.36: Fine-Grained Kubelet API Authorization Graduates to GA

Kubernetes v1.36 marks an important milestone for cluster security: fine-grained kubelet API authorization has reached General Availability (GA). This feature, which began as an alpha experiment in v1.32 and moved to beta in v1.33, is now production-ready and will be enabled by default in new clusters. For teams managing Kubernetes at scale, this graduation matters because it gives you precise control over who can do what on individual nodes—closing a significant security gap that’s existed in Kubernetes for years.

Highlights from Git 2.54

Git 2.54 is the latest stable release of the distributed version control system that powers most modern development workflows. For anyone working with infrastructure automation, AI model repositories, or cloud deployments, understanding what’s new in Git can directly impact your productivity and how you manage code across teams. GitHub recently published their analysis of the most significant features and improvements in this release, offering insights into changes that affect daily development practices.

Speeding up agentic workflows with WebSockets in the Responses API

Agent-based systems have transformed how we think about automation in the cloud. Instead of rigid workflows, agents can reason through problems, take actions, and adapt based on results. But there’s a catch: traditional REST APIs introduce latency overhead that compounds with each agent step. OpenAI’s recent work on WebSocket support in the Responses API tackles this head-on by maintaining persistent connections and caching context across agent loops. For teams building autonomous systems—whether that’s code generation pipelines, customer service agents, or data processing workflows—this optimization can mean the difference between a system that feels responsive and one that feels sluggish.

Gateway API v1.5: Moving features to Stable

The Kubernetes ecosystem just got a significant stability boost. On March 14, 2026, the Kubernetes SIG Network community released Gateway API v1.5—a milestone release that graduates several experimental features into stable, production-ready status. If you’re running Kubernetes clusters and managing ingress traffic, this is worth paying attention to. Gateway API represents the next generation of how Kubernetes handles north-south traffic (traffic entering and leaving your cluster), moving beyond the older Ingress API with a more flexible, role-based design.

Automating Incident Investigation with AWS DevOps Agent and Salesforce MCP Server

Every minute counts during a production incident. While your team scrambles to understand what’s happening, customers are already noticing the outage. Traditional incident response relies on manual investigation—jumping between monitoring dashboards, checking logs, reviewing configuration changes, and updating ticket systems. AWS DevOps Agent, developed in collaboration with Salesforce, streamlines this process by automating the investigation phase, allowing teams to diagnose problems faster and keep stakeholders informed automatically.

At its core, AWS DevOps Agent combines two key technologies working together. The agent itself is an autonomous system that can investigate AWS infrastructure issues by accessing CloudWatch logs, EC2 instances, and other AWS services on your behalf. The Salesforce MCP (Model Context Protocol) Server acts as a bridge, allowing the agent to read and update incident information directly in Salesforce Service Cloud. When an incident is detected, instead of a human opening multiple tabs and manually gathering information, the agent begins investigating immediately. It searches relevant logs, identifies recent changes in your environment, checks resource utilization metrics, and correlates these findings into a coherent incident narrative—all while automatically updating your Salesforce ticket with findings and status.

AWS Weekly Roundup: Claude Opus 4.7 in Amazon Bedrock, AWS Interconnect GA, and more (April 20, 2026)

This week brings several significant updates across AWS’s AI, networking, and infrastructure services. Claude Opus 4.7 is now available in Amazon Bedrock alongside new connectivity options and security enhancements. If you’re building multi-model AI applications, managing hybrid cloud infrastructure, or concerned about quantum-safe encryption, there’s something here worth your attention.

Claude Opus 4.7 and the 1M Token Context Window

Anthropic’s Claude Opus 4.7 is now available through Amazon Bedrock, bringing meaningful improvements for developers building AI agents. The headline feature is the 1 million token context window—roughly equivalent to 750,000 words. Technically, this means you can pass an entire codebase, lengthy documentation, or months of conversation history in a single API call without token limits becoming a constraint. The model also ships with improved agentic coding capabilities, meaning it can write, debug, and refactor code with better accuracy than previous versions. Practically, this matters for teams building code analysis tools, documentation chatbots, or multi-step automation workflows. Instead of chunking documents into 100K token segments and making multiple API calls, you can now process large datasets in parallel, reducing latency and complexity in your application logic.

Building an emoji list generator with the GitHub Copilot CLI

GitHub recently demonstrated a practical example of AI-assisted development during their Rubber Duck Thursday stream: building an emoji list generator using the GitHub Copilot CLI. While emoji generators might sound like a novelty, the underlying technique reveals something genuinely useful for developers working with APIs, data transformation, and rapid prototyping. The Copilot CLI lets developers ask natural language questions directly from the terminal, turning the command line into an interactive problem-solving partner without leaving your workflow.

AWS Interconnect is now generally available, with a new option to simplify last-mile connectivity

AWS just announced the general availability of two interconnectivity services that address a real problem many organizations face: connecting infrastructure across multiple cloud providers securely and efficiently. If you’ve ever struggled with the complexity of establishing private connections between your AWS environment and resources on Azure, Google Cloud, or your own data center, these new tools are worth understanding.

At its core, AWS Interconnect – multicloud does something straightforward: it creates managed private connectivity between your Amazon VPC and VPCs on other cloud providers without routing traffic over the public internet. Technically, this builds on AWS’s existing Direct Connect infrastructure, but extends it to work with other clouds. Instead of configuring VPN tunnels manually or dealing with the complexity of peering agreements, you get a managed service that handles the heavy lifting. The new AWS Interconnect – last mile component addresses the “final stretch” problem—that expensive and often complicated last connection from your on-premises network or regional office to the AWS network itself. Rather than paying for expensive dedicated lines or dealing with carrier provisioning delays, last mile gives you a more straightforward way to establish these high-speed connections.

How GitHub uses eBPF to improve deployment safety

When you’re managing deployments across thousands of services, one subtle bug can cascade into a production outage. GitHub recently shared how they’re using eBPF (extended Berkeley Packet Filter) to catch one particularly nasty class of problems: circular dependencies in their deployment tooling. This technique represents a practical evolution in how infrastructure teams can observe and prevent failures before they happen.

At its core, eBPF is a technology that lets you run sandboxed programs inside the Linux kernel without modifying kernel code or loading kernel modules. Think of it as a safe way to insert observability hooks directly where the action happens—at the system level where processes communicate, make network calls, and access files. GitHub’s team used eBPF to instrument their deployment pipeline and trace the dependency relationships between services in real time. By hooking into system calls and tracking which services attempt to load or depend on which other services, they could build a live map of deployment dependencies. When the eBPF program detected a circular path (Service A depends on B, B depends on C, C depends on A), it could immediately flag the issue and prevent the problematic deployment from proceeding.

Introducing Anthropic's Claude Opus 4.7 model in Amazon Bedrock

Last week, AWS announced the availability of Claude Opus 4.7, Anthropic’s latest and most capable model in the Opus family, now accessible through Amazon Bedrock. This release marks a meaningful step forward in accessible enterprise AI, particularly for teams working with AWS infrastructure. Claude Opus 4.7 is optimized for tasks requiring deep reasoning and complex problem-solving—think multi-step coding projects, autonomous agent workflows, and professional analysis where accuracy matters. What makes this launch notable isn’t just the model itself, but how it’s integrated into Bedrock’s infrastructure, which AWS has rebuilt specifically for generative AI workloads.

Build a personal organization command center with GitHub Copilot CLI

GitHub recently shared how one of their engineers built a personal organization command center—essentially a custom CLI tool that acts as a single entry point for managing tasks, calendar events, and project work. The project is a great example of how modern AI tools like GitHub Copilot CLI can accelerate development of internal productivity tools that would’ve taken significantly longer to build manually. Rather than spending weeks writing boilerplate code and debugging command parsing, the engineer leveraged Copilot to scaffold the project structure, handle common patterns, and solve specific problems interactively.

The next evolution of the Agents SDK

OpenAI just released significant updates to their Agents SDK that address one of the biggest pain points in building production AI agents: security and execution isolation. If you’re working with autonomous agents that need to interact with files, databases, or external tools over extended periods, this update is worth your attention.

The core improvement centers on native sandbox execution. Previously, when you built an agent that needed to run code or access files, you had to handle isolation yourself—spinning up containers, managing permissions, cleaning up resources. It was workable but added complexity and potential security vulnerabilities. The updated SDK now provides built-in sandboxing, meaning your agent’s code runs in an isolated environment by default. Think of it like running Python scripts in a restricted subprocess, but handled automatically by the framework. This matters because agents that run unattended need hard guarantees that they can’t accidentally (or maliciously) access data outside their scope.

Troubleshooting environment with AI analysis in AWS Elastic Beanstalk

AWS Elastic Beanstalk has long been a go-to platform for developers who want to deploy web applications without getting bogged down in infrastructure management. You push your code, and Elastic Beanstalk handles the heavy lifting—provisioning capacity, configuring load balancers, scaling instances, and monitoring health. But even with all this automation, things still break. Your application might be consuming too much memory, your database connections could be pooling incorrectly, or environment configuration issues might be silently degrading performance. Historically, tracking down these problems meant digging through logs, comparing metrics against baselines, and making educated guesses. AWS has now added AI Analysis to this toolset, bringing automated troubleshooting directly into the Elastic Beanstalk console.

AWS Weekly Roundup: Claude Mythos Preview in Amazon Bedrock, AWS Agent Registry, and more (April 13, 2026)

As AI models move from experimental side projects into critical business workflows, teams face a hard reality: cost visibility becomes non-negotiable. AWS is addressing this squeeze with several new releases that acknowledge the practical challenges of scaling AI workloads. The Claude Mythos preview in Amazon Bedrock, combined with the new AWS Agent Registry, represents a meaningful shift toward production-ready AI infrastructure rather than just raw model access.

The Claude Mythos preview is important because it demonstrates how foundation models are evolving beyond size and capability metrics into specialized variants optimized for real constraints. When you’re running inference at scale—say, processing thousands of support tickets or analyzing document batches—the difference between a general-purpose model and one tuned for your specific task can mean the difference between a sustainable operation and cost overruns that catch your finance team off guard. Mythos reportedly focuses on improved efficiency in particular domains, which technically means better token-to-output ratios and lower latency for common patterns. For your Python workflows calling Bedrock’s API, this translates to more predictable costs and faster response times without architectural changes.

Kubernetes v1.36 Sneak Peek

Kubernetes v1.36 is arriving in late April 2026, and the community is gearing up for another significant release cycle. Like every major version bump, this one brings the usual mix of removals, deprecations, and new features—but this time, the enhancement list is notably substantial. If you’re managing containerized workloads in production or exploring Kubernetes for the first time, understanding what’s coming helps you plan upgrades and adjust your automation strategies accordingly.

Securely connect AWS DevOps Agent to private services in your VPCs

AWS DevOps Agent represents a meaningful shift in how teams handle operational tasks across distributed infrastructure. Rather than jumping between monitoring dashboards, ticketing systems, and cloud consoles, you get an AI-powered teammate that understands your entire stack—AWS, multicloud, and on-premises systems included. The agent proactively identifies incidents before they impact users, suggests optimizations based on real performance data, and handles routine SRE work like log analysis and root cause investigation. If you’re managing complex deployments where context switching kills productivity, this tool addresses a real pain point.

Launching S3 Files, making S3 buckets accessible as file systems

Amazon S3 has always presented developers with a choice: use object storage for its scalability and cost benefits, or switch to traditional file systems when you need interactive file access. S3 Files bridges this gap by mounting S3 buckets directly as file systems on EC2 instances, Lambda functions, and other AWS compute resources. This means you can now access objects in S3 using standard file operations—ls, cat, grep, mv—without building custom APIs or managing separate storage infrastructure.

GitHub Copilot CLI for Beginners: Getting started with GitHub Copilot CLI

If you’ve been working in the terminal lately, you’ve probably noticed how much time goes into remembering syntax, debugging commands, and looking up documentation. GitHub Copilot CLI brings the AI-assisted coding experience you might know from the editor directly into your command line, making it easier to construct complex commands, understand error messages, and automate repetitive tasks—without constantly switching between your terminal and browser windows.

At its core, GitHub Copilot CLI uses the same foundation as other Copilot products: a large language model trained on vast amounts of code and documentation that understands context and intent. When you describe what you want to accomplish in natural language—say, “find all Python files modified in the last week”—the CLI translates that into the appropriate command for your system, whether that’s Linux, macOS, or Windows. It works by analyzing your description, considering your current shell environment, and generating shell commands that match your intent. You maintain full control: the tool shows you what it’s about to run, and you approve or modify commands before execution.

GitHub Copilot CLI combines model families for a second opinion

If you’ve ever asked a colleague to review your bash command or SQL query, you understand the value of a second perspective. GitHub has introduced a similar concept into Copilot CLI through a feature called Rubber Duck—a way to get multiple AI viewpoints on the same problem. Instead of relying on a single model’s suggestion, Rubber Duck leverages different model families to cross-check and validate proposed solutions before you run them in production.

Running Agents on Kubernetes with Agent Sandbox

The way we build AI applications is fundamentally changing. For years, the dominant pattern was simple: send a prompt to an AI model, get a response back, move on. But that era is ending. We’re shifting toward something more sophisticated—AI agents that can think, plan, and take actions over extended periods. This transition creates new architectural challenges, especially around deployment and resource management. That’s where running agents on Kubernetes with Agent Sandbox comes in.

Streamlining Cloud Compliance at GoDaddy Using CDK Aspects

At scale, managing cloud compliance feels like herding cats. Every team deploys resources differently, security rules get forgotten, and suddenly you’re auditing hundreds of stacks to find resources missing required tags or using the wrong encryption settings. GoDaddy faced exactly this problem—and solved it with AWS CDK Aspects, a feature that applies organization-wide policies automatically across your entire infrastructure as code.

CDK Aspects work by implementing the Visitor pattern to traverse your infrastructure constructs and enforce standards before resources are deployed. Think of them as automated compliance checkpoints that run during the synthesis phase. When you define a CDK Aspect, you write code that inspects every construct in your stack—from S3 buckets to RDS databases—and either validates that it meets your requirements or modifies it to comply. For example, you could create an Aspect that checks every S3 bucket has default encryption enabled, or automatically adds cost-tracking tags to all resources. The key advantage: these rules apply consistently across all your stacks, no matter which team deployed them or when they were created.

Amazon S3 Files: making S3 buckets accessible as file systems

AWS just launched S3 Files, a feature that turns S3 buckets into fully accessible file systems for compute resources. If you’ve ever dealt with the friction of copying data between S3 and file-based applications, this is the kind of update that changes your workflow fundamentally. S3 Files delivers a shared file system interface on top of S3, combining the scalability, durability, and cost-effectiveness of object storage with the semantics applications expect from a traditional file system.

Amazon Bedrock Guardrails supports cross-account safeguards with centralized control and management

If you’ve been working with Amazon Bedrock to build generative AI applications, you’ve likely had to think about safety controls. The question of how to enforce consistent guardrails across multiple projects and AWS accounts just got easier. AWS has made organizational safeguards generally available in Amazon Bedrock Guardrails, which means you can now define safety policies once and apply them across your entire AWS Organization. This is a meaningful shift for teams managing AI applications at scale, moving from scattered, account-specific controls to a unified governance model.

Run multiple agents at once with /fleet in Copilot CLI

The GitHub Copilot CLI just got a powerful new capability: the /fleet command. Instead of running one agent at a time to solve a problem, you can now dispatch multiple agents in parallel to work on different parts of your task simultaneously. This is a meaningful shift in how you can interact with AI-assisted development—from sequential, single-threaded assistance to concurrent, distributed problem-solving. If you’ve ever wished you could have Copilot work on multiple files or components at the same time, /fleet is designed for exactly that scenario.

Autonomous Incident Response: How AWS DevOps Agent Brings Agentic AI to Your Operations

The operational challenge is familiar to anyone running distributed systems: when something breaks, the information you need is scattered across logs, metrics, deployment pipelines, and dozens of monitoring dashboards. You spend precious minutes just gathering context before you can even start troubleshooting. AWS DevOps Agent aims to change this by bringing agentic AI directly into your incident response workflow—an always-on operations teammate that can investigate, correlate data, and take action without waiting for human intervention.

Microsoft takes on AI rivals with three new foundational models

Microsoft has just announced three new foundational AI models, marking a significant move in its competition against other major players in the artificial intelligence space. These models were released by MAI following the group’s establishment just six months ago. The announcement demonstrates Microsoft’s commitment to developing diverse AI capabilities rather than relying solely on large language models like those powering ChatGPT.

The three new models cover important use cases across different data types. One model handles speech-to-text transcription, converting spoken audio into written text with high accuracy. A second model focuses on audio generation, enabling systems to create spoken content programmatically. The third model tackles image generation, allowing developers to create visual content through code. For IT professionals and developers, this means more options for integrating multimodal AI capabilities into applications without depending on external vendors or third-party APIs.