AI Engineer World's Fair 2026
Your LLM Stack Is a 2008 Database With Better Marketing
Loading slides…
Read the talk
Your LLM Stack Is a 2008 Database With Better Marketing
Exposed Ray clusters reveal a familiar security problem: production ML needs enforceable access boundaries, protected artifacts, and controls that fit its performance budget.
From a talk by Lovina Dmello
Before you start: Familiarity with APIs, service credentials, containers, and basic ML deployment will help; no specialized security background is required.
An open job API is already a security problem
What happens when a distributed ML cluster exposes its dashboard and job API to the Internet? An attacker may not need to manipulate a model at all: the infrastructure already offers a way to submit work. Lovina Dmello, who introduces herself as a senior software developer on NVIDIA’s deep learning infrastructure team, opens with researchers finding thousands of exposed Ray clusters. The matching ShadowRay investigation was published in March 2024, with evidence of exploitation extending back to September 2023.
Dmello describes authentication as a default that operators forgot to enable. The historical distinction matters: Ray’s maintainers stated in November 2023 that open-source Ray lacked built-in authentication and depended on an external security boundary. The deployment failure was allowing untrusted network access, rather than overlooking an available authentication switch. Built-in token authentication arrived later, starting with Ray 2.52.0.
Dmello describes the exposure as over a billion dollars; the matching investigation estimated almost a billion dollars in potentially compromised machines and compute, using observed clusters and contemporary annualized GPU rental prices. That was an estimate of exposed resources, not measured losses. Her practical point does not depend on the valuation: this was an exposed infrastructure interface, not a clever attack on a neural network. The same class of failure includes leaked API keys, overprivileged accounts, and model weights left in public buckets. Security depends on the configuration that actually reaches production.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The stack changed its security assumptions
Dmello’s stylized 2008 application has three convenient properties: deterministic code, a fixed perimeter, and one tenant. A security team can reason about its branches, identify the boundary, and decide what belongs inside it. Production ML complicates each assumption. Correctness becomes a distribution rather than a single yes-or-no branch. Model weights are copyable assets, while the serving API itself can become a route for extracting information about the model.
Cost pressure then puts multiple tenants on shared GPUs, making isolation part of the security problem. The LLM stack extends the boundary again: prompts influence control flow, retrieval corpora supply answer content, and agents take actions. A document store is now part of the system’s behavioral input; a generated response may become a request to another service. Keeping the old security assumptions while adding these capabilities leaves a 2008 playbook governing a 2026 system.
Three priorities follow: fix configuration failures before assuming the platform lacks security features; make defenses survive production latency and throughput constraints; and secure the infrastructure surrounding the model. These priorities connect the model’s behavior to the systems that grant it data, compute, and authority.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Build the boundary from the infrastructure upward
Defense in depth starts with infrastructure security: containers, networks, GPU virtualization, and encryption. Above that sits access control, which determines who may perform which actions. Runtime security watches traffic while the system is live. Operational practice surrounds all three: team responsibilities, compliance, incident response, and the culture that determines whether controls stay enabled. These layers depend on one another. A carefully written access policy offers little protection if an attacker can reach the underlying cluster through an unprotected interface.
The threat map spans six categories, grouped here by the assets and boundaries they threaten:
| Threat categories | Corresponding controls |
|---|---|
| Adversarial inputs; model extraction | Input validation, adversarial detection, rate limits, API authentication, query analysis |
| Poisoning and supply chain; privacy breaches | Secure CI/CD, model signing, provenance, access control, encryption |
| Infrastructure compromise; insiders | Container isolation, network segmentation, RBAC, behavior analysis |
Model-focused defenses belong in this map, but they do not replace infrastructure controls. Dmello identifies infrastructure compromise and insider access as recurring practical breach paths that are particularly easy to expose through configuration mistakes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Available protection can disappear in configuration
Dmello reports an unnamed audit of 50 production ML setups in which 78% had at least one critical security mistake. The audit’s sampling method and severity definition are not supplied, so the figure describes the study she cites rather than an established prevalence across production ML. Its recurring failures are concrete enough to inspect in a deployment.
- Open access controls: Almost any account can do almost anything, making a compromised identity broadly useful to an attacker.
- Unseparated components: Access to one part of the system enables movement into the rest. The initial compromise has no effective containment boundary.
- Exposed storage: Passwords and trained models sit where unintended parties can reach them.
These failures widen what an attacker can do after obtaining access; none requires discovering a weakness in the model’s predictions.
The ownership problem helps explain why existing protections go unused. Security experts design controls for people who understand security configuration, then hand them to ML teams whose primary responsibility is model accuracy. A platform can contain the necessary protection while the deployed configuration disables it. The missing capability is often an operational one: making the secure configuration understandable, owned, and maintained by the team shipping the system.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A defense must fit the request path
Every control consumes resources, and in ML those costs show up in latency and throughput—the quantities service-level agreements constrain. Dmello groups controls into three approximate cost tiers. She does not specify workloads, hardware, baselines, or whether each percentage measures latency or throughput, so these are her planning ranges, not transferable benchmark results.
| Tier | Control | Dmello’s approximate performance cost | Deployment guidance |
|---|---|---|---|
| Green | Logins and input checking | Under about 8% | Run everywhere |
| Orange | Heavier workload isolation | 10–20% | Prioritize sensitive or untrusted workloads |
| Purple | Real-time malicious-input detection | 15–30% | Reserve for higher-risk paths |
The distinction is about placement as well as expense. Basic authentication and input checking form a baseline. More expensive isolation or detection needs a deployment strategy that reflects the workload’s risk and available performance budget.
Implementation quality can change that tradeoff substantially. Dmello warns that a poorly implemented security check can double response time. A team therefore needs more than a recommendation to enable a defense: it needs guidance on implementing the defense efficiently. Run cheap controls broadly and spend the expensive checks where the risk justifies them. That turns security from a feature checklist into a request-path engineering problem.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The gaps between tools, teams, and research
Deployability is also an ecosystem problem. Dmello points to conventional software practices—automated security scanning and proper password management—that have not fully carried over to ML workflows. ML-specific early-warning systems are another part of the tooling question. Meanwhile, responsibility is split across teams: security specialists may not understand ML, ML specialists may not understand security, and operations teams may not understand model behavior. A failure can live in the space between those responsibilities without anyone holding the full picture.
The research environment introduces another gap. Defending against tiny image perturbations is different from defending a production service against stolen passwords or misuse of legitimate access. Studying one model in isolation also leaves out the operational conditions of dozens of models sharing infrastructure. The constructive requirement is a set of controls one team can actually deploy, supported by a maturity model that shows where the system stands and a short list of repairs to make first.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Assess the deployment, then repair its boundaries
Dmello proposes a maturity model intended to map onto the NIST AI Risk Management Framework. The levels and overhead budgets below are her proposal, not NIST-defined tiers. NIST’s AI RMF Playbook instead organizes guidance around Govern, Map, Measure, and Manage. She announces four maturity levels but describes only the first three.
| Level | Proposed overhead budget | Deployment context |
|---|---|---|
| 1 | Under 5% | Bare basics; test environments only |
| 2 | 5–10% | Production minimum: logins, encryption, network separation, monitoring |
| 3 | Not specified | Advanced controls for regulated industries |
These budgets likewise have no stated benchmark conditions. The useful assessment is whether the controls actually exist in the deployed environment. Dmello cautions that teams may consider themselves ready for regulated workloads while their configuration still places them at the basic or baseline level.
Start the repairs with least privilege and short-lived credentials. An account with full administrator rights and a credential that never expires combines broad authority with a long opportunity for misuse. Give each account only the operations its job requires, and shorten the lifetime of the credentials that exercise those permissions.
Next, separate the network and require verified service identity. In a flat network, compromise of one component can expose every reachable component. Segmentation limits that movement, while identity verification prevents network reachability from acting as authorization. A minimal TypeScript authorization check illustrates the second boundary: an authenticated inference service can read model artifacts without automatically gaining permission to publish them.
typescript
type Action = "model:read" | "model:publish";
type VerifiedService = {
id: string;
expiresAt: number;
};
const grants: ReadonlyMap<string, ReadonlySet<Action>> = new Map([
["inference-service", new Set<Action>(["model:read"])],
["release-service", new Set<Action>(["model:publish"])],
]);
function authorize(
service: VerifiedService,
action: Action,
now: number = Date.now(),
): boolean {
if (service.expiresAt <= now) return false;
return grants.get(service.id)?.has(action) ?? false;
}
The service identity and expiry must come from trusted authentication middleware, not request fields. This check enforces permissions; network policy separately determines which services can connect.
Finally, protect secrets and model artifacts. Remove hardcoded passwords, put secrets in a secrets manager, and keep model files out of publicly reachable storage. Add encryption and automatic scanning before shipping. The complete repair slide makes these boundaries concrete: least-privilege RBAC and short-lived credentials; default-deny policies, microsegmentation, and mTLS; then secret management, encryption at rest, and CI scanning. These are ordinary infrastructure controls applied to the assets an ML system depends on.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
New attack surfaces still need enforceable boundaries
The familiar repairs do not exhaust the threat model. Dmello closes with four areas she considers less settled:
- Prompt injection: A model cannot reliably separate trusted instructions from someone else’s input. Malicious text can redirect behavior when the system treats that text as instructions.
- RAG poisoning: Corrupting the document store can corrupt retrieved answer content without retraining the model. The retrieval corpus becomes a security-sensitive dependency.
- GPU side channels: Sharing a GPU across customers saves money but can introduce routes for information to leak between tenants.
- Model supply chains: Downloading models and add-ons from public sources without checking their provenance imports risk into the deployment.
These are directional concerns in a fast-moving field, with defenses that remain immature. They extend the boundaries that need protection: instructions versus input, trusted versus untrusted documents, one tenant versus another, and verified versus unknown artifacts.
The engineering agenda is to spend security effort where breaches occur and make existing controls work within production performance budgets. Another isolated attack–defense pair does not solve the deployment problem if teams cannot afford to keep the defense enabled. Repair overprivileged access, flat networks, and exposed secrets, then increase maturity deliberately. The database analogy ends with a concrete operational demand: lock down access, segment the network, and protect data at rest. The LLM stack adds new behavior, but it still needs those boundaries to hold.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The voluntary framework for managing AI risks throughout system design, development, deployment, and use.
Further reading
Oligo's investigation of compromised Ray servers, exposed credentials, compute abuse, and deployment mitigations.
The maintainers' 2023 explanation of Ray's external trust boundary and lack of built-in authentication.
Suggested actions and references organized around Govern, Map, Measure, and Manage.
Dmello's practical guide to combining self-hosted inference, request policies, CI security checks, human review, and operational metrics.
Updates since the talk
Configuration guidance for built-in authentication in Ray 2.52.0 and later, including token handling and transport protection.
Full transcript
Loading transcript…