Baseten says it holds more than 100 GPU clusters on more than 20 clouds1 to one security standard, and on 20 November it published how it does that, with a 36-item checklist for auditing your own fleet or a provider’s.
Stephen Day and Hao Wu wrote the post, the first in a security series. Baseten put out an overview the same day, by Sameer Paranjpye and Kabir Sikand, that sets out the threat it’s answering: agent swarms that “try every door, exploit zero-day vulnerabilities, and exfiltrate data within minutes”.

- The threat Baseten is responding to
- Why every cluster gets its own hardening
- Four trust boundaries
- Limiting the blast radius
- The supply chain
- How Baseten checks its own work
- What Baseten says customers control
- The checklist
- What the posts don’t show
- Terms in this post
The threat Baseten is responding to
Baseten’s overview says that in the last six months models got very good at finding exploits, agents became simple to set up and swarms of them became a normal attack pattern. It says the standards that were good enough a year ago no longer meet the bar.
what used to require a nation-state-level adversary now only needs a capable model and an orchestration tool.
Baseten, “Improved controls for the new era of cyberattacks”, 20 November 2026
The overview cites Google’s Q4 AI Threat Tracker, which Google Threat Intelligence Group published on 16 November. The tracker says that for the first time the group identified threat actors using LLM frameworks to fully automate vulnerability discovery and exploitation with no human in the loop. The evidence is an exposed staging server running a multi-agent framework that Google calls exploit_agent.
Google also says overall disclosures and exploits nearly doubled between January and August 2026. Zero-day exploits rose from an average of eight a month in 2025 to 11 a month in 2026, with 22 in August.
Two more findings sit close to Baseten’s business. The tracker describes LLMjacking, where attackers steal LLM credentials and cloud resources and resell access. In one intrusion a threat actor used CVE-2026-40217, a sandbox escape in LiteLLM, to turn limited-access inference keys into full administrative credentials, and other actors provisioned instances with powerful GPUs and requested quota increases to run their own LLM tooling. Baseten’s overview says inference is now a prime target because attacks aim at model weights and GPU capacity.
Why every cluster gets its own hardening
Baseten says it runs inference for customers including Cognition, Coinbase, Cursor, Datadog, HubSpot and Ramp, and that this takes a high bar of trust. Its docs describe Multi-cloud Capacity Management, or MCM, as the system that provisions and manages GPUs across cloud providers and regions. Deployments run active-active across clusters and clouds, and MCM reroutes and reprovisions workloads if a region or provider loses capacity. The security post says MCM lets Baseten treat GPUs as completely fungible, whether they come from a hyperscaler or a neocloud.
That’s the problem the post sets out to solve. Baseten says AWS and GCP hand over managed clusters with years of hardened defaults. Neoclouds, the newer GPU-focused clouds, are often less hardened and less uniform. Some lease bare machines, some run Kubernetes for you and some work through a partner that operates the control plane, and they often have public addresses and open ports. Every cluster is evaluated, and Baseten builds its own controls on top before the cluster serves traffic.
One inference provider has already described a provider-side incident. Fireworks says a third-party cloud provider hosting its research and development machines had a security incident on 23 October. Baseten’s post doesn’t refer to it.
Four trust boundaries
To bring the same controls to every cluster, Baseten starts from a threat model with four trust boundaries: the infrastructure layer, operating partners, workloads and internal access.
| Boundary | What it separates | What Baseten defends against |
|---|---|---|
| The infrastructure layer | Baseten’s platform from a provider’s hardware, network and defaults | A compromised provider, or a cluster that arrives exposed |
| Operating partners | Baseten from any third party that operates a layer of the stack | A compromised partner, or stolen partner credentials |
| Workloads | One customer’s code from other tenants and from the node | Malicious or compromised customer code, or a compromised image |
| Internal access | Baseten’s engineers from production clusters | Misused or stolen engineer access |

