Spheron shipped a feature on 5 September 2026 to let you stop a GPU instance without losing data. Before v1.27.0, hitting Stop on a Spheron instance meant destroying it, disk included. Now Stop keeps the machine instead: the GPU stops billing, the disk stays exactly where it was, and Start brings it back when you want it.
TL;DR: Stop, Start, and Terminate on Spheron, in One Table
Spheron's Stop control now keeps a GPU instance instead of destroying it: the GPU-hour billing stops, and the disk and IP stay put, as of the 5 Sep 2026 release.
| Action | Billing | Disk & IP | Reversible |
|---|---|---|---|
| Running | Full rate | Live | n/a |
| Stop | Disk + IP only | Retained | Yes |
| Terminate | None | Deleted | No |
Stop is self-serve on Spheron AI and Spheron ES. See Spheron's H100 pricing for a live rate to run the savings math against.
What Changed: Now You Can Stop GPU Instance Without Losing Data
The mechanics are in the changelog entry itself: stopping an instance used to mean destroying it, and now the GPU stops billing, the disk and everything on it stays exactly where it was, and you start it again when you want it. That's a real behavior change, not a UI relabel. Before v1.27.0, hitting Stop on a Spheron instance meant the same thing as Terminate does today: the disk went with it.
The practical effect is that a GPU instance now has a genuine middle state between running and gone. If you've been terminating dev and test instances every evening and redeploying from a fresh image every morning to avoid paying for idle GPU time, that's the exact workflow this closes. Spheron's overview docs describe it the same way from the feature side: stopping releases the GPU and drops billing to the disk rate while the disk and everything on it stays in place, and starting it again "returns the same environment on the same public IP."
That last detail matters more than it sounds like it should. A restart that hands you a new IP address means updating DNS, SSH config, and anything else pointed at the old address. Stop and Start doesn't do that. Whatever pointed at the instance before Stop still points at it correctly after Start.
GPU Cloud Instance Lifecycle Management: Where Stop and Start Fits
A GPU instance moves through a small number of states, and each one means something different for your bill. Here's the full lifecycle as Spheron implements it:
| State | What's running | What's billed | Data | Typical use |
|---|---|---|---|---|
| Provisioning | Nothing yet | Nothing yet | n/a | Instance is being allocated |
| Running | GPU, disk, network | Full on-demand or spot rate | Live | Active training, inference, or dev work |
| Stopped | Disk only | Disk rate, plus public IP where charged | Retained, unchanged | Overnight pauses, between experiments, seasonal workloads |
| Restarted (rebooted) | Same as before reboot | Unchanged; status stays as it was | Unaffected | Clearing a hung process without losing the running state |
| Terminated | Nothing | Nothing | Deleted | Workload is permanently done |
Restart is a different operation from Stop, worth separating out because the two get confused. Per the changelog: "A restart reboots in place. Your billing does not change and the instance keeps its status." Stop changes your instance's billing state; Restart doesn't change anything except that the machine rebooted.
Detached persistent storage sits outside this lifecycle entirely. Spheron's overview docs note you can "create persistent storage volumes that exist independently from your instances," and "attach a volume to a running instance, detach it without losing data, and reattach it to a different instance later." That's a second way to keep data alive across instance changes, useful when you want to move a dataset to a different GPU type rather than pause the same instance. Our cloud GPU data persistence guide covers which storage tier survives which kind of restart.
The Billing Math: What You Pay Stopped vs Running
A stopped instance is cheaper than a running one, but it isn't free, and Spheron shows you the exact trade before you confirm. The stop dialog, per the changelog, "quotes both rates before you commit. It shows what the instance costs running, what it will cost stopped, the saving as a percentage, a monthly figure for leaving it that way, and an itemised list of what is still being charged."
Worked example: Spheron's on-demand H100 runs $3.77/hr as of 19 Nov 2026. Stopping that instance drops the GPU-hour charge to zero and leaves you paying only for the retained disk and, where the provider charges for it, the dedicated public IP. Spheron's own persistent-volume storage rate was roughly $0.00016/GB/hr as of 12 May 2026, which is a separate storage product from the disk bundled into an instance's hourly rate rather than a direct stand-in for it, but it gives you the right order of magnitude: storage for a 2TB disk at that rate works out to well under a dollar an hour even before any volume discount applies. The GPU, not the disk, is almost always the expensive part of the bill, which is exactly why stopping instead of terminating saves real money on a workload you're coming back to.
The one caveat that actually bites people: a stopped instance still costs something, and it still needs a funded account behind it. Stopping an instance protects it from an accidental Terminate click. It does not protect it from an empty balance.
How a Mid-Cycle Stop Actually Gets Settled
Hitting Stop doesn't snap your bill to the new rate down to the second. Spheron settles charges on a five-minute billing cycle, and a Stop that lands partway through one of those windows is billed at whichever rate was already active when that cycle fired, not pro-rated between the running rate and the stopped rate. Per the changelog, "the switch is settled at the rate you were on. Charges run on a five minute cycle, so a stop landing mid-cycle would otherwise bill the whole slice at whichever rate happened to be stored when the cycle fired."
In practice this means a Stop clicked one minute into a five-minute window still closes out that window at the running rate, and the stopped rate only takes effect from the next cycle. It's a small amount of money on any single instance, usually a fraction of a GPU-minute, but it explains a line item that otherwise looks like Stop didn't take effect right away. It did; the billing clock just rounds to the cycle it was already in.
The 20-Minute Minimum Runtime: What Stop Doesn't Change
Stopping changes what you pay once an instance is already stopped. It doesn't touch the clock that starts the moment an instance first goes to Running. Every instance on Spheron carries a 20-minute minimum billed runtime, extended to 60 minutes on a 2x AMD MI300X configuration, and billing only drops to per-minute after that minimum is up. Stop a fresh instance at the four-minute mark because the image booted wrong, and you're still billed for the full 20 minutes at the running rate, then the disk rate from there. That's not a Stop-specific rule and stopping doesn't shorten or waive it. Worth knowing before you build a workflow around spinning instances up and down quickly to test something: the first 20 minutes of any Run cost the same whether you use all of them or not.
Worked Example: Stopping an H100 Dev Box Over a Weekend
Here's the math with real numbers. A developer leaves an H100 dev box running at $3.77/hr on-demand from Friday at 6 PM to Monday at 9 AM, 63 idle hours with nobody connected. Left running the whole weekend, that idle stretch alone costs 63 times the hourly rate. Stopped instead, the GPU-hour charge drops to zero for those 63 hours and the only thing still on the bill is the retained disk, plus a public IP on providers that charge for one, which runs to a small fraction of a dollar an hour for a typical dev-box disk size.
The gap compounds further once you factor in where that H100 is running at all. Spheron's on-demand H100 rate as of 19 Nov 2026 sits well below the $6.98/hr Azure and $7.00/hr AWS charged for the equivalent GPU as of Q1 2026, so the same idle weekend on a hyperscaler burns through a bigger number even before you ask whether that provider's stop control keeps your disk, your public IP, or both.
Pricing fluctuates based on GPU availability. Spheron rates above are live as of 19 Nov 2026; other providers reflect their most recent published rates and may have changed. Check current GPU pricing → for live rates.
Step-by-Step: Stopping and Starting an Instance on Spheron
- Open the instance card or its details panel. Stop and Start are self-serve controls in both places, no ticket needed.
- Select Stop. The confirmation dialog shows the running rate, the stopped rate, the percentage saved, a monthly projection for leaving it stopped, and an itemized list of what's still charged (disk, plus a public IP where the provider bills for one).
- Confirm. The GPU releases immediately and billing drops to the stopped rate. The disk and its contents don't move.
- Start it again whenever you need it. The instance comes back with the same disk, the same contents, and the same public IP, so any saved SSH config or connection string still resolves correctly.
That's the whole flow for an instance type that supports it. Not every instance type does, which is the part worth checking before you build a workflow around it.
Which Providers Support It and Which Don't
Spheron aggregates 5+ providers on its backend, and Stop and Start isn't uniform across all of them.
| Provider on Spheron's marketplace | Stop | Restart | Notes |
|---|---|---|---|
| Spheron AI | Yes, with conditions | Yes | Also depends on machine type and region; roughly half of one upstream provider's catalog can't hibernate, and one region refuses to shut instances down at all |
| Spheron ES | Yes | No | Stopping works here even though restart doesn't: "Spheron AI reboots and Spheron ES does not, so restart is absent on Spheron ES even though stopping works there" |
| Spheron MS | No (bare metal) | VMs only | Bare metal instances support neither restart nor stop; per the changelog, "bare metal instances support neither. An instance you have finished with should be terminated" |
| Verda, Sesterce, Massed Compute | No | No | Not part of the current stop/start rollout |
On Spheron AI specifically, the limiting factor isn't a blanket rule, it's inventory: "On Spheron AI it also depends on the machine type and the region: roughly half of one upstream's catalog cannot hibernate, and one region refuses to shut instances down at all." When a machine type or region can't support it, the deploy summary and instance panel say which of the three reasons applies, since the fix differs depending on whether it's the machine type, the region, or the provider itself.
Outside Spheron's own aggregated set, Hyperstack offers a comparable control called VM hibernation, which saves VM state and pauses billing without a full cold start. It's a genuine advantage for session-based workflows, with the caveat that GPU VRAM contents (loaded model weights) aren't guaranteed to persist across a hibernation cycle on a standard cloud VM the way disk state is. Spheron's Stop keeps the disk; it isn't a VRAM snapshot either, since the GPU itself is released on Stop.
Verda and Sesterce don't appear in that table by omission. Per the changelog, "Verda and Sesterce keep charging in full for a shut down instance, so the control is absent there." That's a provider-side limitation, not a gap in Spheron's rollout: those two backends don't stop the meter when the machine shuts down, so there's no cheaper state for a Stop control to switch an instance into.
Restart Reliability on Spot Instances
Restart on a spot instance used to carry a timing risk that's worth calling out separately from the general lifecycle table above, because spot capacity can be reclaimed at any moment and a reboot that takes too long used to look indistinguishable from a reclaimed instance, the exact ambiguity Spheron's Timeline tab and status badges are built to resolve by naming the actual cause behind a stop. Per the changelog, the fix was to add a guard around the boot itself: "a reboot now arms a guard that covers the boot, and the dashboard leaves RESTARTING as soon as the machine reports back rather than waiting out a fixed window." Before that, the dashboard held a restarting instance in that state for a fixed window regardless of how long the actual reboot took, which meant a fast reboot still looked slow and a genuinely stuck one didn't surface as a problem until the timer ran out.
The practical effect for anyone running spot workloads with Restart in the mix: the status you see now reflects when the machine actually reports back, not a worst-case estimate baked into the dashboard. If you're scripting health checks around a restart, you can trust the RESTARTING-to-ready transition as a real signal instead of padding your own wait time on top of it.
How Other GPU Clouds Handle Stopped Instances
Spheron isn't the only GPU cloud with some version of a stop control, and the fine print varies enough that it's worth checking before you assume "stopped" means the same thing everywhere.
AWS EC2 drops compute billing the moment an instance enters the stopped state, but any attached EBS volume keeps billing at its normal per-GB rate regardless of instance state, so storage isn't a separate line item you remember to check, it's one you're already paying no matter what. The detail that actually trips people up is the public IP: on restart, a stopped EC2 instance gets a new public IPv4 address unless it's tied to a secondary network interface or an Elastic IP, and AWS charges for an Elastic IP address whether it's attached to a running instance or sitting idle, including on an instance you've stopped. Spheron's same-public-IP restart isn't unique in the industry, but on EC2 it isn't the default, and keeping it costs something extra either way.
Runpod takes a different angle on the same problem. Stopping a pod erases its temporary container disk for free, but the persistent volume disk that survives the stop keeps billing, at double the running rate, $0.20/GB/month instead of $0.10/GB/month, as published in October 2026, until the pod is deleted. A 500GB volume that cost $50/month running costs $100/month stopped at that rate. That's the opposite of what most people assume "paused" means, and it's a good reason to read a provider's stopped-rate math line by line instead of taking "cheaper when stopped" on faith.
Azure splits "stopped" into two distinct states, and the distinction decides whether compute billing actually stops. Per Microsoft's own documentation, a VM powered off from inside the guest OS, or via the PowerOff API call, lands in a Stopped state that "is allocated on a host but not running," and that state is still billed. Only Stopped (Deallocated), reached by explicitly deallocating the VM, releases the host and stops compute charges, and even then "disks and networking continue to incur charges" regardless of which stopped state the VM is in. Shut a GPU VM down from inside Windows or Linux without taking the extra deallocate step, and you're still paying full compute for a machine that looks off. Spheron's Stop control doesn't have this two-step trap: there's one action, and it's the one that actually drops the GPU charge.
Google Cloud takes a different route entirely: its VM-suspend feature, which otherwise works a lot like Spheron's Stop by freezing a VM's state to disk and pausing compute billing, explicitly excludes any instance with a GPU or TPU attached. The documentation lists it as a hard limitation: "You can't suspend instances that have GPUs or TPUs attached." A GPU-backed Compute Engine VM only has Stop (which, like Azure, needs the full stop-not-just-shutdown path to actually cut compute billing) and Delete. There's no middle state that both pauses GPU billing and keeps a resumable snapshot the way Stop and Start does on Spheron AI and Spheron ES.
When to Stop vs When to Terminate for Good
Stop when you're coming back to the exact same environment: a dev box you use during business hours, a fine-tuning setup you're iterating on across a few days, or any instance where re-provisioning and reinstalling dependencies costs you more time than the stopped-rate disk charge does. Startups running intermittent dev and test GPU workloads are the clearest case: paying the running rate 24/7 for a GPU that's only in active use during working hours is the kind of idle-GPU cost that adds up fast, the same mistake one team traced back to a starved dataloader rather than a genuine compute shortage once they actually measured utilization instead of assuming it.
Terminate when the workload is actually done, or when the instance type doesn't support Stop at all, like Spheron MS bare metal. There's also a middle case Stop doesn't solve: moving a workload to a different provider or a different GPU entirely, as opposed to pausing it on the same one. That's a migration, not a pause, and it needs portable checkpoints and a cutover plan rather than a Stop button.
And if you're running training on a provider or instance type where Stop isn't available, or on spot capacity that can be reclaimed without notice regardless of Stop support, checkpointing discipline is still doing the job Stop does for a stoppable instance. Spot GPU training resilience covers the checkpoint intervals and preemption-recovery pattern that keeps a run safe when there's no Stop option to fall back on.
Common Mistakes When Using Stop and Start
A few mistakes come up often enough to call out directly.
- Expecting a restart to pick up mid-task the way a resumed laptop would. As covered above, Start isn't a resume. Budget the same warm-up time you'd budget after any cold boot: reloading model weights, re-establishing an active CUDA context, re-warming any cache that only ever lived in memory. Teams that script their restarts sometimes skip this and get hit with a request that fails or times out in the seconds right after Start reports ready, because the first inference call after a restart is doing cold-start work the dashboard doesn't surface.
- Letting the account balance run out while relying on Stop for something long-term. Running out of funds destroys instances regardless of their state, which erases the disk Stop exists to protect. The fix isn't complicated: set a balance alert before you stop anything you intend to keep for more than a few days, so a funding gap doesn't quietly undo the thing you stopped it to avoid.
- Assuming the stopped rate is a flat number across every instance. It scales with the disk size provisioned at deploy time and whether the instance carries a dedicated public IP, so two stopped instances of the same GPU type can carry different stopped rates. The stop dialog's monthly projection is the number to trust, not a mental estimate carried over from a different instance.
Picking up a paused project shouldn't mean rebuilding the environment from scratch. Spheron's Stop control releases the GPU, keeps the disk exactly as you left it, and brings it back on the same public IP when you're ready.
Quick Setup Guide
From the instance card or the instance's details panel, select Stop. This is a self-serve control, no support ticket required.
Spheron shows the running rate, the stopped rate, the percentage saved, a monthly projection, and an itemized list of what's still billed (disk, and a public IP where the provider charges for one).
The GPU releases and billing drops to the stopped rate. The disk and its contents stay exactly where they were.
Starting a stopped instance returns the same disk, the same contents, and the same public IP, so saved connection details still work without reconfiguration.
Frequently Asked Questions
Yes, on Spheron AI and Spheron ES, using the Stop control shipped in Spheron's v1.27.0 release on 5 Sep 2026. Stopping an instance keeps it instead of destroying it: the GPU stops billing, the disk and everything on it stays exactly where it was, and Starting it again returns the same disk, the same contents, and the same public IP, so saved SSH or connection details still work.
Yes. A stopped instance bills for its disk, not its GPU, and the stop dialog itemizes exactly what's still being charged, including a dedicated public IP where the provider charges for one. It's cheaper than running, not free. A team that runs out of account credit has every instance destroyed, stopped ones included, so stopping an instance is not a substitute for keeping the account funded.
Stopping releases the GPU and drops billing to the disk rate while keeping the disk, its contents, and the public IP in place for a later restart. Terminating destroys the instance and its disk for good. Stop an instance you're coming back to; terminate one you're finished with, especially on instance types like Spheron MS bare metal that don't support stop or restart at all.
On Spheron's aggregated marketplace, Stop and Start works on Spheron AI and Spheron ES. It isn't available on Spheron MS, Verda, Sesterce, or Massed Compute. Among competitors, Hyperstack offers a comparable VM hibernation control that saves VM state and pauses billing. Support varies by provider and, on Spheron AI, by machine type and region too, so check the deploy summary or instance panel before you plan around it.







