AI Agent Security: Every Agent, What It Can Reach, What It Did (2026)
AI agent security answers four questions per agent: what is acting, what can it do, what did it do, what sensitive data can it reach. How to answer all four.
Somewhere in your company right now, an AI agent is reading a file it should not be able to see. It is not malicious. Nobody attacked it. An engineer connected Claude Code to Google Drive with a scope that was easy to click, a finance analyst pointed ChatGPT at a shared folder, a platform team gave a Bedrock agent an IAM role copied from a human, and Salesforce quietly spun up an Agentforce integration user with the same object access as a sales admin.
AI agent security is the discipline of finding every one of those agents, resolving what identity each one runs as, mapping what that identity can do, observing what the agent actually did, and joining it all to the sensitive data behind the permissions. Done right, it answers four questions for every agent, bot and AI-enabled automation in the business:
This guide is written for the CISO or security engineer who has to answer those questions by Friday. It covers what makes agents a different problem from service accounts and SaaS apps, the six identity patterns agents actually use, the controls that work, the findings that matter on day one, and how Strac's agent security platform answers all four questions across the systems where agents live: Google Workspace, AWS and Bedrock AgentCore, GitHub and Copilot, Slack, Salesforce and Agentforce, Anthropic Claude, OpenAI ChatGPT and Cursor.

Related: see agentic AI security and how an MCP gateway governs what agents can access and send.
AI agent security is identity security plus data security, applied to software that decides its own next step.
That last clause is the whole problem. A traditional SaaS app or service account does what its code says. An agent interprets an instruction in natural language, picks tools, chains calls, reads whatever its credential can read, and writes wherever its credential can write. The blast radius of an agent is not its code. It is the union of every permission behind every credential it can borrow.
So AI agent security cannot be a prompt filter or a model firewall alone. It has to be built on a graph:
Agent → runs as / delegates through → Principal (OAuth grant, GitHub App, Slack bot, Salesforce user, IAM role) → has → Permissions (scopes, roles, repo grants, ACLs, IAM actions) → permits → Resources (Drive files, Slack channels, repos, Salesforce objects, S3 buckets) → contain → Sensitive data (PII, PHI, PCI, secrets, source code, financial data)
Activity joins the same graph: Agent → Principal → action → Resource → Sensitive data → Destination. The first chain tells you what could happen. The second tells you what did. Keeping them separate, and joining them only through evidence, is the difference between a tool that produces a CISO-grade finding and a tool that produces a theory.

The first generation of agentic AI security focused on the model: guardrails, prompt-injection filters, output scanning. Those controls are necessary and Strac uses them at the data layer. But they answer the wrong first question. A guardrail cannot tell you that a stale Zapier automation still holds a live HubSpot token, or that a Copilot coding agent has contents:write on payments-prod, or that an Agentforce bot has no owner.
Here is what an inventory like the one above tends to surface in a mid-size company in the first week:
None of these show up in a model-layer tool, because none of them are about the model.
If you only remember one section of this guide, make it this one. Agents do not have one kind of identity. They have six, and your ability to attribute an action to an agent, and to revoke that agent's access, depends entirely on which pattern it uses.
client_id and the user
Patterns A through D are what most identity-security and SaaS-security tools can see, because they leave a footprint in the provider's admin API. Patterns E and F are where API-only tools go blind, and they are growing fastest, because computer-use agents and browser agents are the easiest kind to deploy. More on that below.
A practical rule from this table: do not call every service account, bot or OAuth app an AI agent. Store "is an agent" separately from "is a non-human identity." Your NHI inventory might have 4,000 entries. The ones that interpret instructions and choose actions are the ones that need agent-grade controls, and conflating the two buries the real risk in noise.
The most common mistake in agentic AI security programs is inferring did from can.
Authorization is what the provider's control plane says is possible: a Claude OAuth grant for Alice has drive.readonly; Alice is a member of Finance; Finance has Reader on the Payroll folder. Activity is what the audit log says happened: Google's token audit shows client_id=Claude called the Drive API on behalf of Alice at 10:04; Drive's audit shows Alice's identity opened payroll.xlsx. Data is what Strac's inventory knows about that file: it contains SSNs and compensation.
Three different sources, three different confidence levels, one finding. Store them separately. Join them through evidence. Show the join on the finding. A security team that has been burned by a "risk score" nobody could explain will trust the first tool that shows its work.

