GKE Workspaces Explained: Google’s Self-Hosted AI/ML Development Platform for Kubernetes (2026)

GKE Workspaces Explained: Google’s Self-Hosted AI/ML Development Platform for Kubernetes (2026)

If you train or fine-tune AI models for a living, the most powerful chips you need almost certainly live on Kubernetes. The problem is that Kubernetes was never designed to be a friendly place to write code. Researchers end up wrestling with YAML files, kubectl commands and GPU scheduling just to open a notebook — work that has nothing to do with the model they are trying to build. GKE Workspaces is Google’s answer to that friction: a self-hosted AI and machine learning development platform for Google Kubernetes Engine (GKE), announced on 4 November 2026, that turns your team’s cluster into a simple web dashboard where a researcher picks an IDE and a machine, then starts coding on cloud GPUs or TPUs within minutes.

Built on the open-source Kubeflow Workspaces project and released under the Apache 2.0 licence, GKE Workspaces is aimed squarely at platform teams and the ML engineers they support. Your platform team deploys it once on your own GKE cluster; after that, researchers never touch the cluster directly. They get persistent personal environments, a pause button that freezes a GPU-loaded notebook without losing its state, and a smooth path from a single TPU chip to a multi-host training slice — all inside the same notebook. This guide explains what GKE Workspaces is, how it works, what it costs, how it compares with Vertex AI Workbench and plain Kubeflow, and who should actually deploy it.

GKE Workspaces running AI workloads in a Google Cloud data centre server room

Table of Contents

What Is GKE Workspaces?

GKE Workspaces is a self-hosted development platform for AI and machine learning teams that run on Google Kubernetes Engine. Instead of giving every researcher direct access to a Kubernetes cluster — with all the YAML, command-line tooling and accelerator scheduling that implies — GKE Workspaces puts a clean web dashboard in front of the cluster. A researcher signs in with their Google account, chooses an IDE, chooses a machine size, and gets a personal, persistent development environment running on cloud accelerators.

Google introduced GKE Workspaces on 4 November 2026 in a post on the Google Open Source Blog, positioning it as the notebook layer for teams whose models already live on GKE. The timing matters. GKE now powers AI workloads for all of Google’s top 50 customers on the platform, and multi-agent AI workflows on the service have surged by 327 percent in just a few months. The infrastructure is there; what was missing was a humane way for humans to develop on it. GKE Workspaces is that layer.

The platform is built directly on Kubeflow Workspaces, the open-source project that gives every researcher a personal, persistent environment on shared cluster hardware. Google’s version adds the pieces that only make sense on Google Cloud: standalone deployment without the Istio service mesh, integrated authentication token flows, and stateful pause and resume for GPU and CPU workspaces. Both projects are released under the Apache 2.0 licence, which means there is no licence fee for the software itself — you pay for the Google Cloud resources underneath it.

It is important to be clear about what GKE Workspaces is not. It is not a managed notebook service like Vertex AI Workbench, and it is not a consumer tool. There is no “sign up and start coding” button for an individual. A platform team deploys GKE Workspaces on the organisation’s own GKE cluster, curates the images and hardware options, and decides which machines, reservations and capacity types back them. Researchers then see only the choices that work. That division of labour — platform team owns the infrastructure, researchers own the models — is the whole point of the product.

GKE Workspaces at a Glance

Feature Details
Announced 4 November 2026, Google Open Source Blog
Built on Kubeflow Workspaces (open source)
Licence Apache 2.0 for both GKE Workspaces and upstream Kubeflow Workspaces
Runs on GKE Standard or GKE Autopilot — no full Kubeflow installation required
IDEs JupyterLab or in-browser VS Code
Hardware choices Small CPU, GPU, or TPU — curated by the platform team
Storage Per-workspace home directory on a dedicated, encrypted Persistent Disk
Standout feature Stateful pause and resume via GKE Pod Snapshots, including GPU memory
TPU support Single chip, multi-chip, and multi-host TPU slices; JAX and PyTorch
Agent support Local coding agents via revocable links; in-cluster coding subagents in Agent Substrate sandboxes
Authentication Google accounts; traffic encrypted with Google-managed certificates
Cost model Software free (open source); you pay for GKE, compute, storage and snapshots

The Problem GKE Workspaces Solves