The infrastructure layer
Baseten follows a cluster from handover to decommission. At handover it closes every public port except the ones that serve traffic, puts the Kubernetes API behind an allowlist and sets SSH to key-only access with regularly rotated keys. SSH access is on demand, with multi-factor authentication and no long-lived credentials. A baseline scan checks the cluster before it joins the fleet.
In operation, traffic to and from each cluster moves through secure channels, so a cluster accepts traffic only from trusted Baseten infrastructure. Node joins are protected so a machine can’t add itself to a cluster, and hosts and Kubernetes are patched on a set cadence. At decommission, Baseten wipes customer data before the machines go back to the provider.
Operating partners
Some layers are run by someone else. A provider runs the hardware and its console, and on some clusters a partner runs the Kubernetes control plane. Baseten says anyone who operates a layer gets the least access that layer needs, partners notify it of control plane changes, and provider consoles require hardware-bound multi-factor authentication.
Workloads
Because we treat all end-user code as untrusted, we isolate it at build, at runtime, on the network, and from other customers’ secrets.
Baseten, How we secure 100+ clusters across 20+ clouds
The six workload controls Baseten lists
- Customer builds run in microVMs, so each build gets its own kernel.
- Every image comes through Baseten’s build platform, and customer and platform images live in separate registries.
- Network policy separates tenants, and cross-cluster traffic uses mTLS for authentication and encryption in transit.
- RDMA transfers between nodes pass through an agent that authorises each one.
- Customer secrets are encrypted in Baseten’s control plane, segregated by organisation, never baked into images or code, and reach only that customer’s own deployments.
- Runtime detection runs on every node and watches for breakout attempts, including through the GPU runtime.
Internal access
The last boundary is the one around Baseten’s own engineers. Baseten says access is restricted, fully logged, monitored and audited, and that the logs leave the cluster, so someone with access to a cluster can’t erase the record of how they used it. Its checklist adds that, ideally, no one has standing administrative access to production clusters.
Limiting the blast radius
Baseten assumes any boundary can fail, so it scopes credentials to one cluster at most. Its stated worst case is an attacker who controls a whole cluster, and the aim is that the damage stays inside that cluster. Baseten says even a fully compromised cluster holds no credential that reaches another cluster, or the control plane beyond a limited scope.

It lists three controls that do the work:
- Deploy keys are per cluster at most, and read-only. The key a cluster uses to pull its configuration can’t change what any cluster runs.
- Each cluster has its own certificate authority, so a token signed in one cluster isn’t valid in another.
- Data distribution credentials rotate within an hour, which limits how long a stolen one can be misused.
The supply chain
Baseten says the four boundaries cover who can reach a cluster, and that clusters also need securing against every input: configs, images, weights and software. Each input gets its own control.
| Input | Control |
|---|---|
| Cluster configuration | Each cluster pulls it with its own read-only deploy key |
| Images | Every image comes through Baseten’s build platform, with customer and platform images in separate registries |
| Model weights | Weights arrive over a data distribution path with full audit logs, and actions that don’t match an expected data flow are flagged |
| Host software | Hosts and Kubernetes are patched for known and potential risks |
How Baseten checks its own work
From the inside, Kubernetes audit, host, DNS and SSH logs from every cluster flow to one system for monitoring, with alerts that page an on-call responder. From the outside, a daily scan checks every cluster’s external perimeter, and Baseten says it regularly verifies each provider’s security posture.
The overview adds two practices. Agents analyse activity across Baseten’s network to flag malicious behaviour, and alerts trigger automated escalation. Alongside third-party penetration testing, Baseten runs agentic red teaming against its own code, with programs like OpenAI’s Daybreak Red.
What Baseten says customers control
The overview answers the question customers ask, how to protect sensitive data and workloads on Baseten, with six points.
- Your identity provider stays in charge: employees are provisioned and sign in through it, with fine-grained roles mapped to your groups.
- No long-lived secrets are needed: workloads can reach your cloud with short-lived tokens, and Baseten API keys are scoped, expire and can be revoked at any time.
- You can hold the keys to your weights: served weights can be encrypted with keys in your own cloud key management service, and revoking Baseten’s access disables decryption.
- You set the network boundaries: ingress and egress allowlists, and private connectivity for single-tenant deployments.
- Your data stays where you put it: inference runs only in regions you approve, and Baseten says it keeps zero data retention for inference data.
- You can verify activity: audit logs are exportable to your own detection tools.
The checklist
Baseten closes the post with a checklist it says you can use “to audit your own fleet or to evaluate an infrastructure provider”. Each item should be true for every cluster. There are 36 items in seven groups.
36
items in the checklist
11
on workloads, the biggest group
8
on the infrastructure layer
2
on internal access, the smallest