Notice the last line in that screenshot: granted versus used. Overprivilege is measured over a policy window, not guessed. gmail.readonly was granted and never exercised in 30 days, so the recommendation is to drop it, and the remediation is reversible and one click because Google exposes a bounded admin API for revoking a user's third-party app tokens by client_id. That is what "least privilege for AI agents" looks like when it is operational rather than aspirational.
Agents live where your data lives. An AI agent security platform earns its keep by covering the handful of systems where agents, credentials and sensitive data overlap most, and by being honest about what each integration can and cannot see.
Two rules we hold to in building this. First, use provider control-plane APIs and audit logs before you build an inline proxy for anything. Proxies see traffic; control planes see permissions, and permissions are the thing you need to change. Second, every integration ships a capability manifest that says, per provider, exactly what Strac can discover, resolve, attribute and remediate, so that "coverage" on a dashboard is a measured number and not a marketing claim. Breadth of integrations is not the metric. Useful agent connections, identity-to-resource joins and explainable sensitive-data findings are.
Here is the scenario that breaks every SaaS-posture tool on the market.
Alice is logged into Salesforce in Chrome. A computer-use agent, Cowork or similar, takes control of that browser session and exports a report. Salesforce's audit log records, correctly, that Alice exported a report. No OAuth grant was created. No service account exists. There is nothing in Salesforce's admin API that can prove an agent did it.
The only way to attribute that action is to join the provider's activity with evidence from where the agent actually ran: the browser and the endpoint. Process and session, URL and domain, account context, file upload or download, timing, and where available the AI session ID. Strac marks that attribution as correlated rather than provider-native, because honesty about confidence is part of the product.

This is the structural advantage of an agent security platform built on top of browser DLP and endpoint sensors that are already deployed for data loss prevention:
These are optional evidence adapters into the same graph, not a separate product. Deploy them where you need the confidence; the inventory still works without them.
A good finding is deterministic, explainable and actionable. An opaque ML risk score is none of those things, and a security team cannot defend it in an audit. Strac computes severity from six factors you can see on every finding: sensitivity × action capability × breadth × sanctioning × observed use × attribution confidence.
These are the findings worth building a program around:
* resourcesEvery row in that table is a question a CISO already asks. The difference is that with the graph in place, the answers come with proof.

Discovery without remediation is a report. The reason agent security programs stall is that the fix usually lives in someone else's console, and the security team is reduced to filing tickets.
Strac's remediation model is built on one safety principle: separate discovery credentials from remediation credentials. You can deploy agent security read-only on day one. Write access is opt-in per provider and per action, and every remediation option states exactly what will change, whether it is reversible, and whether Strac can apply it or you need the provider console.
The data layer of the platform in action: Strac redacting sensitive data in AI and MCP traffic. Agent security adds the identity, permission and activity layers on top of this.
What that looks like per provider:
client_id in one click; remove a Drive permission where Strac already manages it. Otherwise, a deep link and the recommended scope change.And for the human side of remediation: the owner can acknowledge the finding, sanction the agent, or create an exception with an expiry, so the inventory stays honest instead of filling up with snoozed alerts.
If you are starting from zero, this is the order that produces results fastest. It mirrors how we sequence the product itself.