Ask any ML engineer what slows them down and the answer is rarely the model. It is the machinery around the model. GPUs and TPUs are scarce, expensive resources that live on shared clusters, and getting access to them has traditionally meant filing tickets, writing Kubernetes manifests, and waiting for a platform engineer to schedule your job. The researcher who just wants to test an idea in a notebook ends up doing infrastructure work instead — or worse, keeps a GPU running overnight because shutting it down means losing an hour of loaded model weights and notebook state.

The second problem is the tool-switching tax. A typical ML workflow starts with a small experiment on one GPU, grows into a bigger training run, and eventually needs distributed infrastructure. In most organisations, each of those steps means a different tool: a local notebook, then a training job submission system, then a separate pipeline for serving. Every switch costs context — code moves, environments change, and something breaks.

The third problem is newer: coding agents. Developers now run AI coding agents locally, but those agents need cloud accelerators to do anything serious, and pointing a local agent at a remote cluster has meant SSH keys, tunnels and cluster credentials sitting on a laptop. That is a security headache no platform team enjoys.

GKE Workspaces attacks all three problems at once. It hides Kubernetes behind a dashboard, keeps the researcher in the same notebook from prototype to distributed training, and gives local agents a secure, revocable bridge to cloud compute. None of this is magic — it is careful product design on top of infrastructure Google already operates at enormous scale. But for teams already running on GKE, the difference between “file a ticket for a GPU” and “click GPU and start coding” is the difference between a platform that serves researchers and one that slows them down.

How GKE Workspaces Works

Using GKE Workspaces as a researcher is deliberately boring. You sign in to your team’s Workspaces web UI with your Google account — no Google Cloud Console access, no YAML, no command line. You choose JupyterLab or in-browser VS Code, pick an environment from the list your platform team has approved, and select a hardware size such as “Small CPU”, “GPU” or “TPU”. Within minutes, you are coding on a cloud accelerator.

Behind that simple flow, several things are happening. Each workspace mounts its own home directory on a dedicated, encrypted Persistent Disk in your Google Cloud project, isolated to that workspace. Your files, notebooks and installed packages stay safe across restarts, pauses and machine changes — the workspace is personal and persistent, not a throwaway container. If you move from a small CPU machine to a GPU, your home directory comes with you.

The guardrails are set by the platform team, and that is a feature, not a limitation. Admins curate the approved images and hardware options and decide which machines, reservations and capacity types — on-demand or Spot — back them. A researcher only ever sees choices that will actually work in their project, with the quota and budget the team has agreed. That removes the most common failure mode of self-service ML platforms: a researcher picking a machine size the project cannot afford, or a GPU type that does not exist in their region, and losing an afternoon to an error message.

Deployment is intentionally lightweight. GKE Workspaces runs on its own on GKE Standard or Autopilot — you do not need to install the full Kubeflow platform to use it. That matters because a full Kubeflow installation is a serious commitment: multiple components, an Istio service mesh, and ongoing maintenance. GKE Workspaces deliberately skips the Istio dependency, which is one of its key enhancements over the upstream project. Users sign in with Google accounts, traffic is encrypted with Google-managed certificates, and each team’s work is isolated from the others.

GKE Workspaces developer coding on a laptop with an external monitor in a dark office

JupyterLab or VS Code in the Browser

The choice of IDE is a small detail that says a lot about who GKE Workspaces is for. JupyterLab is the default home of exploratory ML work — notebooks, quick experiments, data visualisation. In-browser VS Code is where the same researcher goes when the experiment becomes a codebase: proper editing, extensions, debugging and source control. Offering both, in the same workspace, on the same persistent disk, means the researcher does not have to choose between them or keep two environments in sync. And because the environment lives on the cluster, the code runs where the data and the accelerators are — there is no “works on my laptop, fails on the cluster” gap.

Pause and Resume: Keep Your GPU State, Stop Paying

The headline feature of GKE Workspaces is also its most practical one: stateful pause and resume. Google’s announcement describes the scenario every ML engineer recognises. You have spent an hour loading a large model into GPU memory and building up results across notebook cells. It is time to go home. Normally you have two bad options: shut down and lose everything, or leave the GPU running and pay for an idle accelerator overnight.

