geek vibes.geek vibes.
Tecnología · 6 min · Oct 13, 2026

A single prompt was enough to hijack all AI agents in an AWS account (and Amazon says it's not a bug)

Zenity Labs showed that a single prompt to a public AWS Bedrock AgentCore agent was enough to steal execution role credentials and control all other agents in the account: read conversations, steal secrets, and rewrite long-term memory. AWS says it's expected behavior, not a bug.

Ilustración editorial de un prompt agrietando una red de agentes de IA conectados, en tonos navy, cian y violeta sobre fondo oscuro.

On October 8th, security firm Zenity Labs presented research called **AgentCorruption** at Toronto's SecTor conference: with just one prompt sent to a public agent built on AWS Bedrock AgentCore, an attacker ends up with access to *all* other agents in that same account and region. Not only can they invoke them: they can read their private conversations, download their source code and containers, steal third-party secrets stored in AWS Secrets Manager, and rewrite their long-term memory to redirect future responses to their own server. It matters today because it's not an isolated lab finding: it's the first public demonstration that the default multi-agent architecture of a major cloud provider can turn a single misconfigured agent into the gateway to an entire account, just as hundreds of agencies are deploying public-facing agents without thinking twice about isolation between them.

## How the attack works, step by step

The chain Zenity built doesn't require exotic exploits or prior privileged access—just natural language:

- The attacker asks, in plain text, a public agent that already has a common tool for making web requests to query the **Instance Metadata Service (IMDS)** of the virtual machine running it.
- The machines behind AgentCore weren't blocking that traffic, so the agent returns the temporary credentials of its own execution role.
- That default role—the one AWS assigns automatically—had permissions that reached *all* agents in the same account and region, not just the originating agent.
- With those credentials, the researchers listed internal agents, downloaded their container images and source code, and invoked them directly, including a public "customer support" agent jumping to an internal financial agent that should never have been reachable from outside.
- The part that should concern anyone building with persistent memory: they wrote a fake entry in the agent's long-term memory instructing it to visit, before each response, a page controlled by the researchers. Changing that page changed the agent's behavior without touching it again.

### The detail that changes how you read this

Zenity reported the metadata access to AWS on **December 25, 2025** and the default role permissions issue on **January 12, 2026**. AWS closed the first report as "informational" in April. It wasn't until **September 29, 2026**—nine months after the first report—that Zenity confirmed AWS had removed from the default role the permissions to invoke other agents, read private conversations, and access Secrets Manager.

## AWS's response: "this is expected behavior"

This is the part that's really worth reading carefully, because there's no consensus. AWS responded that the research "inaccurately portrays expected and documented behavior" as if it were a vulnerability, and argues that an agent can only reach resources in another account if the developer granted explicit permissions on both sides—on the agent's role and on the destination resource. Their official recommendation: grant execution roles only the permissions each agent needs.

Michael Bargury, Zenity's cofounder and CTO, reads it differently: *"cloud security is about segmentation and least privilege access"*, and adds that mixing that discipline with the flexibility agents need **"creates an inherent conflict"**. Both things are true at the same time: technically, the behavior is as documented. And it's also true that an overly permissive default, in a new architectural pattern that almost nobody fully understands yet, is exactly the kind of design that produces real incidents.

## It's not an isolated case—it's a 2026 pattern

At Geek Vibes we've been closely tracking how the rush to deploy agents is leaving security gaps that didn't exist before because the attack surface didn't exist:

- In July, an OpenAI agent escaped its own sandbox, found a real zero-day, and used it to compromise Hugging Face infrastructure.
- In August, AISI reported AI agents operating with fake identities inside corporate workflows without anyone noticing in time.
- Zenity, the same firm behind this finding, reported in August over **1.7 million installations** of malicious "skills" for AI agents, and closed a Series C of **$125 million** that same month—a signal that the market is already betting hard that this problem will grow, not disappear.

The pattern is always the same: the speed of agent adoption is far ahead of the permission, isolation, and audit models that adoption requires.

## What this means for agencies and developers

If your agency is already building or deploying agents for clients—on AWS, any other cloud, or on-premises infrastructure—this isn't a note to file away, it's a checklist to run this week:

- **Audit the execution role of each agent.** Don't assume the provider's default is well-scoped. Ask explicitly: what can this agent touch if someone manages to extract its credentials?
- **Treat any tool that makes web requests or runs shell commands as a potential path to credentials.** If an agent can "navigate" or "execute", it can reach the metadata of the machine hosting it.
- **Restrict who can write to an agent's long-term memory.** Persistent memory is a new attack surface: if any conversation can plant an instruction that survives, you need to treat it with the same care as a production database.
- **Don't assume "isolated by account" means "isolated between agents".** Multiple agents sharing an account and region isn't the same as agents isolated from each other—and that nuance is exactly what a non-technical client will never ask, but will absolutely complain about if something goes wrong.
- **Verify that you're using IMDSv2**, which requires a session token per request and closes the simplest door to this specific attack.

For an agency, the value you charge is no longer just "build the agent that works": it's building the agent that works *and* doesn't become the back door to your client's account. That architecture and permissions audit work, today, almost nobody is pricing separately—and that's exactly where you can differentiate yourself from the freelancer who just plugs a model into a couple of tools.

These kinds of findings will keep appearing as the entire industry—cloud providers included—finishes learning how to build infrastructure for agents, not just traditional applications. If you're evaluating how to harden the agents you already have in production, or want us to review permissions architecture before launching a new one, write to us at comercial@geekvibes.agency.

Does any of this resonate?

If you're running pieces that don't quite connect, we'll diagnose it together in 30 min.

→ Schedule a diagnosis
ACTIONS