For the broader program, including the frameworks regulators are converging on, see AI agent governance frameworks and the three operating practices: discover AI agents, protect AI agents and monitor AI agents.
Programs fail from ambition as often as from neglect. Things we recommend against, and have chosen not to build first:
The two terms get used interchangeably and mostly describe the same work. Agentic AI security tends to be used when the concern is autonomy: an agent that plans, chains tool calls and acts without a human approving each step. AI agent security tends to be used when the concern is the specific software: Claude Code, Cursor, Codex, an internal LangChain service.
The distinction matters less than what both need, which is the same three answers: which agents exist, what each one can reach, and what data actually moved. An autonomous planner with read-only access to a test folder is a smaller problem than a single-step script holding a production database credential. Autonomy is not the risk multiplier. Reach is.
Most tools that claim agent coverage are really covering one layer of it. The honest way to compare them is by what they can see and what they can do about it.
| Approach | What it sees | What it misses or enforces |
|---|---|---|
| Strac | Every AI agent and MCP server on the device, what data each can reach, and the sensitive data moving through prompts, files and tool calls | Audit, warn, redact or block per channel |
| Identity and NHI governance (Okta, Microsoft Entra) | Which machine credentials exist and who owns them | Nothing about what the agent actually reached, or whether the data was sensitive |
| AI gateways (Cloudflare, Kong, AWS) | Model traffic that is routed through the gateway | Agents running locally, MCP servers, and files that never touch the gateway |
| EDR (CrowdStrike and peers) | Process execution and file events on the endpoint | Prompt contents, MCP tool calls, and whether the data was regulated |
| CASB and SSE (Netskope, Zscaler) | Sanctioned SaaS traffic from the network | Coding agents on the laptop and their local MCP configuration |
The pattern is that identity tells you who an agent is allowed to be, the network tells you what it sent, and the endpoint tells you what it ran. None of those tell you whether the thing it touched was a customer record. That is the layer Strac starts from, which is why agent findings name the data at risk rather than just the tool.
This sits inside Strac's wider AI security posture management surface, which inventories every AI tool, agent and MCP server on your devices and ranks the findings to fix first.
Strac already runs the data layer for AI at hundreds of companies: AI DLP in the browser and on the endpoint, MCP DLP for agent tool calls, shadow AI discovery, and a classified inventory of sensitive data across SaaS, cloud and endpoints.
Agent security adds the other three questions on top of that inventory. In practice that means:
Deploy it read-only in an afternoon. The first inventory is usually the most uncomfortable meeting of the quarter, and the most useful.
👉 Book a demo and we will run the inventory against your own Google Workspace, AWS or GitHub tenant live on the call.
AI agent security is the practice of discovering every AI agent and AI-enabled automation in an organization, resolving the identity and credential each one runs as, mapping the permissions that identity has, observing what the agent actually did, and joining that to the sensitive data it can reach. It combines identity security, data security and runtime monitoring for software that chooses its own actions.
Start with reach, not prompts. Remove write, export and send capability the agent never uses, keep secrets and execute off the same principal, and redact sensitive data at the MCP, browser and endpoint boundary before it reaches the model. Then watch activity for sends, exports or tool responses that carry classified data to an external destination, and treat each one as a Critical finding.
LLM security protects the model: prompt-injection filtering, output scanning, jailbreak resistance. AI agent security protects what the model can do: the credentials it borrows, the permissions behind them, the data it can reach and the actions it takes. You need both, but guardrails cannot tell you that an ownerless agent holds a live production token. The graph can.
NHI security inventories every service account, API key and bot. AI agent security is the subset that interprets instructions and chooses actions, plus the join to sensitive data. Treat "is an agent" and "is a non-human identity" as separate flags. Most NHIs are not agents; every agent uses at least one NHI or borrows a human identity.
No, and any vendor who says otherwise is selling a filter. Prompt injection is a property of models that follow natural-language instructions. What you can do is bound the blast radius: least privilege on the agent's credential, no secrets-plus-execute on one principal, sensitive data redacted before it reaches the model, and activity monitoring that catches an injected agent doing something its owner never asked for.
No regulation names "AI agents" yet, but every existing control framework already covers them through their identities and data. SOC 2 and ISO 27001 require access control, least privilege and logging for every identity, human or not. GDPR, HIPAA and PCI DSS regulate the sensitive data agents read regardless of who read it. The EU AI Act and the NIST AI RMF add transparency and accountability expectations for AI systems, which in practice means an owner, an inventory and an audit trail for each agent. The agent inventory is the artifact every one of those audits will ask for first.
Rarely, and you choose per channel. Strac runs four enforcement modes: audit, warn, redact and block. Most teams start everything in audit, move the risky paths to warn or redact, and reserve block for the few flows where regulated data must never leave. Alongside that, give every agent an owner, scope its credential to what it actually uses, redact sensitive data at the boundary, and keep a reversible way to switch it off. Teams that ban agents outright get shadow AI agents instead, which is the same risk with no audit trail.
.avif)
.avif)
.avif)
.avif)
.avif)

.gif)