With GKE Workspaces, you just pause. Click a button in the Workspaces dashboard and GKE takes a snapshot of your running notebook — including variables in memory and models loaded on the GPU — saves it to Cloud Storage, and releases the hardware so you stop paying. When you resume, you pick up exactly where you left off. The mechanism underneath is GKE Pod Snapshots, and workspaces can also be paused automatically after a period of inactivity, so a forgotten notebook does not quietly burn a GPU budget over a weekend.

This is a bigger deal than it sounds. A single high-end GPU can cost several dollars per hour, and an idle GPU left running overnight, every night, across a team of twenty researchers, is one of the easiest ways to waste a cloud budget. The traditional fix — auto-shutdown timers — saves money but destroys state, so researchers disable them or work around them. Pause and resume removes the trade-off entirely: the money-saving option and the convenient option are the same option. For a platform team, that is also a governance win. Instead of policing idle GPUs, the platform makes the cheap behaviour the default behaviour.

There are limits worth noting. A snapshot captures the running notebook’s state, but it is still a snapshot — restoring it takes time, and the snapshot itself lives in Cloud Storage, which has its own (small) storage cost. Google has not published exact restore times or snapshot size limits in the announcement, so teams should test the pause-and-resume cycle with their own largest models before promising researchers it is instant. The honest framing is that pause and resume turns an overnight GPU bill into a storage bill, which is a very good trade — not that it makes compute free.

The TPU On-Ramp: From One Chip to Multi-Host Slices

If pause and resume is the cost-saving feature, the TPU on-ramp is the scaling feature. Moving from a quick experiment to large-scale training on TPUs used to mean switching tools at every step. GKE Workspaces keeps you in the same notebook the whole way, with both JAX and PyTorch supported. Google describes the progression in three steps:

  1. Prototype on a single TPU chip, just like you would on a GPU. The notebook behaves the same way; the accelerator underneath changes.
  2. Scale to multiple chips on one machine by choosing a bigger hardware option in the same dashboard.
  3. Scale out to multi-host TPU slices by sending the same training function from your notebook to a larger slice. Logs stream back to your notebook, and the TPUs are released as soon as the job finishes.

That third step is the one that matters most. Multi-host TPU training has historically been the preserve of teams with dedicated infrastructure engineers, because it involves provisioning a slice, coordinating hosts, and cleaning up afterwards. GKE Workspaces folds it into the notebook workflow: the researcher writes a training function, sends it to a slice, watches the logs, and the hardware is released when the job ends. The notebook stays small and cheap; the heavy lifting happens on hardware that exists only for the duration of the job.

The same logic applies to GPUs, though Google’s announcement leads with TPUs for an obvious reason — TPUs are Google’s own chips, and the smooth path from notebook to TPU slice is a capability no other cloud can offer in quite the same form. For teams training on NVIDIA GPUs, the workspace model still applies, but the distinctive advantage of GKE Workspaces is the TPU path. If your team trains exclusively on GPUs and never touches a TPU, some of the platform’s headline value does not apply to you — a point the pricing section below makes concrete.

One more detail from the announcement is worth flagging for PyTorch users. Google and Meta open-sourced TorchTPU, a native PyTorch backend for Cloud TPUs, on 20 October 2026 — just two weeks before GKE Workspaces launched. The two launches fit together: TorchTPU gives PyTorch code a first-class path to TPUs, and GKE Workspaces gives PyTorch developers a notebook that runs on them. If your team is PyTorch-first, that combination is the practical route onto TPU hardware without rewriting your training code in JAX.

Local Coding Agents Meet Cloud Accelerators

The most forward-looking part of GKE Workspaces is how it handles AI coding agents. Many developers now prefer to use their own coding agents and editors locally — on their own laptop, with their own setup. The problem is that a local agent cannot do serious ML work without cloud accelerators, and connecting the two has traditionally meant SSH keys, local tunnels, or cluster credentials sitting on a laptop.

GKE Workspaces solves this with a short-lived, revocable link generated from the Workspaces web UI. The link lets you run your notebooks and agent-generated code on a remote GPU or TPU. Traffic is secured over HTTPS via Google Identity-Aware Proxy and the cluster’s access proxy, with permissions checked on every request — so no SSH keys, local tunnels, or cluster credentials ever sit on your laptop. If a link leaks or a laptop is lost, the platform team revokes it; nothing permanent was ever handed out.

