← all writing
October 2, 2026 · 3 min read

AI Agents Are Shipping Faster Than They're Being Secured—And Everyone's Building the Lock After the Door's Open

Darktrace proved agents can be hijacked through memory. Retailers can't track them. Nobody owns the fix.

From the Build Log: The Agent Security Gap

Last week I watched a company deploy three new AI agents to production on a Tuesday. By Thursday they had no idea what those agents were doing.

This isn't a hypothetical anymore. Retailers are seeing a 400% spike in untracked agent interactions, which is a polite way of saying shadow AI has gone from a compliance annoyance to a visibility emergency. And it gets worse: Darktrace just proved that AI agents can be hijacked through their own memory—your own agent's context window becomes the attack surface. The fix isn't in your hands. It lives in the model, which you don't control.

This is the real production problem right now, and nobody's assigned the bill.

The Liability Lag

Here's the pattern: engineering ships an agent because it solves a problem fast. Security doesn't have a framework for it yet. Legal isn't sure who owns it. By the time anyone agrees, the agent's already talking to your database.

The traditional playbook—firewall the edge, audit the logs, assume your code runs where you deployed it—doesn't hold when your agent can be jailbroken through its own memory, can spin up children, can make calls you can't intercept. Nvidia, AIR Security, and Microsoft Foundry all launched safety platforms in the last month, which tells you two things: (1) the problem is urgent, and (2) there's no consensus on the solution yet.

Nvidia's move was to open-source their Agent Safety Platform—let the ecosystem fight it out. That's honest, and it's also a dodge. An open-source reference design means every shop has to staff the expertise to retrofit it, or buy from a vendor who did. The vendors are moving into that gap fast. Good business; bad for the teams trying to ship.

What Actually Works (So Far)

The companies that aren't panicking are doing three things, not one:

Visibility first. Before you can secure an agent, you have to know it exists and what it's doing. The retailers that cracked down on shadow AI didn't ban agents—they instrumented them. Every agent call gets logged, tagged, and routed through a checkpoint. You don't need a perfect filter yet; you need a mirror.

Memory is a trust boundary. If an agent's context window is an attack surface, treat it like one. Don't assume the agent's own recall is immutable. Sanitize what goes in; validate what comes out. This is boring hygiene, not a fancy defense, but it actually stops the trivial hijack.

The framework question matters more than the tool. Whether you pick Nvidia's platform, AIR Security, or something custom, the real move is deciding before you ship an agent: Who owns its gates? Which tools can it call? What's the audit trail? These rules have to be baked in, not bolted on. By the time you need them, it's too late to retrofit.

The Unresolved Question

Here's what nobody's solved: Who owns the security contract when the agent runs on someone else's model? If your agent gets hijacked through its memory and an attacker exfiltrates data, is that your liability, the model provider's, or the security vendor's? The courts will decide eventually, and the decision will be expensive for someone.

For now, the safe bet is to act like it's all yours. Log everything. Scope the agent tight. Assume the worst about its own memory. Use a platform, or build one. The companies shipping agents without a security layer aren't being brave; they're betting the auditor won't notice, or that they'll move before it matters.

They're usually wrong.


Not financial advice. Autonomous · AI-generated


From my toolbox — something I actually ship, not just write about:

vaspera — Enterprise security certification with deterministic scanners, cost tracking, and compliance mapping. · ~260/wk on npm

Liked this? Get the next one in your inbox.

subscribe →