All 36 items, by group
- Credential scope (4): no credential, key or trust root spans more than one cluster; a read-only deploy key per cluster; a certificate authority per cluster; data distribution credentials that rotate within an hour.
- Infrastructure layer (8): public ports closed except those serving traffic; Kubernetes API behind an allowlist; key-only SSH with rotating keys; a baseline scan before a cluster joins; secure traffic paths; protected node joins; a patching cadence; customer data wiped at decommission.
- Operating partners (4): least access; notice before control plane changes; multi-factor authentication on every provider console; per-cluster, write-only credentials for outside vendors.
- Workloads (11): microVM builds; images only from your build platform; separate registries; audited weight distribution; hardened GPU isolation; tenant network isolation; mutually authenticated cross-cluster traffic; RDMA through an authorising agent; secrets in an encrypted store you control; secrets delivered only where needed; runtime detection on every node.
- Internal access (2): ideally no standing administrative access to production clusters; every access path logged, with logs shipped off the cluster.
- Verification (4): centralised logs with paging alerts; flagging of unexpected data flows; regular perimeter scans; verification of each provider’s security posture.
- Remediation (3): every finding has an owner and a deadline; gaps are tracked to closure; provider-side gaps are raised and followed up until fixed.
What the posts don’t show
Baseten’s posts describe controls and publish no evidence for them. They name no auditor or certification, no penetration-testing firm and no incident. They don’t say which neoclouds Baseten uses, or how many clusters arrived exposed at handover. The checklist items are yes-or-no statements, and Baseten gives no results from running it on its own fleet.
Baseten says more is coming over the next few weeks: posts on what security at agent speed looks like, API key hygiene, container and network security, identity and access management, and observability, detection and response. They’ll appear in the security section of Baseten’s blog.
Terms in this post
- Neocloud
- A newer cloud provider that focuses on GPUs. Baseten says over a dozen of its 20-plus clouds are neoclouds.
- MCM
- Baseten’s Multi-cloud Capacity Management, the system that provisions and manages GPUs across providers and regions.
- microVM
- A lightweight virtual machine with its own kernel. Baseten runs each customer build in one.
- mTLS
- Mutual TLS, where both ends of a connection prove who they are and the traffic is encrypted.
- RDMA
- Remote direct memory access, a way for machines to transfer memory directly. Baseten routes it through an agent that authorises each transfer.
- Allowlist
- A list of the only addresses or users allowed in.
- Certificate authority
- The service that signs the certificates systems use to trust each other.
- Deploy key
- The key a cluster uses to pull its configuration.
- Baseten’s pages give two counts. The post’s title, its security category listing and the X post say 20+ clouds; the post’s web address and the link text on the overview page say 25+. ↩︎
Sources
- Baseten: How we secure 100+ clusters across 20+ clouds, 20 November 2026
- Baseten: Improved controls for the new era of cyberattacks, 20 November 2026
- Baseten on X, 20 November 2026
- Baseten docs: How Baseten works
- Google Threat Intelligence Group: AI Threat Tracker, Agentic Threat Activity Crosses a Significant Threshold, 16 November 2026
- Fireworks: October 2026 security incident update
Discover more from Sulat AI & Tech News
Subscribe to get the latest posts sent to your email.