This design is quietly important. Coding agents are powerful, and they execute code — which means the code they run can do anything the agent’s credentials allow. Giving an agent your cluster credentials is a genuine security risk. A short-lived, revocable, permission-checked link is the right granularity: the agent gets exactly the access it needs, for exactly as long as it needs it, and the platform team can take it away. As coding agents become a normal part of ML development, this kind of plumbing will matter as much as the models themselves.

GKE Workspaces engineer running AI code on a monitor with cloud GPU access

A Launchpad for Distributed Work

Your workspace does not have to be big to drive big jobs. That is the idea behind GKE Workspaces as a launchpad: from a small, inexpensive CPU notebook you can process data with Spark, launch multi-host training, serve your model, and scale Ray clusters — all from Python. Built-in Cloud Storage access, with no keys to manage, makes it easy to pass data between each step.

This is the part of GKE Workspaces that will appeal most to teams doing real ML operations rather than one-off experiments. A typical workflow might look like this: clean and prepare a dataset with Spark from a cheap CPU notebook; kick off a multi-host training run on a TPU slice; serve the resulting model from the same notebook; and scale out a Ray cluster for batch inference — without ever leaving the notebook, and without managing credentials for any of it. The notebook is the control plane; the cluster is the muscle.

The built-in Cloud Storage access deserves emphasis. In a traditional setup, every step of that workflow needs credentials to reach the data — service account keys, mounted secrets, or environment variables that someone has to rotate. GKE Workspaces handles storage access through the platform, with no keys for the researcher to manage. That is both a convenience and a security improvement: there are no long-lived keys to leak, and the platform team controls exactly what each workspace can reach.

Coding Subagents in Safe Sandboxes

GKE Workspaces also addresses the newest pattern in AI-assisted development: fleets of coding subagents. Running a fleet of coding agents directly on your local machine can drain your battery, expose sensitive files or credentials to agent-executed code, and halt progress as soon as you close your laptop. Google’s answer is to run the subagents in the cluster instead.

From a standard GKE Workspace, you can task your favourite coding agent to hand off parallel work — such as resolving failing tests across a repository — to background subagents. While your primary workspace operates as a full-featured environment, these subagents are isolated within lightweight, in-cluster sandboxes using providers like Agent Substrate, requiring zero local setup. Each subagent executes independently in its own sandbox on shared cluster nodes, continues running even when you log off, snapshots to Cloud Storage at zero compute cost while idle, and outputs a clean patch for your review and merge.

Agent Substrate is itself a new Google project: Google Cloud announced it alongside GKE Workspaces in the same week, and is donating it — along with gVisor — to the Cloud Native Computing Foundation in Sandbox status at KubeCon North America 2026 in Salt Lake City. The idea is a secure, low-latency sandbox substrate for stateful agents, built from the best parts of Kubernetes. For GKE Workspaces, it means subagents get isolation by default: agent-executed code runs in a sandbox, not in your workspace, and not on your laptop.

The workflow this enables is worth picturing. You finish your day by asking your coding agent to fix the failing tests across a repository. The agent splits the work among subagents, each running in its own sandbox on shared cluster nodes. You close your laptop and go home. The subagents keep working, snapshot to storage when idle at zero compute cost, and by morning each one has produced a clean patch for your review. Nothing ran on your machine, nothing touched your files, and nothing kept a GPU billing while it waited. That is a genuinely different way of working — and it is the clearest sign of where Google thinks ML development is heading.

GKE Workspaces vs Kubeflow Workspaces

Because GKE Workspaces is built on Kubeflow Workspaces, the obvious question is what you actually get from Google’s version. The honest answer is: the same open-source core, plus GKE-specific engineering that would be hard to replicate yourself. Here is the breakdown.

Capability Kubeflow Workspaces (upstream) GKE Workspaces (Google’s build)
Personal, persistent dev environments Yes Yes
JupyterLab and in-browser VS Code Yes Yes
Encrypted Persistent Disk home directories Depends on your setup Built in
Standalone deployment (no Istio) No — Istio required Yes
Integrated authentication token flows No Yes
Stateful GPU/CPU pause and resume No Yes, via GKE Pod Snapshots
Cloud TPU on-ramp (single chip to multi-host slices) No Yes
Local agent bridge (revocable HTTPS links) No Yes, via Identity-Aware Proxy
Coding subagent sandboxes (Agent Substrate) No Yes
Licence Apache 2.0 Apache 2.0
Runs on Any Kubernetes GKE Standard or Autopilot only

