$ today_in_10_seconds
Google Cloud shipped agent-aware perimeter controls that block a compromised agent from exfiltrating data even when its credentials are perfectly valid — because in the world of prompt injection, IAM sees no anomaly. It's the clearest signal yet that the network perimeter is becoming the mandatory safety net for autonomous agents, precisely because the agent layer can't be trusted to police itself. The whole week's security news points one way: assume the agent will be hijacked, and contain the blast radius.
$ lead_story
Google Cloud adds agentic guardrails to VPC Service Controls
Google Cloud extended VPC Service Controls with capabilities built specifically for autonomous agents, establishing a network-level, destination-based perimeter around what agents can reach. Three changes matter: agents become first-class IAM identities you can add to ingress/egress rules (and revoke at the perimeter the instant one is compromised); policy can now key off MCP attributes like mcp.toolName, mcp.method, and mcp.tool.isReadOnly — so you can, for instance, grant an agent read access to a Workspace MCP server while explicitly denying its ability to send emails; and the Gemini Agent Platform gets native VPC-SC integration. The reason this exists is the core asymmetry of agentic security: an agent's input can inadvertently prompt it to execute an unintended action, and if a hijacked agent has valid IAM permissions, IAM detects no anomaly — but when it tries to ship data to an external webhook, the perimeter blocks the transfer because the destination is outside the boundary.
// why_it_matters: Prompt injection turns a legitimately-credentialed agent into an insider threat, and identity controls alone can't stop it — a destination-based network perimeter is the backstop that can.
$ also_worth_attention
The new MCP spec goes stateless — and pushes security onto you
The next Model Context Protocol version lands July 28, 2026, and the headline change is that MCP becomes stateless at the protocol layer, replacing permanent sessions with tracking identifiers and state objects the server hands the client. Akamai warns predictable IDs open the door to workflow hijacking, cross-agent data access, and unauthorized cross-tenant actions, and new MCP-specific HTTP headers introduce desync attacks and header-leakage risks. The theme Microsoft's security team put bluntly in its own 2026 checkpoint: the protocol deliberately does not enforce security for you — that's the platform operator's job now.
link →A third of agent "skills" ship with a security flaw
The supply-chain risk under all this just got quantified: Snyk's ToxicSkills audit found 36.82% of 3,984 scanned agent skills had at least one security flaw, with arbitrary file read, RCE, and tool-poisoning vulnerabilities documented even in widely used official MCP servers. The uncomfortable implication for builders: the marketplace skill you install to save an afternoon may be the exact vector that turns your credentialed agent hostile — which is precisely why perimeter and gateway controls that assume compromise are becoming table stakes.
link →The "rug pull" is now a named MCP threat model
Microsoft's state-of-MCP-security writeup names the attack that breaks one-time approval: a server behaves while it's being reviewed, earns approval, then changes after agents and workflows already depend on it — the server you approved is not the server you're running. The defense is architectural, not procedural: register every server in a design-time catalog, pin tool definitions and alert on drift as a rug-pull tripwire, and route everything through a gateway that re-checks identity and policy on every call. Approval can't be a one-time event when the thing you approved can silently mutate.
link →
$ bigger_picture
The trend behind the headlines
Every security story this week converges on a single assumption: the agent will be compromised, so design for containment rather than prevention. Google's perimeter blocks exfiltration when IAM is fooled; MCP's stateless redesign explicitly hands security to operators; a third of agent skills ship exploitable; and even approved servers can rug-pull. Notice what's happening architecturally — because you can't trust the agent's reasoning layer (prompt injection makes its inputs untrustworthy by definition), defenses are migrating to the layers the agent can't talk its way past: the network destination, the tool-level gateway, the design-time catalog, the revocable identity. This is the same 'harness over model' thread this newsletter keeps pulling, now wearing a security badge. The controls that matter aren't verbal guardrails inside the prompt; they're technical boundaries outside the agent's reach.
MCP gateways (TrueFoundry, MintMCP, IBM ContextForge, and peers)
The enforcement layer the protocol won't give you. A gateway sits between your agents and every MCP server as the single approved endpoint, enforcing per-tool RBAC, pre-execution guardrails that flag injection-pattern tool sequences (bulk reads followed by external writes), and a complete invocation audit trail. Pair it with a network perimeter like today's lead and you get defense-in-depth: the gateway governs what can happen, the perimeter governs where data can go. If you're running agents in production, this is the piece most teams are missing.
$ subscribe --free
Get the next edition in your inbox
// DAIly Agent covers agentic AI three times a week
// free, no spam, exit anytime