"I'll just SSH in and run Claude Code myself." That's the first objection anyone raises when a GPU rental platform tells them an AI agent can deploy and operate its own GPU. It's also a fair one: SSH is free, it's how most of us already work, and it doesn't ask you to trust a new vendor with sudo access to a box with a credit card attached. This post is a check on AI coding agent own GPU safety specifically, not a general pitch for a product: it lays out exactly what a do-it-yourself SSH setup leaves unguarded, checks that list against two real incidents where none of it was in place, and lands on the honest answer, which is that SSH wins for a single session you're watching, and the guardrails earn their keep once the job repeats, runs unattended, or gets handed to more than one person.
TL;DR: Is Manual SSH Enough for AI Coding Agent Own GPU Safety?
Past a single supervised session, no: manual SSH gives an agent root with no spend ceiling, no approval step before a destructive or billing action, and no record of what it ran unless you build all three yourself, which is exactly what two real, documented 2026 incidents show going wrong without them.
- Credential theft: an attacker who extracted an API key from a compromised agent host added a persistent SSH key and ran undetected for about three weeks, consuming roughly $600,000 in donated model credits, per METR's own incident writeup, disclosed in 2026.
- Runaway spend: a Mandiant case study published 16 Sep 2026 describes an accounting agent entering an unconstrained reasoning loop that fired more than 15,000 API calls in under an hour and ran up roughly $50,000, with no attacker involved at all.
- What closes the gap: Spheron's Agent GPU Sandbox requires approval on every deploy, Stop, Start, and terminate, caps spend per connection, and restricts the sandbox to the account that deployed it.
- What SSH doesn't give you: none of that ships with a raw shell. A spend cap, an approval gate, and owner-only access are things you write and maintain yourself over SSH, not defaults.
- Verdict: SSH is the right call for a single session you're watching; the guardrails pay for themselves once the job is unattended, repeated, or shared. See Spheron's Agent GPU Sandbox for how the approval and spend-limit flow actually works.
What Manual SSH Actually Requires You to Wire Up Yourself
SSH solves exactly one problem: getting a shell on the box. Everything that makes handing that shell to an agent safe, rather than merely possible, is left for you to build on top of it.
- A spend ceiling. Nothing in
sshorsudotracks the instance's hourly rate against a budget. Spheron's own on-demand H100 runs $2.98/hr as of 21 Nov 2026, and a background job that keeps a GPU running for a week nobody noticed is a credit-card problem you find at the end of the month, not one the shell caught at the start.
Pricing fluctuates based on GPU availability. Spheron rates above are live as of 21 Nov 2026; other providers reflect their most recent published rates and may have changed. Check current GPU pricing → for live rates.
- An approval gate on destructive or billing-changing actions. A raw shell runs whatever the agent sends, the moment it sends it. Nothing stops a deploy, a scale-up, or a teardown command from executing the instant the agent decides to run it.
- Access scoped to the one account that provisioned the box. An SSH key in
authorized_keysworks for whoever holds the matching private key, which is however many people that key has been copied to, not whoever actually deployed the instance. - A command-level audit trail. Bash history sits on the box until someone clears it and isn't shipped anywhere, so it's useless the moment the instance is gone, rebuilt, or compromised.
- Network exposure discipline. An SSH daemon has to accept an inbound connection on some port, and keeping that port closed to everything but your own IP is a firewall rule you write and keep current yourself, not a default.
None of this is hard to build individually. Teams running internal ML platforms already do it, with IAM policies, a Slack-bot approval step, and a sidecar that ships bash history to a log aggregator. It's just work that has to happen before the first agent command runs, not something ssh root@<ip> gives you for free.
The Four Guardrails Behind AI Coding Agent Own GPU Safety That a Bare SSH Session Doesn't
Spheron's Agent GPU Sandbox docs describe the same four gaps closed as defaults, not as something you configure after the fact. Connecting an agent takes one MCP URL (the step-by-step connect and deploy walkthrough covers the exact command for Claude Code, Cursor, and Codex CLI), and every guardrail below is already active on the box the agent gets back.
Approval on every state-changing action, not every command. Every deploy, Stop, Start, and terminate shows a price preview first and requires explicit approval before anything is created or billed. That's a deliberate design choice, not a missing feature: Anthropic has written that Claude Code's own sandboxing exists partly to counter "approval fatigue," where a user asked to approve every single bash command eventually stops reading the prompts closely and starts clicking through them. Gating the handful of actions that actually cost money or destroy state, instead of every command the agent runs inside the box, keeps the approval step meaningful instead of becoming background noise.
A per-connection spend limit and a total budget. Each connection carries a per-hour cap and an overall budget; a launch that would exceed either is refused outright, and only the owner can raise it. A bare SSH session has no equivalent. The only thing stopping an agent from running a GPU for days is someone noticing the bill.
Owner-only access with no inbound port. Only the account that deployed an instance can use its sandbox; other team members and accounts can't. The sandbox program itself opens no inbound port at all, connecting outward to Spheron over HTTPS only, which removes an entire class of exposure an internet-facing SSH daemon carries by default. Anthropic's Claude Code team puts the underlying logic plainly: "Sandboxing ensures that even a successful prompt injection is fully isolated, and cannot impact overall user security." A tightly scoped, outbound-only connection is what makes that isolation claim hold.
Command logging by default. Every command the agent runs is logged with its text and exit code. Command output and file contents aren't stored in that log, so it isn't a full audit of everything the agent read or wrote, but it is a record of every action it took, without anyone having to set up log shipping first. And the deploying user's own SSH key keeps working on the machine the whole time the sandbox is active, so none of this trades away the ability to get on the box directly and check it yourself.
Worth being honest about what these four guardrails don't do: none of them review whether the agent's code, config, or output is actually correct. They bound blast radius and cost once an action is already inside the approved spend limit, they don't grade the work. A model that writes a broken training script but stays under budget and inside its approval scope will run that broken script just as readily in a sandbox as it would over SSH.
What Those Guardrails Would Have Caught: Two Real Runaway-Agent Incidents
Neither of the incidents below happened on Spheron. Both are real, documented cases of an agent with broad GPU or cloud access going wrong in exactly the ways a bare SSH setup leaves open, which is why they're worth checking against the guardrails above rather than treating them as hypotheticals.
The credential-theft case. A METR researcher's agent was running on an internet-exposed EC2 instance after an authentication flaw silently disabled its login check. An attacker prompted the agent into revealing an API key, then installed an SSH key on the box, creating a persistent method for remote access that went unnoticed for about three weeks and consumed roughly $600,000 in donated model credits, disclosed in 2026. Two of the four guardrails map directly onto what went wrong here: a box that opens no inbound port removes the exposed listener the attacker needed in the first place, and access scoped to one owner means a stolen credential doesn't automatically hand someone a working, persistent foothold on the machine. A spend limit would have bounded the damage even if the initial compromise still happened, instead of letting it run for three weeks before anyone noticed the bill.
The runaway-spend case. Mandiant's AI Risk and Resilience Report 2026, covered on 16 Sep 2026, describes an accounting agent entering an unconstrained, recursive reasoning loop that issued more than 15,000 high-cost API calls in under an hour, generating roughly $50,000 in cloud charges and locking a local database that halted live business transactions, with no attacker involved at all. This one needed no stolen key and no injected prompt, just a loop with nothing stopping it. A per-hour and total spend cap is the one guardrail purpose-built for exactly this: a launch or a continuation that would cross the limit gets refused, which is a different failure mode than a $50,000 charge discovered after the fact. Mandiant's own framing of the broader problem is blunt: "Defending against these autonomous threats requires transitioning to clearly identified, adaptive identity controls." A spend limit tied to a single, verified owner is a narrow version of exactly that.
Where Manual SSH Still Wins: One-Off Exploratory Work
None of this makes SSH the wrong call in general. If you're going to sit at the terminal, watch the agent work, and kill the box yourself when you're done, SSH into an instance that's already running is faster than any of the above, and it doesn't ask you to learn a new tool first. Spheron's own sandbox takes about 1 to 3 minutes to move from setting up to ready once the instance itself is running, real overhead a human who's already SSH'd into a live box simply doesn't pay. This blog's comparison of six agent sandboxes tabulates that exact tradeoff against CPU-only tools like E2B and Daytona, where cold starts land in milliseconds because there's no GPU VM to provision at all. And if what you actually want to understand is the isolation mechanics underneath any of these, the deeper breakdown of Firecracker and gVisor passthrough covers that layer in more depth than a buying decision needs.
For a single run where a person is present the whole time, the four guardrails above are solving a problem that supervision already solves. You are the approval gate. You are the one watching the spend. Building a sandbox around that session adds a step without removing a real risk. It's also built around a single owner: foreground commands cap at 10 minutes by default, so anything longer needs explicit background mode, and the sandbox is single-tenant by design, one owner's agent on one machine, not a shared multi-tenant platform. A raw shell session imposes neither constraint.
When the Sandbox Pays for Itself: Repeated, Unattended, or Team-Shared GPU Work
The calculation flips the moment nobody is left watching. Karpathy's autoresearch is the clean example: an agent that edits a training script, runs an experiment, and repeats the loop unattended overnight, racking up roughly 80 to 100 runs by morning on a machine with nobody at the keyboard to approve or stop anything in between. That's precisely the shape of job a spend cap and an approval gate on teardown are built for, because the whole point is that it runs while you're asleep.
Team-shared GPU work has the same problem from a different angle. Twelve real prompts sent to a GPU sandbox by role, from an ML engineer's fine-tune to a researcher's RL ablation sweep, are jobs where more than one person's agent might reasonably want access to GPU capacity over time. Owner-only access and a per-command log matter more once it's not a single person's terminal session anymore: they're what let a team share GPU capacity without any one person's agent having standing, unlogged root on a box someone else is also relying on.
Manual SSH doesn't become unsafe in either case. It just stops including anything that notices when the job runs longer, more often, or with more hands on it than the day you set it up.
Checking its exact objection against two real runaway-agent incidents is one way to see what a GPU sandbox's guardrails actually buy you over a bare SSH session; connecting one to your own agent is the faster way to feel it.
Frequently Asked Questions
It's as safe as the guardrails around that access, not the access itself. Root on a GPU box is root on a GPU box whether an agent or a person holds the key. Spheron's Agent GPU Sandbox bounds what that access can do: every deploy, Stop, Start, and terminate needs explicit approval against a price preview, only the deploying account can use the sandbox, it opens no inbound port, and every command is logged by text and exit code. A bare SSH session gives the same sudo access with none of that built in.
Four things specifically: a spend ceiling, an approval step before a destructive or billing action runs, access restricted to the one account that provisioned the box, and a record of what the agent actually ran. None of those ship with `ssh root@<ip>`. Spheron's Agent GPU Sandbox docs describe building in a per-connection spend limit and total budget, approval previews on every state-changing action, owner-only access, and command logging as defaults.
Yes, the same way it can compromise an agent anywhere else, by getting the model to take an action the operator didn't intend. What changes box to box is the blast radius once it happens. [Anthropic's Claude Code team](https://claude.com/resources/articles/beyond-permission-prompts-making-claude-code-more-secure-and-autonomous) has said sandboxing "ensures that even a successful prompt injection is fully isolated, and cannot impact overall user security." A sandbox with owner-only access, no inbound port, and a spend cap limits what a hijacked agent can reach and spend; a bare SSH box with none of those limits does not.
For a single session you're watching yourself. If you're going to sit at the terminal, supervise the agent in real time, and tear the box down when you're done, SSH into an already-running instance is faster and has no extra setup step. The guardrails matter most once the job repeats on its own schedule, runs unattended overnight, or gets shared across more than one person, which is exactly when nobody is left watching to catch what SSH alone wouldn't have stopped.