The trade is clear. If you run Kubernetes anywhere other than Google Cloud, Kubeflow Workspaces is your option — it is portable by design. If you run on GKE, Google’s build removes the Istio dependency, adds the pause-and-resume and TPU features, and wires in Google authentication and storage. Google says it is actively working with the Kubeflow community to upstream its enhancements, so the gap may narrow over time — but for now, the GKE version is the more capable one on Google’s own platform.

GKE Workspaces vs Vertex AI Workbench

The other natural comparison is with Google’s existing managed notebook service, Vertex AI Workbench. The two products solve the same problem — giving researchers a notebook with accelerators — from opposite directions. Workbench is fully managed: Google runs the notebook infrastructure, you pick an instance, and you pay for the compute plus a management fee. GKE Workspaces is self-hosted: you run it on your own cluster, you manage it, and you pay only for the underlying cloud resources.

Factor Vertex AI Workbench GKE Workspaces
Hosting model Fully managed by Google Self-hosted on your own GKE cluster
Setup effort Minutes, per notebook Platform team deploys once, then self-service
Software cost Compute plus management fees Free (Apache 2.0); pay for GKE, compute and storage
Spot capacity Not supported for managed notebooks Supported — platform team chooses on-demand or Spot
TPU access Available in some configurations Native on-ramp to multi-host TPU slices
Stateful pause/resume Stop/start, but state handling is manual Built in, including GPU memory, via Pod Snapshots
Multi-user governance Per-instance controls Central curation of images, hardware and capacity
Best for Individuals and small teams who want zero setup Teams already on GKE who want control and scale

Which one should you choose? If you are a solo researcher or a small team that wants a notebook today with no platform work, Vertex AI Workbench is still the simpler answer. If you already run GKE, have a platform team, care about Spot pricing and GPU cost control, and want TPU scaling and agent sandboxes in the same place, GKE Workspaces is the stronger choice. The two products will coexist — Google has not suggested Workbench is going away — and some organisations will sensibly use both: Workbench for quick individual work, GKE Workspaces for the team’s shared ML platform.

For readers weighing alternatives beyond Google Cloud, the same logic applies to the wider market. AWS SageMaker Studio and Azure Machine Learning both offer managed notebook environments with their own strengths, and a self-managed JupyterHub on any cloud is still the cheapest option in raw dollars — but it is also the most work to run well. GKE Workspaces sits in the middle of that spectrum: open source and self-hosted like JupyterHub, but with the polish, TPU access and agent features that only Google’s own platform team could build. That middle ground is exactly where most serious ML teams live.

Pricing: What GKE Workspaces Actually Costs

The pricing story for GKE Workspaces has two parts, and it is important not to confuse them. The software itself is free: both GKE Workspaces and upstream Kubeflow Workspaces are released under the Apache 2.0 licence, so there is no licence fee, no per-seat charge and no subscription for the platform. What you pay for is the Google Cloud infrastructure underneath — and that is where the real numbers live.

The fixed cost is the cluster. GKE charges a $0.10 per hour management fee per cluster in both Standard and Autopilot modes, billed per second until the cluster is deleted — roughly $74 a month for a cluster that runs continuously. In Autopilot mode, you then pay per pod for the CPU, RAM and ephemeral storage your scheduled pods request, at approximately $0.0445 per vCPU-hour and $0.0049 per GiB-hour. In Standard mode, you pay Compute Engine prices for each node in the cluster. Either way, the cluster fee is the smallest line on the bill; the accelerators dominate it.

Accelerator pricing is where teams should do their sums before deploying. Google publishes Cloud TPU prices per chip-hour, and the current on-demand rates in US regions are:

Cloud TPU On-demand (per chip-hour) 1-year commitment 3-year commitment
TPU v5e $1.20 $0.84 $0.54
TPU v6e (Trillium) $2.70 $1.89 $1.22
TPU v5p $4.20 $2.94 $1.89
Ironwood (TPU v7x) $12.00 $8.40 $5.40

