GKE Dynamic Slicing Assembles TPU Slices When a Workload Asks for One
"GKE dynamic slicing builds TPU slices at scheduling time from pre-provisioned 16-VM cubes, and Google reports job startup up to 5x faster with recovery 4.5x faster than building a static no
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.

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.

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.

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.

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.

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.

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.

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.
Sources
Source: the Google Cloud Blog post of 9 November 2026 by Kavitha Gowda and Wenzhe Li, retrieved 14 November 2026. That page carries the 5x startup and 4.5x recovery figures, the cube and super-slice topologies, the sub-slicing and deformation behaviour, the incremental provisioning rule, the Slice custom resource, the TPU All Capacity reservation requirement and the one-to-two-minute cube swap quoted above.