Two reports from October 2026 describe the same fundamental problem from different directions.In the first case, an agent in Grok Bot posted a CEO's private account balances in the company Slack.For two hours, the data remained visible there.In the second case, according to Zenity Labs researchers, a single publicly reachable AI agent on Amazon's Bedrock AgentCore was enough to take over all AgentCore agents in the same AWS account and the same region.
Both incidents have little to do with the quality of the underlying language models.They concern the layer above: which data an agent may read, where it may write, and with which credentials it acts on behalf of the company.
The Slack case: wrong channel, real data
An agent that works in a chat system like Slack generally has two sets of permissions: access to data sources and write permissions in channels.If the two are not cleanly separated, an answer that is correct in itself can end up in the wrong place.That is exactly what happened here – financial data intended for a narrowly limited circle appeared in a channel with a significantly broader audience.
What is remarkable is less the mistake itself than the two-hour period during which the information remained visible.This is an indication of missing monitoring: no one immediately noticed that the agent had published something it should not have published.In regulated environments, this latency alone would be a reportable circumstance.
The AgentCore case: one prompt, many agents
The second case lies technically deeper.Bedrock AgentCore is Amazon's platform for operating AI agents in the AWS cloud.According to the researchers, a single externally reachable agent was enough as an entry point.The expansion was made possible by an internal AWS interface that issues temporary cloud credentials.Whoever intercepts these credentials then acts with the agent's permissions – and thus potentially also towards all other agents of the same account in the same region.
AWS has made improvements and, according to the account, later also significantly restricted the agents' default permissions.This second step is the more interesting one: it confirms that the original default granted more permissions than would have been necessary for operation.This is a recurring pattern with new platforms – generous defaults make it easier to get started and shift the security problem into production.
What the two cases have in common
The sources describe different levels: one a misdirected output in a collaboration tool, one a privilege escalation in a cloud infrastructure.What both have in common is that the agent could do more than its actual purpose would have required.
A classic software module does what is written in the code.An agent decides during operation which tools it calls and which data it passes on in the process.This decision depends on inputs that cannot be fully controlled – on user requests, on content from connected systems, in the case of AgentCore on a prompt from outside.Anyone who gives such a system extensive permissions effectively grants these permissions to anyone who can influence the inputs.
Permission concept before feature scope
For agent projects in companies, this implies an order that is often reversed in practice.Not feature scope first, but limits first:
- Minimal permissions per agent: An agent receives access only to the data sources and target systems that its specific use case requires – not to what the platform offers by default.
- Separation of reading and writing: Read access to sensitive data and write access to public channels do not belong in the same identity.
- Isolation between agents: Multiple agents in the same account should not be able to reach or take over each other.Separate accounts, roles or environments reduce the damage of a single compromised agent.
- Do not adopt default permissions: Platform providers' presets are starting points, not approvals.The AgentCore case shows that even large providers readjust here.
- Treat publicly reachable agents separately: Every externally addressable agent is a potential entry point and needs its own threat model.
Monitoring is part of operations, not an optional extra
The Slack case makes clear that prevention alone is not enough.Agents act quickly and often unobserved.Without logging of actions – which tool was called, which data was passed, which channel the output went to – an incident can neither be noticed nor reconstructed.
This also includes mechanisms for rapid intervention: a way to immediately shut down an agent, retract outputs and rotate affected credentials.Two hours of visibility is a long time in a company chat.
Clarify data releases explicitly
A third point concerns less the technology than the organisation.Which data sets may be made accessible to an agent at all?Financial data, HR data and contract documents require a deliberate release decision, ideally documented and with named responsibility.This decision cannot be delegated to the project team that builds the agent – it belongs to the business side and, depending on the type of data, to data protection.
A simple question before rollout is helpful: which information would be most unpleasant if it appeared in the wrong channel?
If an agent can access exactly this information, the justification for it must be robust.
Classification for web and software projects
For ongoing and planned projects, this shifts the effort involved: an agent is not finished with the connection to a language model, but with a robust permissions, approval and logging concept. This part is difficult to retrofit because it reaches into the architecture of the connected systems – into role models, interfaces and deployment environments. Anyone integrating agents into business processes should therefore plan security architecture and operating concept as part of the project scope from the outset and not treat them as downstream hardening.