A few worked examples make this concrete. A researcher prototyping on a single TPU v5e chip for a four-hour afternoon pays about $4.80 on demand. The same session on a v6e Trillium chip costs about $10.80. An eight-chip v5e slice running a training job for ten hours costs about $96 on demand — or about $48 with the Dynamic Workload Scheduler flex-start rate of $0.60 per chip-hour. And an Ironwood chip, Google’s flagship, is $12.00 per chip-hour — a reminder that the top of the range is priced for frontier training, not casual experiments. These are list prices from Google’s official Cloud TPU pricing page; regional prices vary slightly, and committed-use discounts cut one-year prices by 30 percent and three-year prices by 55 percent.

GPU pricing follows the same logic but varies by model — an NVIDIA L4 costs far less per hour than an H100 — and Google does not publish a single table for it in the GKE Workspaces announcement. The practical advice is the same either way: check the current Compute Engine GPU price for your region before promising researchers a hardware option, and use the platform team’s curation powers to offer only the machines the budget supports.

Then there are the two cost levers GKE Workspaces is designed around. The first is Spot capacity: the platform team can back workspaces with Spot VMs, which Google prices at a 60 to 91 percent discount versus on-demand, in exchange for the possibility of interruption. For fault-tolerant work — and a pausable notebook is fault-tolerant by design — Spot is the cheapest way to run. The second is pause and resume itself: every hour a paused workspace is not billing for a GPU is money saved, and the auto-pause timer turns that saving into a default rather than a discipline.

The remaining costs are small but real: each workspace’s encrypted Persistent Disk is billed as storage, Pod Snapshots live in Cloud Storage, and network egress applies if data leaves Google Cloud. None of these will dominate a bill that includes GPUs, but a platform team should track them — a hundred researchers each holding a large persistent disk adds up, and snapshot storage grows with every pause. Set a retention policy for snapshots early.

Put it together and the honest summary is this: GKE Workspaces itself costs nothing, a cluster costs about $74 a month to keep alive, and everything else scales with the accelerators your researchers actually use. For a team already paying for GKE and GPUs, the platform adds almost no cost — it adds control over the cost they already have.

How to Deploy GKE Workspaces

Deployment is a platform-team job, and Google’s message to researchers is explicit: ask your platform team to deploy it using the GKE deployment guide. That division is deliberate. A researcher should never have to deploy GKE Workspaces themselves, and the deployment guide on GitHub walks the platform team through the steps: provisioning or selecting a GKE cluster in Standard or Autopilot mode, installing GKE Workspaces, configuring authentication, and curating the images and hardware options researchers will see.

A few decisions the platform team will need to make up front:

  • Standard or Autopilot? Autopilot removes node management and bills per pod, which suits teams that want the least operational work. Standard gives full control over node pools, machine types and GPU drivers, which suits teams with specific hardware needs or existing reservations.
  • Which images? Curate a short list of notebook images — a general data-science image, a PyTorch image, a JAX image — rather than letting researchers bring anything. Fewer images means fewer surprises.
  • Which hardware? Decide which machine sizes appear in the dashboard, which capacity types back them (on-demand for interactive work, Spot for batch-style experiments), and what quotas apply per researcher or per team.
  • How long before auto-pause? Set the inactivity timer aggressively at first — an hour is a reasonable starting point — and loosen it only if researchers complain. The default should save money.
  • Who can create workspaces, and where? Use Google account authentication and per-team isolation so that each team’s work stays separate, and make sure the platform team can see usage and cost per team.

One thing to verify before committing is accelerator availability in your region. TPUs and high-end GPUs are quota-limited and region-specific — not every region offers every chip, and quota must be requested and approved. A deployment plan that assumes Ironwood availability in a region that does not offer it will fail late and expensively. Check quota and regional availability first, choose hardware options second, and announce the platform to researchers third.

Who Should Use GKE Workspaces — and Who Should Not

GKE Workspaces is built for a specific audience, and it is honest to say who that is — and who should look elsewhere.

It is a strong fit for:

  • ML platform teams already running GKE who need a self-service notebook layer for their researchers, with cost controls and governance built in.
  • Research teams training on TPUs, especially teams that prototype on one chip and scale to multi-host slices — the TPU on-ramp is the platform’s most distinctive capability.
  • Organisations with GPU cost problems, where idle accelerators and forgotten notebooks are inflating the cloud bill. Pause and resume plus auto-pause directly attack that waste.
  • Teams adopting AI coding agents that need a secure bridge between local agents and cloud accelerators, or that want to run coding subagents in isolated sandboxes.
  • Open-source-first teams that want an Apache 2.0 platform they can inspect, extend and eventually contribute to — and that like the idea of Google upstreaming its enhancements to Kubeflow.

