# Your LLM Stack Is a 2008 Database With Better Marketing

Lovina Dmello

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/XjI-AR4pt7Y-your-llm-stack-is-2008-database-better) · [Video](https://www.youtube.com/watch?v=XjI-AR4pt7Y)

## 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.

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

[0:00](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=0s)

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](https://www.oligo.security/blog/shadowray-attack-ai-workloads-actively-exploited-in-the-wild) 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](https://www.anyscale.com/blog/update-on-ray-cves-cve-2023-6019-cve-2023-6020-cve-2023-6021-cve-2023-48022-cve-2023-48023) 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](https://docs.ray.io/en/latest/ray-security/token-auth.html) 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.**

![Slide titled “$1B+ exposed. No zero-day. Just a default left on.” with a ShadowRay callout and bullets about exposed keys, overprivileged accounts, and public model weights.](https://ai.engineer/api/talk-essay-media/70f3f5609509e5c4e3e38d67e0ae1cadf886dc2593c63173227570d75b5a887c)

The talk’s ShadowRay example: Ray clusters exposed to untrusted network access.

### The stack changed its security assumptions

[3:07](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=187s)

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 connected boxes labeled Classic app, ML in prod, and LLM stack compare deterministic code and perimeters with probabilistic behavior, copyable weights, shared GPUs, prompts, retrieval corpora, and agents.](https://ai.engineer/api/talk-essay-media/8acaa8c45f1ad69f5915b2d44696253730aaf7d67535a05ead4c21330d6cf3f1)

From classic applications to production ML and the LLM stack, security assumptions change.

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.

### Build the boundary from the infrastructure upward

[5:35](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=335s)

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.

### Available protection can disappear in configuration

[8:22](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=502s)

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.

### A defense must fit the request path

[10:26](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=626s)

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.

### The gaps between tools, teams, and research

[12:32](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=752s)

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.

![Slide titled “The ecosystem isn't production-ready either” with three colored panels labeled Tooling lags DevOps by years, Expertise silos, and The research–practice gap.](https://ai.engineer/api/talk-essay-media/2b60a1a27c7327396e789a25601bc655b057e7b5694b6c84d7673a4b695c6428)

Three ecosystem gaps: tooling, expertise silos, and research versus practice.

### Assess the deployment, then repair its boundaries

[14:31](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=871s)

Dmello proposes a maturity model intended to map onto the [NIST AI Risk Management Framework](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-ai-rmf-10). The levels and overhead budgets below are her proposal, not NIST-defined tiers. NIST’s [AI RMF Playbook](https://www.nist.gov/itl/ai-risk-management-framework/nist-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.

![Three numbered rows pair risks with least-privilege RBAC and short-lived credentials; default-deny policies, micro segmentation, and mTLS; and a secret manager, encryption at rest, and CI scanning.](https://ai.engineer/api/talk-essay-media/7f2f1cc8125db2d5f52978e5ecfe3e6de62b4eafaf5e1e3a5f1610a51e7be511)

Three deployment risks and their fixes: overprivileged access, flat networks, and exposed secrets and artifacts.

### New attack surfaces still need enforceable boundaries

[17:21](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1041s)

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.

## Resources

- [The original ShadowRay investigation](https://www.oligo.security/blog/shadowray-attack-ai-workloads-actively-exploited-in-the-wild) — Oligo's investigation of compromised Ray servers, exposed credentials, compute abuse, and deployment mitigations.
- [Ray's historical security boundary](https://www.anyscale.com/blog/update-on-ray-cves-cve-2023-6019-cve-2023-6020-cve-2023-6021-cve-2023-48022-cve-2023-48023) — The maintainers' 2023 explanation of Ray's external trust boundary and lack of built-in authentication.
- [Configure Ray token authentication](https://docs.ray.io/en/latest/ray-security/token-auth.html) — Configuration guidance for built-in authentication in Ray 2.52.0 and later, including token handling and transport protection.
- [NIST AI Risk Management Framework 1.0](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-ai-rmf-10) — The voluntary framework for managing AI risks throughout system design, development, deployment, and use.
- [NIST AI RMF Playbook](https://www.nist.gov/itl/ai-risk-management-framework/nist-ai-rmf-playbook) — Suggested actions and references organized around Govern, Map, Measure, and Manage.
- [Self-hosting a validated AI coding assistant](https://developer.nvidia.com/blog/how-to-self-host-a-validated-ai-coding-assistant-with-nvidia-nemo-guardrails/) — Dmello's practical guide to combining self-hosted inference, request policies, CI security checks, human review, and operational metrics.

## Slides

### Your LLM Stack Is a 2008 Database With Better Marketing

Lovina Dmello argues that production ML security failures often stem from familiar infrastructure mistakes and misconfiguration rather than exotic AI attacks.

[0:28](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=28s) [Title slide introducing Lovina Dmello’s talk on ML security misconfiguration.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c9dd2754fe2bed0b4900015fee7f032b25f1ba3aeef8337623444b1ba0379cf.webp)

AI ENGINEER · SECURITY TRACK · ROOM 2005

Your LLM Stack Is a
2008 Database
With Better Marketing

Why ML security is dominated by misconfiguration, not missing features

Lovina Dmello
Senior Infrastructure Software Engineer · Deep Learning Libraries, NVIDIA

### ShadowRay: A Default Left On

Dmello describes Ray dashboards and job APIs exposed to the internet with authentication off by default. She puts the exposure at over $1 billion and points to familiar configuration mistakes behind ML breaches.

[1:02](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=62s) [The slide describes exposed Ray clusters and attributes the exposure to disabled authentication and infrastructure misconfiguration.](https://assets.ai.engineer/sites/aiecode2025/sha256/826a138d99ea64bd2b89dfbabee6a26ffc7634c41aae1a4d87d1668bf0fa96d5.webp)

A story

$1B+ exposed. No zero-day. Just a default left on.

“ShadowRay,” 2023: Ray clusters exposed to the open internet with authentication turned off.

Ray didn't lack a security feature. Operators deployed it with the feature disabled.

• It wasn't a clever new attack. The headline ML breaches almost never exploit novel attacks on models.
• It was the boring stuff. Exposed API keys, overprivileged accounts, model weights in public buckets.
• The whole breach was a checkbox nobody flipped.

Your LLM Stack Is a 2008 Database With Better Marketing
02 / 17

### The Stack Changed, but Security Assumptions Did Not

Production ML introduced probabilistic behavior, copyable weights and shared multi-tenant GPUs. LLMs add prompts, retrieval corpora and agents, while the security playbook remains deterministic, perimeter-based and single-tenant.

[3:05](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=185s) [Three panels compare a classic application, production ML and an LLM stack, highlighting changes in behavior, tenancy and attack surface.](https://assets.ai.engineer/sites/aiecode2025/sha256/225b85255a4af0c407279a3f254862f4410f07bc3122d897d1e38f4fa2159513.webp)

How we got here

We changed everything about the stack except our assumptions

2008
Classic app
Deterministic code. A perimeter. One tenant. Security had a clean mental model.

Today
ML in prod
Probabilistic behavior, copyable weights, shared multi-tenant GPUs.

Now
LLM stack
Prompts as control flow, RAG corpora, agents the surface explodes again.

The systems got probabilistic, copyable, and multi-tenant. Our security playbook is still deterministic, perimeter-based, single-tenant.

Your LLM Stack Is a 2008 Database With Better Marketing
03 / 17

### Three Core Ideas

The speaker identifies misconfiguration as the top failure mode, warns that published defenses may not survive production, and argues for securing ML as infrastructure.

[4:48](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=288s) [Three ideas emphasize misconfiguration, defenses in production and securing ML as infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/c9aa692964b5fd25cb406101804850da5ce7e196b7b48cec30714ead391c4bed.webp)

What I want you to leave with

Three core ideas, then where this is going

1 Misconfiguration, not missing features, is the #1 failure mode.
2 The defenses you read about don't survive production.
3 Secure ML like infrastructure : not like a model.

Five things stand out distilled into three ideas to remember, plus a few musings on the LLM + GPU frontier before we wrap.

Your LLM Stack Is a 2008 Database With Better Marketing
04 / 17

### Four-Pillar Defense-in-Depth

Infrastructure security forms the foundation. Access control and runtime security sit above it and feed each other, while operational practices guide day-to-day work across the stack.

[5:35](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=335s) [A layered diagram places operational practices above access control and runtime security, with infrastructure security as the foundation.](https://assets.ai.engineer/sites/aiecode2025/sha256/93bce84c9ea2c94ec60018c31e71c482bbbb5f7b7b6114a1b99c8f7a7e877c72.webp)

The mental model
Four-pillar defense-in-depth

OPERATIONAL PRACTICES  MLSecOps · compliance · incident response · culture

ACCESS CONTROL
auth · authz · multi-tenant

RUNTIME SECURITY
validation · anomaly · logging

INFRASTRUCTURE SECURITY
containers · network segmentation · GPU virtualization · encryption

Infrastructure is the foundation. Get the bottom layer wrong and every layer above it is decoration.

Your LLM Stack Is a 2008 Database With Better Marketing
05 / 17

### Six Threat Categories and Their Defenses

The table pairs adversarial inputs with validation and detection, and model extraction with rate limiting, API authentication and query analysis. Each threat needs a stack of controls.

[6:52](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=412s) [A table pairs six threat categories, from adversarial inputs to insider threats, with primary defenses.](https://assets.ai.engineer/sites/aiecode2025/sha256/20c06f20a663c2b686df0a7a84e3f870793585b8fca64d5078920a5d5b7030cc.webp)

What you're defending against

Six threat categories each needs a stack of defenses

THREAT | PRIMARY DEFENSES
Adversarial inputs | Input validation + adversarial detection
Model extraction | Rate limiting, API auth, query analysis
Data poisoning / supply chain | Secure CI/CD, model signing, provenance
Privacy breaches | Access control, encryption, audit logs
Infra compromise & DoS | Container isolation, network segmentation
Insider threats | RBAC/ABAC, MFA, behavior analytics

No threat maps to one control. Defense is always a stack: primary + secondary + detection.

Your LLM Stack Is a 2008 Database With Better Marketing
06 / 17

### Misconfiguration is the #1 failure mode

The speaker introduces misconfiguration as the first core idea after pointing to infrastructure compromise and insider threats as recurring sources of breaches.

[8:13](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=493s) [Section 01 states that misconfiguration, not missing features, is the number one failure mode.](https://assets.ai.engineer/sites/aiecode2025/sha256/b0d0fd55783e3970ee2e73966896ab48b6b16d3d6ed5311b58d40e0f266e6440.webp)

01

Misconfiguration, not missing features, is the #1 failure mode.

### Configuration beats features

The speaker reports critical security mistakes in 78% of 50 audited production ML setups. The slide highlights overly broad access, missing network policies, and publicly accessible secrets and model artifacts.

[8:21](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=501s) [The slide reports critical misconfigurations in 78% of reviewed Kubernetes ML deployments and lists access, network and storage problems.](https://assets.ai.engineer/sites/aiecode2025/sha256/e985e3cbf285f41ddecdc66772ede8dd09554cb5cb9c8046162308a66cf64e92.webp)

Core idea 1 · the evidence

Configuration beats features more reliably than any attacker

78%
of reviewed K8s ML deployments had ≥1 critical misconfiguration

- RBAC left at cluster-admin defaults.
- Network policies absent in > half of clusters.
- Secrets and model artifacts in public buckets.

One well-configured cluster
Pod Security Standards, network policies, secret management
would prevent more real breaches than every adversarial-defense technique from the last five years.

Your LLM Stack Is a 2008 Database With Better Marketing
08 / 17

Interface text: CC

### Defenses in production

The speaker introduces the production tradeoff: every control costs something, and in ML that cost is latency and throughput.

[10:24](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=624s) [Section 02 states that the defenses people read about do not survive production.](https://assets.ai.engineer/sites/aiecode2025/sha256/bdc6e28e6c9571fa27706a03d33fe50b4b1b82b0864e3e60c4f2dcea6e6ef11c.webp)

02

The defenses you read about don't survive production.

Interface text:
CC

### Why the best defenses never ship

The slide puts sandboxing at 10–20% latency and adversarial detection at 15–30%, recommending selective use or noting limited live viability. The speaker says implementation quality also affects cost.

[10:31](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=631s) [A table compares estimated latency and deployment guidance for authentication, validation, logging, isolation, sandboxing and adversarial detection.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b04e590b93d366a78ddd5c014c36f03371f48b8c1c99c28d3677493a70868c0.webp)

Core idea 2 · the economics
Why the “best” defenses never ship

MECHANISM | LATENCY | VERDICT
Auth (API key / OAuth) | <1–5% | Always on
Input / schema validation | 1–3% | Always on
Comprehensive logging | 3–8% | Always on
Container isolation (Docker) | 2–5% | Default for prod
gVisor / Kata sandboxing | 10–20% | Selective
Adversarial detection | 15–30% | Rarely viable live

The strategy isn't binary. Run the sub-5% controls everywhere; deploy expensive ones only on high-risk workloads.

Your LLM Stack Is a 2008 Database With Better Marketing
10 / 17

Interface text: CC

### The ecosystem isn't production-ready

ML security tooling lags, while expertise is split across teams. Research often studies isolated models and pixel attacks, while production teams face stolen credentials, insider misuse and shared infrastructure.

[12:29](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=749s) [Three panels describe gaps in ML security tooling, expertise across teams, and the relationship between research and practice.](https://assets.ai.engineer/sites/aiecode2025/sha256/f3356875507904b95f622ff0e708cb9e7bd19acbc10ff9920fcfdded91aa60d8.webp)

Core idea 2 · it's not just overhead
The ecosystem isn't production-ready either

Tooling lags DevOps by years    Gap 1
ML-specific security tooling trails general DevOps tooling badly and there's still no ML threat-intel sharing at scale.

Expertise silos    Gap 2
Security doesn't speak ML, ML doesn't speak infra-security, ops doesn't own model behavior. Gaps live in the seams no single team can see.

The research–practice gap
Research assumes pixel-perturbation attacks; you face credential theft and insider misuse. Evaluation stops at accuracy and studies one model you run dozens behind shared infra.

Your LLM Stack Is a 2008 Database With Better Marketing
11 / 17

Interface text:
CC

### Secure ML like infrastructure

The speaker introduces a maturity model and a short list of first fixes for securing ML infrastructure.

[14:07](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=847s) [Section 03 calls for securing ML like infrastructure rather than treating it as a model problem.](https://assets.ai.engineer/sites/aiecode2025/sha256/1cb36af41158925afb74e534e3d2cf97ef7d6cd97ac51686a31c53b449ba6f60.webp)

03

Secure ML like infrastructure
not like a model problem.

Interface text:
CC

### A four-level security maturity model

The model pairs controls and overhead budgets with deployment contexts. L2 is the minimum for production; L4 targets critical infrastructure at 20–30% overhead.

[14:29](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=869s) [Four security maturity levels, from minimal controls for low-risk development to maximum controls for critical infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/c739a3411bee2610ae4bb1a88e4a82dd55486b83c4c5ea71c6d4a8eed00a6e53.webp)

Core idea 3 · know where you stand
A four-level security maturity model

L1 Minimal
<5% overhead
API keys, basic RBAC, default containers, schema validation
Dev / low-risk

L2 Baseline
5–10% overhead
OAuth/JWT, network policies, TLS, rate limiting, logging, CI/CD scans
Min. for production

L3 Enhanced
10–15% overhead
mTLS, RBAC+ABAC, service mesh, microsegmentation, ML anomaly detection
Regulated (HIPAA, finance)

L4 Maximum
20–30% overhead
Zero-trust, gVisor/Kata, confidential computing, red team, dedicated SOC
Critical infrastructure

Your LLM Stack Is a 2008 Database With Better Marketing
13 / 17

Interface text: CC

### The three misconfigurations behind most of the risk

Broad privileges, unrestricted pod-to-pod access, and exposed keys or model weights create risks. The slide pairs least-privilege RBAC and network isolation with secret management, encryption, and CI scans.

[15:32](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=932s) [Overprivileged access, flat networks, and exposed secrets and artifacts, with suggested fixes for each.](https://assets.ai.engineer/sites/aiecode2025/sha256/0f7f1b23392b7992432915e2578bbb48a6eaa2a295810c0221bb44b6748818d2.webp)

The three misconfigurations behind most of the risk

Core idea 3 · if you screenshot one slide, this one

1. Overprivileged access
Cluster-admin RBAC defaults & long-lived service accounts.
Fix: Least-privilege RBAC · scoped, short-TTL credentials

2. Flat networks
No network policies  any pod reaches any pod.
Fix: Default-deny policies · micro segmentation · mTLS

3. Exposed secrets & artifacts
Keys in code, model weights in public buckets.
Fix: Secret manager · encrypt at rest · scan in CI

Your LLM Stack Is a 2008 Database With Better Marketing
14 / 17

Interface text: CC

### Three takeaways

Secure ML infrastructure by fixing overprivileged access, flat networks and exposed secrets first. Make existing defenses practical to run in production.

[18:56](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1136s) [Secure ML infrastructure, make existing defenses deployable, and fix the three misconfigurations first.](https://assets.ai.engineer/sites/aiecode2025/sha256/d7e95e31e5f81b93750b6b606c98b1ad94b41c7b9dcc5f18c4d16bc5d249203c.webp)

If you forget everything else
Three takeaways

1. Securing ML is an infrastructure problem, not a model problem.
The breaches that matter exploit config, not clever math.

2. The field has enough defenses it needs deployable ones.
Optimize existing controls for production; don't invent new ones.

3. Fix the three misconfigurations first.
Overprivileged access, flat networks, exposed secrets then climb the maturity model.

Your LLM Stack Is a 2008 Database With Better Marketing
16 / 17

Interface text:
CC

### AI Engineer World's Fair

[20:25](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1225s) [Black outro card with white AI Engineer World's Fair branding and the event website.](https://assets.ai.engineer/sites/aiecode2025/sha256/38566e51c7dca975474b16db3cc0f8b84980521927d5d3e0f75af130d0199933.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

[0:00](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=0s) [on-hold music] Hi, everyone. So my name is Lovina Dmello, and I'm a senior software developer at NVIDIA, and I work on the deep learning infrastructure team.

[0:23](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=23s) So the title here is a bit of provocation. What I really mean, and what I want you to leave with is, uh, for the next fifteen minutes, I am going to make one uncomfortable argument, which is almost everything that is breaking in the production ML security isn't some exotic AI attack.

[0:45](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=45s) It's the same boring infrastructure mistakes that we supposedly fixed years ago. So now, once, uh, you look across the research from the whole field, the pattern is very easy, like, it's very difficult to unsee.

[1:02](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=62s) Let me start with a story. So in two-- in twenty-twenty-three, security researchers went looking at Ray clusters, and Ray is one of the most popular framework for distributed ML.

[1:17](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=77s) So what they found out over there was there were thousands of clusters that were sitting open on the Internet. What that means is the dashboards were open, and there were job APIs that were open.

[1:34](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=94s) And why that happened? Because authentication was off by default, and somebody just forgot to turn it on while putting the ML in the, uh, in production.

[1:53](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=113s) So I'm a little bit short, you know. [laughing] [laughing]

[1:57](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=117s) So I need this. [laughing] Thank you. Okay. So, uh, the exposure at that time was a lot, like, it was over a billion dollars. So now let's sit with this part.

[2:10](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=130s) This was not a zero-day attack, and it was not a clever new attack, uh, on a neural network. So what happened was somebody just forgot to turn the default setting on while putting them into the production environment.

[2:26](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=146s) So it just depends upon what the configurations are on different deployment environments in the infrastructure. And when we look at the breaches that actually make the news, what we see, this is the rule, it's not an exception, but it's almost never the fancy adversarial attack.

[2:45](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=165s) What is happening is it's maybe like s-somebody exposed an API key. What happened is maybe some account was just overprivileged. Maybe some mo-model weight was, uh, in a public bucket, and the whole breach, it's-- it was just like somebody forgot to flip.

[3:07](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=187s) So how did we get here? Let's rewind a little bit. So what used to happen is a classic two thousand and eight application was deterministic. So we could reason what the code w-would exactly do.

[3:20](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=200s) You know, it had a fixed perimeter, and it served one tenant. Security researchers or security team had a clear mental model. They knew, like, what they need to secure, and, like, great tools were built around that time.

[3:38](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=218s) So later, what happened is we put these machine learning models into production, and we quietly broke all of the three assumptions because behaviors became probabilistic. Correct is a distribution now.

[3:52](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=232s) It is not one branch, like we say yes or no. And then we are protecting the weights, which the weights are itself are copyable, and the leaks are straight through the API that we are trying to serve.

[4:08](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=248s) And to make it more affordable, we pack everything onto a shared multi-tenant GPU where other security risks come into picture. And now the LLM stack itself blows up wide open, and prompts become control flow, and answers come from retrieval corpora, and agents are going to take the actions for us.

[4:32](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=272s) So here is the thing: we changed everything about the stack when we moved to machine learning, but we forgot to change the security assumptions. So we are running a two thousand and eight playbook on a twenty-twenty-six system.

[4:47](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=287s) That's all-- what the whole talk is about. So a few things, uh, five things stand out across all of this, and I have tried to boil them down into three core ideas.

[4:57](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=297s) Uh, and here they are. So first one is misconfigurations. So a lot of the times misconfigurations happen. It is not the missing features that are number one failure reason.

[5:10](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=310s) Second is the defenses that we are actually reading, they might not actually survive into production. And third one is we have to secure ML like infrastructure, and it's not like securing just a model, you know?

[5:25](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=325s) And if we for-- if you forget everything about this talk, I want you to remember these three points over here. Uh, and I'll share a few couple of things at the end.

[5:35](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=335s) Uh, okay. So over here is a map I want you to carry with you. It's four pillars about the defenses in depth. So at the bottom, we can see the-- at the bottom in the black, we can see the infrastructure security.

[5:52](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=352s) Over here comes into picture the containers, the networks, the GPU virtualization, and encryption. On top-- So this infrastructure security is the foundation. And on top of it sits the access control, like who is allowed to do what, and then is the runtime security, which is checking, uh, and watching the

[6:17](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=377s) traffic while the system is live. So they feed each other and wrapping all of it, uh, to day-to-day practice, like, um, how the team works plus compliance, incident response, and honestly, the culture.

[6:33](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=393s) So one thing to remember over here is if, uh, infrastructure is the foundation and failures down there can cascade up. So if we have a perfect access control policy, it's just a decoration if the cluster underneath is wide open.

[6:51](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=411s) So yeah. So those are the four levels. And this is a quick map of what we are defending against. So there are six categories. The two are about the model itself, so where we have the adversarial inputs and we have the model extraction.

[7:10](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=430s) Over here, the primary defenses should be, uh, about how do we do the input validation, how we do the adversarial detection, how we do the rate limiting, API auth, and query analysis.

[7:23](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=443s) The next two are about the data and integrity. Over there comes the poisoning and supply chain and privacy breaches. So we should make sure that, um, over there we make sure to secure the CI/CD model signing and provenance, access control encryption, all of those comes into that picture.

[7:43](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=463s) And the last two are classic infrastructure, where, uh, we take care of, um, basically container isolation, network segmentation, uh, RBAC, and behavior analysis. So if we notice one thing over here, uh, the green ones, infrastructure compromise and insiders, those are exactly where the real breaches keep

[8:08](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=488s) landing, and they are the cheapest to get wrong by accident, which brings me to the core idea number one, which is mis- misconfiguration, not missing feature. So those-- That is one of the number one failure mode.

[8:22](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=502s) Um, okay. So let me walk you through one of the research. What happens is, researchers audited fifty real production setups running machine learning. In seventy-eight percent of them, what the researchers found out was at least one critical security mistake and w- And here's why that

[8:47](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=527s) mattered beyond engineering. So that was a misconfiguration and the difference between a normal Tuesday and something having a headline about our company in the news is this kind of incident where there could be like a critical misconfiguration mistake and,

[9:07](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=547s) and the same three problems kept showing up in this research study. First was access controls were left wide open. So what happens when an access controls are left wide open?

[9:19](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=559s) Almost any account can do almost anything. So that is one of the problem. Second is nothing sep-- nothing was separated. For example, different parts of the system. So once an attacker would get access to one part of the system, he could do anything in the whole system.

[9:39](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=579s) So there is the thing like separating different parts of the system. And the third one were the passwords and trained models. So themselves, they were sitting into a storage that anybody could reach.

[9:54](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=594s) So why does this keep happening? So because these productio-- uh, protections are built by security experts for security experts, and then they get handed to the ML teams, and, uh, the responsibility of ML team is, um, basically making the model accurate, not configuring the infrastructure.

[10:14](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=614s) So the protection is right there in the platform. It just sometimes get switched off by some configurations.

[10:26](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=626s) Okay, so now moving to the core idea two, which is defenses you read about don't survive into the production. So here is, here is the thing. Every control costs us something, and in ML, that something is latency and throughput.

[10:45](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=645s) The two things that LS-- SLA is made up of, let's watch the colors. So the green tier over here, the basics like logins, input checking, costs, tho- those cost under about eight percent, and that should always be there.

[11:03](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=663s) No debate over there. The second one is the orange tier. So this is like the heavier isolation that walls around that, uh, that walls workloads off from each other. So here it runs ten to twenty percent.

[11:19](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=679s) So we can use it selectively. Like for sensitive and untrusted workloads, what we can do is we can decide if we want it or not. And the purple ones is catching malicious input in real-time.

[11:32](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=692s) So this is the most expensive one. Over here it can cost like, I don't know, fifteen to thirty percent, and it's one of the thing that researchers love the most.

[11:42](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=702s) But because we cannot slow every request down, so it's a non-starter. But what really matters is how much it costs depends almost entirely on how well we build it.

[11:56](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=716s) So the same security check, check, it can be done sloppily, and it can double our response time. But if it is done w- well, like considering all of these things, then it's fair, like the balance is fair.

[12:11](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=731s) So the guidance team actually need isn't should I do this? It's like, how do I do it without slowing everything down? And then we can run the cheap controls everywhere, and we can save the expensive ones for the heavier risk systems.

[12:32](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=752s) So here is the next slide. The ecosystem isn't production-ready yet. So what I meant is, um...

[12:40](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=760s) So there is the first gap that we will see. The security tooling for ML is years behind the rest of the software. So regular software teams, they solved a lot of this decades ago with automated security, scanning, proper passport-- uh, password management, and then we haven't cry, uh, carried it all over to ML yet.

[13:04](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=784s) Even today, there's a good share of early warning systems for ML-specific threats. So the second gap is in the expertise silos. So security team don't speak ML, ML teams don't speak security, and the operation teams don't know how the model behaves.

[13:22](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=802s) So there is a gap over here, and the problem lives in the gaps. So between those gaps where nobody has the full picture, so there's a little bit of, uh, mismatch over here.

[13:33](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=813s) And underneath both is a gap between the research and reality. So recha-- research is busy defending against tiny, invisible tweaks, but, uh, to an image that f- while the real world, we are fighting against the stolen password, and then people are misusing access that they already have, and it studies one model on

[13:58](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=838s) its own while we are running dozens of them, uh, on shared system. So what it lacks are one team can actually deploy everything. So there is this core idea number three, it's the constructive one.

[14:13](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=853s) So if the problem is infrastructure, we have to secure it like infrastructure, not like a model. And two practical tools for that are a maturity model to know where we stand and a short list of how to fix it first.

[14:31](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=871s) So here is, uh, the next slide. What we have to do is how to figure out where we actually stand. It's a maturity model that will help us map onto the NIST AI Risk Management Framework.

[14:45](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=885s) So there will be four levels, each tied to an overhead budget and the context. So on the level one, we can see that under five percent overhead is the bare basics.

[14:58](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=898s) Fine for test environment, not for production. So the level two, five to ten percent is a real baseline, like proper logins, encryptions, separating our networks, basic monitoring. This is the minimum bar for production.

[15:12](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=912s) And the level three adds more advanced controls that regulated industries like healthcare and finance needs. So on this part, most of the teams, uh, teams believe that they are at level three, but, uh, they are actually either at level one or two, like, it really depends how we have set up everything.

[15:38](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=938s) So on in this slide, I want to discuss about the three misconfiguration behind most of the risk. So the default setup often gives every account a full admin rights, so that is what have been observed in most of the research studies, with credentials that never expire.

[15:56](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=956s) So there are-- there have been credentials that do not have any expiry, and that can leak the key on its own. And, like, each account, like, should do only what it needs to do, and then the credentials to ex-- should expire very quickly.

[16:17](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=977s) Now, nothing stops one part of the system from reaching another part of the system. So if that can be tackled in a way, uh, then that can be solved.

[16:27](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=987s) Like attacker gets in one part of the system, and then they get it, can do everything. So that's, uh, like a flat network kind of issue. Then the fix.

[16:38](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=998s) So what we can do to fix this is we can wall the parts f-from each other, and we can require a verified identity between services, not just network access.

[16:50](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1010s) So there is an-another issue called the exposed secrets and models. So over there, passwords could be hardcoded in the code, model files sitting in the open storage. So the fix could be, like, a proper secret manager encryption and automatic scanning before sh- before all of this ships.

[17:10](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1030s) So this is nothing but like a basic hygiene, and this kind of hygiene can prevent breaches that actually make the news.

[17:21](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1041s) So, uh, here's the practical stuff. So now a couple of personal takes on where this is heading because the ground is moving very faster under us. So this is the part, uh, that least settled, and four things are on my mind right now.

[17:37](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1057s) So one is prompt injection. So the model can't reliably tell the difference between our instructions and someone else's input. So a cleverly worded message can quickly hijack the whole system.

[17:54](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1074s) So RAG poisoning, if our model pulls answers from a document store, and if the document store is poisoned by somebody or somehow, then what happens is it can poison, like, everything, and nobody has to retrain anything, right?

[18:11](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1091s) So GPUs, so next is the GPU side channel. So where we can pack multiple customers on one GPU in order to save money. That time, information can leak from one customer to the other.

[18:25](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1105s) And another area is the supply chain. So what happens over there is we download models and add-ons from public sources without really checking where they come from. So that's another issue.

[18:39](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1119s) And the honest caveat over here is, uh, all of this moves very fast. Every week, something or the else comes up. So we treat it as a direction, not a gospel.

[18:51](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1131s) And the defenses are immature right now because, uh, the threats keep evolving.

[18:59](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1139s) Okay, so three t-- uh, so let's bring it together. If you forget everything I said today, here are the three takeaways. So one is securing ML is an infrastructural problem, not a model problem.

[19:13](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1153s) So we have to spend our budget where the breaches actually are happening. Second, the field has enough defenses. It just need deployable ones. The frontier isn't a new attack defense pair.

[19:29](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1169s) It's making the existing controls run with proper production overhead. And that's the engineering problem, which is a good news for a room full of engineers. And the third one is we have to fix the misconfigurations, like overprivileged accesses, flat networks, and exposed secrets.

[19:48](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1188s) So then climb the maturity model on purpose. Uh, and to close the loop, uh, on the title, your LLM stack really is a two thousand eight database with better marketing.

[20:00](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1200s) So secure it like a database, lock down accesses, segment the network, and protect the data at rest. So we already know how to do that. We just have to do it actually in a better way.

[20:14](https://www.youtube.com/watch?v=XjI-AR4pt7Y&t=1214s) That's all. So thank you. [audience applauding] [outro jingle]
