GKE Dynamic Slicing Goes GA, Nitro Sandboxes Hit EKS, and CloudNativePG Graduates
7 min read · 12 sources
- GKE dynamic slicing is GA for TPUs, cutting AI workload startup times by up to 5x and recovery by 4.5x.
- AWS Nitro Sandboxes for EKS provide hardware-enforced isolation per pod with a single line in the pod spec.
- Octopus Deploy's Cost Intelligence for Argo CD is open source and shows per-application cloud costs after each sync.
- CloudNativePG became a CNCF incubating project, managing PostgreSQL in Kubernetes without StatefulSets.
- Meta open-sourced Astryx, a design system with 150+ components powering 13,000+ internal apps.
Google made the biggest splash today with GKE dynamic slicing going generally available for TPUs. The headline numbers are brutal and simple: AI workload startup times drop by up to 5x, and recovery times by 4.5x. That’s not incremental tuning; that’s the difference between waiting out a TPU pod failure and actually getting back to training.
The rest of the day is about isolation - hardware-enforced, cost-attributed, and agent-safe. AWS finally gave EKS pods the Nitro treatment, Octopus Deploy wants you to know exactly what each Argo CD sync costs, and the Kubernetes community is still arguing about whether AI agents can ever be trusted to recover on their own. CloudNativePG also quietly graduated to CNCF Incubation, which matters more than it sounds.
GKE dynamic slicing cuts AI workload startup times by up to 5x and recovery times by 4.5x, now generally available for TPUs.
GKE Dynamic Slicing Is GA, and It's Fast
Google’s GKE dynamic slicing is now generally available for TPUs. The change: slice formation is now decoupled from nodepool provisioning. Previously, if you wanted a TPU slice, you had to provision the entire nodepool first, then wait for the slice to form. That’s two sequential waits. Now they happen in parallel, which is why startup times drop by up to 5x and recovery by 4.5x.
For anyone running large model training on GKE, this is the difference between a failed TPU node killing an afternoon and it costing you a coffee break. The feature also means you can resize slices without ripping up the nodepool, which is the kind of operational flexibility that makes TPU fleets actually manageable. If you’ve been holding off on TPUs because of the operational pain, this removes a real chunk of it.
Cost Intelligence for Argo CD: Finally, Syncs Have a Price Tag
Octopus Deploy released Cost Intelligence for Argo CD, an open-source extension that puts a cost tab right in the Argo CD UI. It runs alongside Argo CD, pulls data from OpenCost after each successful sync, and projects 24-hour measurements onto a 30-day month. The clever part: it only counts pods belonging to workloads Argo CD manages for that application, so shared namespaces don’t pollute the numbers.
This solves the eternal “who blew up the bill” problem. When your cloud spend spikes, you can now trace it to a specific sync, which is a specific commit, which is a specific change. It requires Argo CD 3.4 to 3.6 and OpenCost 1.121.1 or newer. For anyone running GitOps at scale, this turns cost attribution from a weekly detective exercise into a click.
AWS Nitro Sandboxes: Hardware Isolation for Every Pod
AWS announced Nitro Sandboxes for Amazon EKS, giving each pod its own lightweight VM backed by the Nitro System. The pitch: the isolation of a dedicated EC2 instance with the simplicity of a Kubernetes pod. Enable it with a single line in the pod spec - no container image changes, no pipeline rewrites.
There are two modes. Isolated mode gives standard hardware-enforced protection. Confidential mode adds cryptographic attestation, which is what regulated workloads and multi-tenant SaaS need. This is aimed squarely at the shared-kernel problem: AI agents, untrusted LLM-generated code, and any workload where a kernel escape would be catastrophic. The cost angle is real too - you no longer need a dedicated instance per sensitive workload, so you can consolidate while getting stronger isolation. Near bare-metal performance, per AWS.
Kubernetes Restarts AI Agents, But Can't Recover Their Work
This piece from Cloud Native Now nails the gap: Kubernetes can restore an agent’s environment, but it has no record of which steps completed. A restarted agent will happily re-run a payment it already made. That’s not a hypothetical - that’s the failure mode that makes production agents dangerous.
Two projects are trying to fix this. Kubernetes SIG Apps’ Agent Sandbox gives stateful pods with stable identity. Google’s Agent Substrate isolates agents in microVMs or gVisor and resumes them in under 500ms. But neither tracks completed execution steps. The author argues for durable execution that logs each step, pointing at Dapr’s workflow engine as an option. Until Kubernetes gets execution history baked in, agents need both sandboxing and a durable execution record, or they’re not safe to let loose with credentials.
Meta Open-Sources Astryx, Its 13,000-App Design System
Meta released Astryx, an open-source design system in Beta built on React 19+ and StyleX. It’s been powering 13,000+ apps internally for eight years, and it ships 150+ accessible components, theming, dark mode, templates, and a CLI. The notable part: no build plugin or styling library required, and you can customize via CSS custom properties or swizzle to eject component source.
It’s designed for both humans and AI agents to build with the same tooling, which is the direction every serious frontend framework is heading. The no-styling-lock-in angle is the differentiator - you get the components without being forced into a styling paradigm. For teams standardizing on React, this is worth a serious look.
HA-MCP: Home Assistant Gets a First-Class MCP Server
HA-MCP is an integration that installs into Home Assistant via HACS or the built-in Marketplace, running the MCP server in-process with full feature parity across all installation types. It requires Home Assistant 2026.8.0 or newer, and setup needs an administrator access token or a dedicated account. Clients can connect via remote access.
This is the recommended way to run an MCP server for Home Assistant, which means Claude or ChatGPT can now control your lights, locks, and thermostats. The security consideration is real: that access token is powerful, so use a dedicated account with limited scope. For home-lab enthusiasts, this is the missing piece for natural-language home automation.
MCP Servers Have Security Holes. Here's How to Plug Them
Solo.io’s guide walks through the ugly truth: Model Context Protocol servers have no built-in authentication, rate limiting, or tool controls. stdio servers can’t run through a gateway at all, meaning zero security. StreamableHTTP servers are black boxes with unknown security, and testing them requires permission.
The fix: deploy an AI Gateway using Kubernetes Gateway API CRDs to add token-based authentication and restrict which specific tools are available to users and agents. This is the layer that makes MCP deployment safe for production. If you’re exposing MCP servers to anything beyond localhost, this is required reading.
CloudNativePG Hits CNCF Incubation
CloudNativePG became a CNCF incubating project, up from Sandbox. This is the Kubernetes operator for PostgreSQL that manages the full lifecycle of HA clusters with primary/standby architecture and native streaming replication. The key architectural choice: it runs pods directly, no StatefulSets.
Recent releases added offline in-place major version upgrades (1.26) and a Lease-based primary election mechanism (1.30). For anyone running production Postgres in Kubernetes, this is the standard answer that doesn’t require external failover tooling. CNCF Incubation is a meaningful vote of confidence in its maturity.
Quick Hits
Running Kubernetes at its extremes: the documented limits are 5,000 nodes, 110 pods per node, and 150,000 pods per cluster. Beyond that, etcd hits its 2 GB storage limit and API server performance degrades, though Kubernetes 1.34 improved read caching. The article also covers shrinking Kubernetes to palm-sized devices, exposing control plane resource demands.
Entire’s Git forge, led by former GitHub CEO Thomas Dohmke, is built for human-AI agent collaboration. It claims pushes up to 89x faster than GitHub, and its core feature, trails, shows eval scores that update with every push, assessing code quality, security, and slop. Review agents suggest fixes, and all findings must be resolved before merge. It rethinks the PR model for agent-driven development.
Authenticating external gRPC clients with VPC Lattice: an ALB validates external JWTs, an ECS proxy tier on Fargate translates identity and signs requests with SigV4, and VPC Lattice IAM policies handle authorization. Two SigV4 signing approaches are covered: native AWS SDK and an Envoy filter. This enables secure end-to-end gRPC over HTTP/2 for external clients without handing them AWS credentials.
Seven Production Habits From Wix, Hard-Won
Wix Engineering’s list of seven production habits, learned over eight years operating the editor server team, starts with a mindset shift: see the users behind the metrics, stop blaming. The habits include leaving production better than you found it by fixing one small thing per shift, using the Five Whys method, running post-mortems without blame, and conducting team-wide on-call handovers.
None of these are flashy. That’s the point - small, repeatable behaviors that compound. For anyone dreading on-call, this is the playbook for making production a place you want to work, not a place that wakes you up at 3 AM.
You May Also Like
GKE Pod Snapshots Slash AI Cold Starts, and More Agent Infrastructure News
GKE's new Pod snapshots cut AI inference startup by up to 89%, loading a 70B parameter model in 37 seconds, a direct hit on the cold-start problem that forces …
Salesforce stumbles, Kubernetes gets pod-level resource control, and the cost of your coding agent's harness
Salesforce spent hours stumbling through a global outage that stalled requests on an internal login service and exhausted server resources across hundreds of …
Docker and ActiveState push trusted content down to pip, npm, and Maven
Docker's partnership with ActiveState extends its trusted-content model from base images to the packages developers install through pip, npm, and Maven, with …