GKE Workspaces team of ML engineers collaborating around a laptop

It is probably not the right choice for:

  • Solo developers and tiny teams who just want a notebook with a GPU today. A managed service like Vertex AI Workbench — or even a cloud notebook with hourly billing — is far less work.
  • Teams not on Google Cloud. GKE Workspaces runs on GKE. If your infrastructure is on AWS or Azure, the upstream Kubeflow Workspaces project is the portable alternative.
  • Teams without a platform function. Somebody has to deploy and operate the platform, curate images, manage quotas and watch costs. If nobody owns that job, a managed service is the better call.
  • GPU-only teams with no TPU ambitions, who will get the dashboard and the pause-and-resume benefits but not the TPU on-ramp that justifies much of the platform’s distinctiveness.

There is also a natural connection to the open-weight models this site covers. Teams developing on GKE Workspaces are often the same teams running open models — and the kind of models they run matter. Recent open-weights releases like Inkling 2 Small, Kimi K3.1 Pro and Tencent Hy4 are exactly the workloads a GKE Workspace is built to develop: large models that need real accelerators, persistent environments and careful cost control. If you are evaluating GKE Workspaces, having one of those models as a test workload is a sensible way to prove the platform out.

Limitations You Should Know About

No launch announcement is a complete picture, and GKE Workspaces has real limitations that a fair guide should name.

It is brand new. Announced on 4 November 2026, GKE Workspaces has days of public history, not years. Early adopters should expect rough edges, evolving documentation and a community that is still forming. The Kubeflow Workspaces upstream project is more established, but the GKE-specific enhancements — Pod Snapshots, the TPU on-ramp, the agent bridge — are new. Treat the first deployment as a pilot, not a migration.

It needs a platform team. This is a feature for the organisations it targets and a barrier for everyone else. There is no hosted version, no free tier for individuals, and no way to try it without a GKE cluster. A team without Kubernetes expertise cannot simply adopt it.

Accelerator availability is not guaranteed. TPUs and GPUs are quota-limited, and the most powerful chips are scarce. A workspace that offers a TPU option the project has no quota for is a broken promise. Quota, reservations and regional availability are the platform team’s problem — and they are real work.

Pause and resume is not magic. Snapshotting a GPU-loaded notebook takes time and storage, and Google has not published restore times or limits. Teams should test with their largest models before relying on it, and should set snapshot retention policies so storage costs do not creep up silently.

The ecosystem is Google-shaped. Identity-Aware Proxy, Cloud Storage, Pod Snapshots, Agent Substrate — the platform’s best features are Google Cloud features. That is fine if you are committed to Google Cloud, and it is a form of lock-in if you are not. The Apache 2.0 licence covers the software, not the cloud services it leans on.

GKE Workspaces developer typing on a laptop keyboard while working on cloud AI infrastructure

What Happens Next for GKE Workspaces

The launch timing points at KubeCon North America 2026, which runs from 9 to 12 November in Salt Lake City. Google’s Kubernetes team is running a GKE Day on 9 November with announcements and hands-on agent-infrastructure labs, and a workshop on building and governing Agent Substrate on GKE later in the week. Expect the first real-world deployment stories, and possibly the first community feedback on the rough edges, to emerge from that event.

Two things are worth watching after launch. The first is upstreaming: Google says it is actively working with the Kubeflow community to move its enhancements — standalone deployment without Istio, integrated auth token flows, stateful pause and resume — into the upstream project. If that happens, Kubeflow Workspaces users on any cloud benefit, and the distinction between the two projects narrows. The second is pricing and packaging: GKE Workspaces is open source today, but Google’s history with GKE features suggests managed conveniences may follow. For now, the model is simple — free software, paid infrastructure — and teams should take advantage of it while it is that simple.

There is also a broader context worth noting. Google announced GKE Workspaces in the same period as a wave of other developer-facing launches — including Google Playground, its text-prompt game maker — and the pattern is consistent: Google is shipping the tooling that makes its AI infrastructure usable by humans and agents alike. GKE Workspaces is the infrastructure end of that pattern, and it is the end that working ML teams will feel first.

Frequently Asked Questions

Is GKE Workspaces free?

