TL;DR
- GKE dynamic slicing is a Google Kubernetes Engine feature, generally available since 9 November 2026, that assembles a TPU slice at scheduling time from capacity already provisioned in cubes of 16 virtual machines.
- Google reports AI workload startup times up to 5x faster and workload recovery 4.5x faster; the baseline is creating a static nodepool for each TPU slice.
- Super-slicing stitches several 16-VM TPU cubes through an optical circuit switch to build slices larger than one cube, such as a 4x4x16 slice of 64 Ironwood VMs and 256 chips.
- Sub-slicing carves a single pre-provisioned cube into smaller independent slices, so jobs with different topologies share one nodepool.
- Incremental provisioning accepts a partially healthy cube and reconciles the missing nodes once faulty hosts return, which makes sub-slicing workable on a real fleet.
- A hardware fault stays inside one cube, and Google says an unhealthy cube is swapped in one to two minutes.
- The workload side is an annotation: the scheduler creates a Slice custom resource at runtime and places the job once the slice exists.
- What a platform team checks first: capacity pre-provisioned as 16-VM cubes, the slice controller enabled, a scheduler that handles dynamic slices, and TPU All Capacity in reservation mode.
Netics visual, 14 November 2026: the operational change Google describes, from a nodepool per slice topology to a slice assembled when a job arrives.
The slice a workload asks for at scheduling time
Google's post describes a specific piece of operational pain. TPU capacity on GKE standard used to arrive as fixed slice-topology nodepools, one per workload shape, so a multi-host nodepool could host only one AI workload and any change of shape meant deleting the nodepool and creating another. A single hardware fault then took down the entire slice, because the slice and the failure domain were the same object.
Dynamic slicing decouples physical hardware provisioning from logical slice formation. Capacity is converted once into uniform nodepools of 16 virtual machines, each one a TPU cube in a 4x4x4 topology, and a workload that asks for a slice gets one assembled at scheduling time from those cubes. Google's headline numbers come from that separation: startup up to 5x faster and recovery 4.5x faster, with the creation of a static nodepool for each slice as the baseline.
The post as published on 9 November 2026, where the 5x startup and 4.5x recovery figures appear in the opening paragraph. Page from https://cloud.google.com/blog/products/containers-kubernetes/gke-dynamic-slicing-on-tpus, retrieved 14 November 2026.
Super-slicing stitches TPU cubes through optical switches
The first mode builds slices larger than a cube. Google connects TPU cubes through TPU optical circuit switching, and the switch reconfigures the optical network at the moment the workload is scheduled, so the topology in the Kubernetes manifest determines how many cubes get stitched together. The post's worked example is a 4x4x16 super slice of 64 Ironwood VMs and 256 chips, formed from four Ironwood cubes that were provisioned as ordinary GKE nodepools.
That detail matters for planning. A team reserving a large slice reserves a set of cubes, and the slice exists for the duration of the job. Google states the same capability carries from single slices of 8,000 chips down to single-host four-chip configurations, which is a range wide enough to cover training and small inference work inside one fleet.
Google's super-slicing diagram from the 9 November 2026 post, reproduced as the first frame of the animation the page publishes: four cubes joined into one slice at scheduling time. Image from https://cloud.google.com/blog/products/containers-kubernetes/gke-dynamic-slicing-on-tpus, retrieved 14 November 2026.
Sub-slicing carves one cube into independent jobs
The second mode goes the other direction. Sub-slicing takes one pre-provisioned 16-VM cube and partitions it into smaller independent slices, reading the topology requirement from the incoming manifest, finding healthy partitions, activating the high-speed inter-chip interconnect to form the sub-slices, and deploying the workload onto them. When the job finishes, the scheduler deforms the slice and returns the partitions to the pool.
Google's example moves from a 2x2x4 slice of 16 chips down to 2x2x2 shapes inside one cube. The practical consequence is packing: several inference services with different topology needs run concurrently in the same physical cube, and a cube with a faulty section can still host work on its healthy partitions. For a platform team whose inference estate is a set of small models, this is the mode that changes utilisation.
Google's sub-slicing diagram from the same post, reproduced as the first frame of its animation: one cube split into several slices that run independently. Image from https://cloud.google.com/blog/products/containers-kubernetes/gke-dynamic-slicing-on-tpus, retrieved 14 November 2026.
Incremental provisioning keeps partially healthy capacity
Both modes depend on a prerequisite that the post states plainly: capacity has to be pre-provisioned into nodepools of 16 VMs first. The interesting engineering sits in how that provisioning behaves on hardware that is not perfect. Google introduces an incremental provisioning nodepool, which provisions using every healthy host it can find even when some hosts inside a 4x4x4 slice are faulty, then reconciles state continuously and adds pending nodes as faulty hosts recover.
This incremental model keeps healthy hosts available during recovery. Consider a hypothetical large reservation with a handful of faulty hosts: GKE would provision the available healthy hosts, then add pending nodes as the faulty hosts recover. Incremental provisioning is also the prerequisite for sub-slicing, because the inter-chip interconnect mesh needs to be configured over whatever healthy set exists.
Netics visual, 14 November 2026: the two published multiples and the baseline they are measured against.
The measurements behind the 5x startup figure
The post uses the delete-and-recreate cycle for a static nodepool as the baseline for both dynamic-slicing multiples, and that baseline is the right one to keep in view. The 5x describes time-to-slice, which is the wait a job experiences while a new nodepool is deployed. The 4.5x describes recovery, and Google ties it to isolating a large slice failure to a single cube and swapping the unhealthy cube in one to two minutes.
Both numbers describe performance after TPU capacity has been reserved and pre-provisioned. Google supports dynamic slicing exclusively for capacity reserved through TPU All Capacity, so the published gains apply within that setup. The claim worth testing in a proof of concept is the one a scheduler can measure: how long a job waits between submission and first step, across the topology shapes the team actually runs.
Netics visual, 14 November 2026: the cube as the unit of provisioning, which is why the failure domain and the slice stopped being the same object.
What a platform team checks before switching
The workload interface is small. After enabling the slice controller and configuring a scheduler that understands dynamic slices, a team annotates the workload, the scheduler creates a Slice custom resource, and the job is placed once the slice is formed. Google lets a team use its deployable schedulers or bring a custom one, which suits estates that already schedule around their own health signals.
Four checks belong before the switch. Confirm the reservation is under TPU All Capacity, because dynamic slicing is offered there. Convert capacity into 16-VM cubes, since sub-slicing and super-slicing both start from that baseline. Watch the health and usage metrics Google exposes per cube partition, because scheduling decisions and repair both depend on them. Then decide who owns the slice lifecycle in the platform code: monitoring has to track every slice created and deformed for a job as a runtime artifact.
Netics visual, 14 November 2026: the order a team works through, from capacity reservation to a workload annotation.
For teams running accelerator capacity, failure domains and utilisation should guide infrastructure architecture decisions. A slice that exists for the length of a job changes who owns the blast radius.
Dynamic slicing is a scheduler feature that turns reserved TPU capacity into something closer to a pool. Dynamic slicing removes the delete-and-create cycle and isolates hardware failures to one cube.
Originally published on the Netics blog.