The software is free — both GKE Workspaces and upstream Kubeflow Workspaces are Apache 2.0 open source, so there is no licence fee. You pay for the Google Cloud resources it uses: the GKE cluster management fee ($0.10 per hour per cluster), the compute (CPU, GPU and TPU time), Persistent Disk storage, and Cloud Storage for Pod Snapshots.

What is the difference between GKE Workspaces and Kubeflow Workspaces?

Kubeflow Workspaces is the open-source upstream project that provides personal, persistent ML development environments on any Kubernetes cluster. GKE Workspaces is Google’s build of it for Google Kubernetes Engine, adding standalone deployment without Istio, integrated authentication token flows, stateful GPU and CPU pause and resume via Pod Snapshots, a Cloud TPU on-ramp, and coding-agent sandboxes via Agent Substrate. Google is working to upstream these enhancements.

Which IDEs does GKE Workspaces support?

JupyterLab and in-browser VS Code, chosen from the Workspaces web dashboard when you create an environment.

Can I use GKE Workspaces without Kubernetes knowledge?

As a researcher, yes — that is the point. You pick an IDE and a machine in a web UI and start coding; you never touch YAML or the command line. As the platform team deploying it, no — deployment and operation require GKE and Kubernetes expertise.

How does pause and resume work?

Clicking pause takes a snapshot of your running notebook — including variables in memory and models loaded on the GPU — using GKE Pod Snapshots, saves it to Cloud Storage, and releases the hardware so you stop paying. Resuming restores the snapshot and you continue where you left off. Workspaces can also pause automatically after inactivity.

Does GKE Workspaces support TPUs?

Yes. You can prototype on a single TPU chip, scale to multiple chips on one machine, and scale out to multi-host TPU slices from the same notebook, with JAX and PyTorch both supported. TPU v5e costs $1.20 per chip-hour on demand in US regions; v6e Trillium is $2.70 and Ironwood is $12.00.

How is GKE Workspaces different from Vertex AI Workbench?

Vertex AI Workbench is Google’s fully managed notebook service — Google runs it, you pay compute plus a management fee. GKE Workspaces is self-hosted on your own GKE cluster — you run it, the software is free, and you pay only for the underlying cloud resources. Workbench is simpler for individuals; GKE Workspaces gives teams more control, Spot pricing, TPU scaling and agent sandboxes.

Can local AI coding agents use GKE Workspaces?

Yes. From the Workspaces web UI you generate a short-lived, revocable link that lets local coding agents and editors run notebooks and agent-generated code on a remote GPU or TPU, secured over HTTPS via Identity-Aware Proxy with permissions checked on every request — no SSH keys or cluster credentials on your laptop.

The Verdict

GKE Workspaces is not the flashiest launch of November 2026, and it is not trying to be. It is plumbing — the unglamorous, essential layer between ML researchers and the accelerators they need. But it is plumbing that solves three problems every serious ML team has: getting researchers onto GPUs and TPUs without Kubernetes busywork, stopping idle accelerators from eating the budget, and giving AI coding agents a safe, revocable path to cloud compute.

The strongest reason to take it seriously is the combination of features no single alternative offers: an open-source platform you can inspect and extend, stateful pause and resume that turns an overnight GPU bill into a storage bill, a genuine on-ramp from one TPU chip to a multi-host slice, and agent sandboxes built for the way developers actually work now. The strongest reason to wait is its age — three days old at the time of writing, with real-world rough edges still to be discovered at KubeCon and in early deployments.

For teams already running on GKE, the advice is simple: pilot it with one team, one model and one workload, and measure the GPU bill before and after. If pause and resume and Spot capacity deliver the savings they promise, the platform pays for itself in the most literal sense — the software is free, and the infrastructure it saves you from wasting is not. For everyone else, the upstream Kubeflow Workspaces project is the portable version of the same idea, and it is worth watching as Google’s enhancements flow into it. Either way, the notebook is finally catching up with the infrastructure underneath it — and that is good news for everyone who trains models for a living.

Sources: the official announcement, “GKE Workspaces: Your notebook, on Google’s AI infrastructure” (Google Open Source Blog, 4 November 2026), and Google’s official Cloud TPU pricing page. TPU and GKE prices are list prices in USD and vary by region; check the official pricing pages before budgeting.

Leave a Comment

Your email address will not be published. Required fields are marked *