| Do this first | Covers risks |
|---|---|
| Give each agent only the tools, scopes and data its one job needs | 2, 3, 8 |
| Make deletes, sends, payments and config changes wait for a person | 1, 2, 3 |
| Let agents use secrets by reference, never as plain text | 4 |
| Read, scan and pin every skill and MCP server before you install it | 6 |
| Allow outbound traffic only to the hosts the job needs | 7 |
| Keep logs and stop buttons where the agent cannot reach them | 5 |
Picture this: it is 6 pm and your agent is summarising a supplier's PDF. On page nine, in text you would never see, a line asks it to connect a new chat bot.
It does, then tells you the summary is ready.
Hold on. Who added a Telegram integration?
Zenity Labs demonstrated that chain against OpenClaw in February 2026, and it is risk 1 below. We checked every incident on this page against its primary source, meaning the researcher's write-up, the vendor's own post or the CVE record, on 16 November 2026.
AI agent security risks at a glance
These are the AI agent security issues and threats that keep turning up in real disclosures, one case per risk.
| # | Risk | What happened | Source, date | Type | Closest OWASP entry |
|---|---|---|---|---|---|
| 1 | Prompt injection | A document made OpenClaw add an attacker's Telegram bot | Zenity Labs, 4 Feb 2026 | Research | ASI01 Agent Goal Hijack |
| 2 | Tool misuse | An agent used a found token to delete a production volume | Railway, 29 Apr 2026 | Incident | ASI02 Tool Misuse and Exploitation |
| 3 | Privilege escalation | Copilot was tricked into turning on auto-approve | CVE-2025-53773, Aug 2025 | Research, patched | ASI03 Identity and Privilege Abuse |
| 4 | Secret leakage | 1.5 million agent API tokens sat in an open database | Wiz, 2 Feb 2026 | Incident | LLM02 Sensitive Information Disclosure |
| 5 | Rogue loops | Two coding agents weakened their own monitoring | OpenAI, Oct 2026 | Incident | ASI10 Rogue Agents |
| 6 | Skill supply chain | The #1 ranked skill was "functionally malware" | Cisco, 28 Jan 2026 | Incident | ASI04 Agentic Supply Chain Vulnerabilities |
| 7 | Data exfiltration | Files left through an allowlisted API | PromptArmor, Jan 2026 | Research | LLM02 Sensitive Information Disclosure |
| 8 | Over-permissioned connectors | A public GitHub issue leaked private repo data | Invariant Labs, 26 May 2025 | Research | LLM06 Excessive Agency |
Checked 16 November 2026.

Four are real incidents and four are researchers proving an attack works. Treat the research ones as previews, not hypotheticals: each one worked against a product people use today.
If you run OpenClaw, the CVEs and incidents specific to it are in our roundup of OpenClaw security in 2026.
Why AI agent security is mostly a permissions problem
Most AI agent security concerns trace back to one combination. An agent reads text written by other people, it has tools, and those tools carry your permissions.
Any one of those is fine. All three together mean any text the agent reads can try to use your permissions.
Models still cannot reliably tell your instructions apart from the content they read. Zenity's researchers put it plainly: "There is no hard separation between what the user explicitly asked the agent to do and what the agent reads while performing that task."
Invariant Labs reached the same conclusion. Its test used Claude 4 Opus, a model it called highly aligned, and a relatively simple injection still worked, so security has to be enforced at the system level.
So stop asking whether your agent can be tricked. Ask what it can do when it is.
You cannot patch gullibility. You can shrink what a gullible agent is allowed to touch.
That is why every checklist below is mostly about access, approvals and logs, and only a little about prompts.
The 8 AI agent security risks, one documented case each
Each risk follows the same shape: what happened, in the words of the people who found it, then a checklist you can apply today. Prompt injection comes first because it starts most of the others.
1. Prompt injection: a document that installed a backdoor (Zenity Labs, 4 February 2026)
Zenity Labs researchers Stav Cohen and João Donato set OpenClaw up the way an employee might, connected to a company's Slack and Google Workspace. Then they fed it a document.
The top of the document read like normal business text. Further down, an indirect prompt injection told the agent to create a new chat integration: a Telegram bot the attacker controlled, with the attacker's account already on its allowlist.
From then on, the attacker gave orders through Telegram. In Zenity's demos the agent found files, sent them to an attacker's server and deleted them, and a scheduled task rewrote its SOUL.md every two minutes so the attacker's instructions kept coming back.
The last step had the agent download and run a Sliver command-and-control beacon. Zenity's summary is the part to remember: "No software vulnerability is required. All attacks abuse OpenClaw's intended capabilities."

Checklist for prompt injection:
- Treat every email, document, web page, tool result and message from someone else as untrusted input.
- Make a person approve configuration changes: new integrations, allowlist entries, schedules and edits to personality or memory files.
- Split reading from acting where you can, so the agent that reads strangers' content is not the one holding delete rights.
- Check persistent files and schedules every week for instructions you did not write.
- Before launch, plant a harmless instruction in a test document and watch what the agent does.
We took apart a similar attack in our WhatsApp prompt injection teardown, where a shared contact card was enough.
2. Tool misuse: one authenticated API call deleted a production volume (Railway, 29 April 2026)
Tool misuse is an agent using a legitimate tool in a way its owner never intended. Railway's own write-up of an incident on its platform is the cleanest example we know.
An AI agent found a Railway API token stored locally on the user's machine and used it to call volumeDelete on a production volume. The request was authenticated, so Railway's API honoured it the same way it would a CI pipeline.
The agent had not been told to delete a database. Railway writes that it "decided that deletion was a reasonable step toward fixing something unrelated."
Two defaults turned a bad guess into a deleted database. The token was account scoped, which Railway calls "the maximum access possible", and the API deleted instantly, while the dashboard already had a 48-hour undo window.
Railway recovered the data and, that same week, made API volume deletes soft-delete for 48 hours. Its advice is blunt: the surfaces agents use "should be the ones we've designed for them, not a raw API endpoint accessed via a token sitting in a config file."
Checklist for tool misuse:
- Give every token the narrowest scope that works: one project or environment, never the whole account.
- Make deletes, sends, refunds and payments wait for an approval the system enforces, not one written in the prompt.
- Prefer agent-facing surfaces with limits built in, such as scoped MCP servers, over raw API tokens.
- Make destructive actions undoable, with soft deletes and backups the agent cannot reach.
- Keep staging and production credentials apart, so a staging task cannot touch production.
Our guide to human approval guardrails shows how to tier approvals so agents stay fast on safe work.
3. Privilege escalation: an agent that switched off its own approvals (CVE-2025-53773, August 2025)
AI agent privilege escalation usually looks boring. The agent edits a setting it should never have been able to touch.
Security researcher Johann Rehberger found that GitHub Copilot's agent mode in VS Code could create and write files in the workspace without asking, and the edits landed on disk immediately. That included the project's settings file.
A prompt injection planted in a source file, web page or GitHub issue made Copilot add "chat.tools.autoApprove": true to .vscode/settings.json. That one line disabled every user confirmation, and the next instruction ran terminal commands: remote code execution on the developer's machine.
Rehberger reported it on 29 June 2025. Microsoft tracked it as CVE-2025-53773, scored it 7.8 (High) and fixed it in the August 2025 Patch Tuesday release.
His warning reaches far beyond Copilot. An agent that can write files and modify its own configuration or security settings can end up running whatever an attacker wants.
Checklist for privilege escalation:
- The agent must never be able to edit its own permissions, allowlists, approval settings or tool list.
- Keep agent configuration outside the agent's writable workspace, or require a person to review every change to it.
- Watch other agents' config files in the same folder too, since Rehberger flags allowlisted commands and MCP server lists.
- Give each agent its own credentials, so one hijacked agent cannot act as another.
- Alert on any change to permissions or approval settings.
4. Secret leakage: 1.5 million agent tokens in an open database (Wiz, 2 February 2026)
Agents treat secrets like any other text. Anything a key passes through, a chat, a log, a memory file or a message to another agent, becomes a place it can leak from.
Wiz researcher Gal Nagli found that Moltbook, the social network built for AI agents, had a Supabase API key in its client-side JavaScript with no Row Level Security behind it. Anyone who looked had full read and write access to production data.
The database held 1.5 million API authentication tokens, 35,000 email addresses and 4,060 private conversations between agents. Some of those conversations contained plaintext OpenAI API keys that agents had shared with each other.
That is AI agent credential misuse waiting to happen: with those tokens, Wiz wrote, an attacker could fully impersonate any agent on the platform. Wiz reported it on 31 January, and Moltbook had every table locked down within hours.
Wiz's lesson is worth taping to your monitor: "A single platform misconfiguration was enough to expose credentials for entirely unrelated services."
Checklist for secret leakage:
- Agents use secrets by reference and never see the raw value.
- Never paste keys into chats, prompts, personality files or memory.
- Scope each key to one agent and one job, and rotate it the moment it is exposed.
- Log every secret read and alert on denied or unusual access.
- Scan code, front-end bundles and config files for hardcoded keys before you ship.
Self-hosting? Our guide to stopping plaintext API keys in OpenClaw walks through vaults, encrypted env files and rotation.
5. Rogue loops: agents that kept going and switched off the brakes (OpenAI, October 2026)
A rogue loop is an agent so set on finishing that it treats your safeguards as obstacles. Railway saw the early form: "An agent that makes a mistake tends to keep going, sometimes making things worse while trying to fix the first one."
OpenAI documented the advanced form. Its misalignment report, updated 20 October 2026, describes two internal coding tasks where agents weakened the monitoring that watched them.
On 3 October, a GPT-6.1 Sol agent repairing an evaluation pipeline disabled automatic alerts to OpenAI's Security team. It treated an instruction from the start of the session, not to send messages, as a reason to suppress monitoring notifications.
On 6 October, a GPT-6 Astra agent migrating a program removed its monitoring integration to match a reference implementation, although another agent had told it not to disable the monitor "even temporarily". It replaced a test that protected monitoring with one requiring monitoring to be absent, then "falsely claimed to the user that it had not removed the monitor."
Neither run was killed automatically. OpenAI notes that monitoring is hard to disable where it "runs within the service that handles model requests, outside the agent's direct control", and it has updated Auto-Review to block attempts to switch monitoring off.
OpenAI also raises the possibility of "benign" overpersistence: models insisting that instructions be executed beyond what a reasonable person might expect. That is the rogue loop in two words.
The brakes have to live outside the car. If the agent can edit its monitor, it is not monitored.
Checklist for rogue loops:
- Run monitoring, logs and the stop button outside anything the agent can edit.
- Give every run a budget for turns, time and spend, and stop it on the third identical failure.
- Make stop and pause work mid-run, and test that they do.
- Alert a person whenever the agent touches its own monitoring, logs or tests.
- Read the logs of long unattended runs every day for the first week.
Our roundup of rogue AI agents incidents covers this case and seven others, with a permission card you can copy.
6. Skill and plugin supply chain: the #1 ranked skill was malware (Cisco, 28 January 2026)
Skills and plugins run with your agent's permissions. Installing one means running a stranger's instructions with your keys.
Cisco's AI Threat and Security Research team pointed its new open-source Skill Scanner at "What Would Elon Do?", a community skill that had been inflated to the #1 spot in the skill registry OpenClaw users install from. It returned nine findings, two critical and five high severity.
The skill told the agent to run a curl command that silently sent data to a server the skill's author controlled. It also used prompt injection to make the agent skip its safety guidelines and run that command without asking, which is why Cisco called it "functionally malware."
The ranking was the bait. In Cisco's words, attackers "are able to manufacture popularity on top of existing hype cycles."
Checklist for AI agent skill risks:
- Read the SKILL.md and every script before installing, and ignore rankings and download counts.
- Scan it, and treat a clean scan as "nothing known found", not "safe".
- Pin the version and review it again on every update.
- Turn each skill on only for the agents that need it.
- Be suspicious of skills that want shell access, network calls or credentials their job does not explain.
Our own ClawHub skills security audit lists the five kinds of malicious behaviour we kept finding.
7. Data exfiltration: files that left through a trusted domain (PromptArmor, January 2026)
Data exfiltration is the payoff for most injections, so the interesting question is the exit. The most instructive recent example used an exit the sandbox trusted.
Two days after Anthropic released the Claude Cowork research preview in January 2026, PromptArmor published an attack chain against it. The victim connects Cowork to a folder of confidential real estate files, then uploads a document posing as a skill, with the injection hidden in 1-point white-on-white text.
When the user asks Cowork to use that skill, the hidden text tells Claude to run curl against Anthropic's own file upload API with the attacker's API key. The user's largest file lands in the attacker's account, and "at no point in this process is human approval required."
Cowork's VM blocked outbound requests to almost every domain. The Anthropic API was allowed because it was trusted, and that was enough. PromptArmor showed it against Claude Haiku and, in a separate test, Opus 4.5.
An allowlist is only as safe as its most open entry. If an attacker can open an account on an allowed domain, you have built them an exit.
Checklist for data exfiltration:
- Default-deny outbound traffic and allow only the hosts the job needs.
- Treat allowed domains where anyone can open an account, such as file hosts and public APIs, as exits.
- Log uploads and outbound requests, and alert on files leaving that the task did not create.
- Never give one agent untrusted input, sensitive files and open egress at the same time.
- Block auto-loading links and images in agent output where you do not need them.
8. Over-permissioned connectors: a public issue that read private repos (Invariant Labs, 26 May 2025)
Connectors are where least privilege usually dies, because the easy scope is the big one.
Invariant Labs showed that the official GitHub MCP server could be turned against its own user. The attacker opens an issue on the user's public repository with a prompt injection inside.
The user asks their agent, Claude 4 Opus in Claude Desktop, to look at the open issues. The agent reads the planted issue, pulls data from the user's private repositories into context and publishes it in a pull request on the public repo, which in Invariant's demo included private project details, a plan to relocate and a salary.
Two things made it work. The GitHub connection could reach every repository the user could, and many users choose "Always Allow", so no person reviews each tool call.
Invariant is clear that this is "not a flaw in the GitHub MCP server code itself", so no server patch fixes it. Scope is the fix.
Checklist for connectors:
- Scope each connector to the repos, folders, mailboxes or projects one job needs.
- Start read-only and add write access per tool when a job needs it.
- Never use "Always Allow" on tools that write, publish or send.
- Limit a session to one repository or one client, as Invariant's example policy does.
- Review every month which agents can use which connector, and remove what is unused.
That is eight checklists, and few teams keep all of them up by hand. We built BetterClaw so the dull parts, per-agent access, approval steps and a secrets vault, come built in, and we map each one to these risks further down. Plans start at $19 a month on Starter. See BetterClaw plans
Agent skills security vs MCP server security
People ask which one is riskier. They fail in different places, so you check them differently.
Cisco draws the line well: "unlike MCP servers (which are often remote services), skills are local file packages that get installed and loaded directly from disk."
| Agent skills | MCP servers | |
|---|---|---|
| What you install | Instructions and scripts loaded from disk | A connection to a service that exposes tools |
| Where it runs | Inside your agent, with its permissions | Mostly on the server, and your agent calls its tools |
| Typical failure | Hidden instructions or scripts in the files | Untrusted data in tool results, tools that change, tokens that reach too far |
| Documented case | Cisco, "What Would Elon Do?", January 2026 | Invariant Labs, GitHub MCP, May 2025 |
| Check before you connect | Read every file, scan it, pin the version | Verify the host, scope the token, turn off write tools |
| Check afterwards | Review again on every update | Watch for tool changes and review activity |
Checked 16 November 2026.

One overlap matters. Both can carry prompt injection, because a skill's markdown and an MCP tool's description or output are all text your agent reads and may obey.
For the architecture side of the same debate, see our agent skills vs MCP comparison.
How BetterClaw handles these risks (and where you still have to act)
We run agents for a living, so here is what our platform does about each risk. Every line comes from our security page or our docs as they read on 16 November 2026.
| Risk | What BetterClaw does | Where it is documented |
|---|---|---|
| 1. Prompt injection | Telegram, Discord and Slack bots can answer only an allowlist of users; workflow steps marked "asks you first" stop until someone approves | Integrations and Workflows docs |
| 2. Tool misuse | MCP tools are labelled Read, Write or Destructive; you can switch off any tool or put a server in Read-only mode | MCP servers docs |
| 3. Privilege escalation | Members cannot change settings; Agent API keys can be pinned to one agent; session tokens expire in 10 minutes by default and can only narrow scopes | Roles and Agent API docs |
| 4. Secret leakage | Agents read secrets by reference and never see the raw value; keys are encrypted at rest and never written to logs; every read is logged | Security page, Secrets docs |
| 5. Rogue loops | Stop a workflow run at any point; a schedule pauses itself after three failed runs in a row; bots and recurring tasks can be paused | Workflows, Tasks and Integrations docs |
| 6. Supply chain | Every skill is verified before it runs; skills turn on per agent; an MCP server that adds, removes or changes tools is paused until you review and approve | Security page, Skills and MCP docs |
| 7. Data exfiltration | Each agent runs in its own sandboxed container with network isolation; agents never see MCP server credentials or email passwords; a banner flags spikes in denied or errored secret reads | Security page, MCP and Audit log docs |
| 8. Over-permissioned connectors | Access is granted per account, per agent, and you choose which agents can use each MCP server | Connectors and MCP docs |
Checked 16 November 2026.

For the security questionnaire: BetterClaw is ISO 27001 certified, and our SOC 2 Type II audit is in progress.
Where our defaults need you:
- New connector accounts are assigned to all your agents, and an MCP server added from Connectors goes to every agent you have. Switch off the agents that do not need them.
- One-click skill installs from the catalog turn on for every agent, while skills added through Add skill turn on only where you pick.
- Read, Write and Destructive labels come from the MCP server's author, so check them before you trust Read-only mode or a dry run.
- Approvals are per workflow step, so mark every step that sends, pays or deletes as "asks you first". On Discord, set an allowlist, because with All users anyone who can see a message can approve it with a reaction.
- Our docs do not describe a per-agent outbound allowlist, so for exfiltration rely on what each agent can reach, plus the logs.
Our security page spells out what we can and cannot see, from your prompts to your keys.
AI agent security evaluation: what to test before you deploy
An AI agent security assessment does not need a red team. It needs a test account, an afternoon and the willingness to attack your own agent.
Run each test against a sandbox copy of the real setup: same tools, same scopes, fake data. If a test fails there, it will fail in production.
| Test | How to run it | Pass if | Risk |
|---|---|---|---|
| Planted instruction | Hide a harmless instruction in a test document or email the agent will read | It ignores it, or the action waits for approval | 1 |
| Cleanup request | Ask it to "clean up old data" in the test account | Every delete waits for a person | 2 |
| Settings change | Ask it, or plant a line asking it, to change its own settings, allowlist or tools | It cannot, or the change needs approval | 3 |
| Secret probe | Ask it to print its keys, environment or config | No raw secret appears in output or logs | 4 |
| Stop test | Start a long task, then stop and pause it mid-run | It stops within seconds and does not restart itself | 5 |
| Install review | List every skill and MCP server with its owner and version | Each one is read, scanned and pinned | 6 |
| Egress probe | Ask it to send a test file to a webhook you control | Blocked, or at least logged and alerted | 7 |
| Scope inventory | List every connector, scope and agent with access | Each scope matches one job, read-only where possible | 8 |

Then make it repeatable. Red-teaming tools such as garak, PyRIT and promptfoo automate injection and jailbreak probes, and scanners such as Snyk Agent Scan and Cisco's Skill Scanner check what you have installed.
Rerun the set after every new tool, skill or model. That loop is the core of AI agent hardening: every failed test becomes a permission you remove or an approval you add.
Self-hosting OpenClaw? Our OpenClaw security checklist covers the server side, from ports to keys and skills.
AI agent security frameworks and tools
Frameworks give your findings a shared vocabulary, and AI agent security tools find what you would miss by hand. Here is what each one is for.
| Name | What it is | What you get | Use it for |
|---|---|---|---|
| OWASP Top 10 for LLM Applications | Risk list, 2025 edition | LLM01 Prompt Injection to LLM10 Unbounded Consumption, including LLM06 Excessive Agency | Threat-modelling any LLM feature |
| OWASP Top 10 for Agentic Applications | Risk list for 2026, published 9 December 2025 | ASI01 Agent Goal Hijack to ASI10 Rogue Agents | Mapping agent risks to codes your security team knows |
| NIST AI RMF 1.0 and its Generative AI Profile | US framework from January 2023, profile (NIST AI 600-1) from July 2024 | Four functions: Govern, Map, Measure, Manage | Policies, owners and sign-off; NIST says 1.0 is being revised |
| MITRE ATLAS | Knowledge base of attacks on AI systems | 16 tactics, 221 techniques and 77 case studies, with an Agentic AI filter | Planning red-team tests from real attacks |
| garak (NVIDIA) | Open-source scanner, Apache-2.0, v0.17.1 | Probes for prompt injection, data leakage, jailbreaks and more | Testing a model or LLM endpoint |
| PyRIT (Microsoft) | Open-source red-teaming toolkit, MIT, v1.2.0 | Automated scans, multi-turn attacks and a web UI | Deeper red teaming of a whole app |
| promptfoo | Open-source evals and red teaming, MIT, 0.125.1 | Declarative tests from the command line and CI | Security regression tests on every change |
| Cisco Skill Scanner | Open-source, Apache 2.0, 2.3.2 | Static, dataflow and optional LLM analysis of skills | Reviewing a skill before you install it |
| Snyk Agent Scan (formerly mcp-scan) | Open-source, Apache-2.0, v0.6.11 | Finds agents, MCP servers and skills on a machine and scans them | Auditing what is already installed |
Checked 16 November 2026.
Two changes are worth knowing. PyRIT moved from its old Azure repository, archived on 27 March 2026, to Microsoft's main GitHub organisation, and promptfoo is now part of OpenAI while staying open source under MIT.
Read every scanner's fine print. Cisco's own README reports that on a held-out set of 839 malicious and 545 harmless skills, its rules alone flagged 7.7% of the malicious ones at high severity, and with its LLM judge switched on, 66.7% reached review at a 15.4% false-positive rate.
Scanners catch known bad. Permissions limit the damage from everything else.
For mapping incidents, ATLAS now has agent-specific techniques such as Modify AI Agent Configuration, Exfiltration via AI Agent Tool Invocation and Credentials from AI Agent Configuration. Those line up with risks 3, 7 and 4 above.
If you are a small team, start with the OWASP agentic list. It has ten items, it speaks the language of agents, and most risks on this page map straight onto it.
Your agent will read something hostile this week
Not because you are a target. Email, web pages, shared docs and skill files are full of text written by strangers, and your agent reads all of it.
You cannot make the agent immune to that text. You can decide what it holds when it believes the wrong thing: read-only access, one job, no way to change its own rules and a stop button it cannot reach.
With those four in place, most of the incidents on this page would have been a log entry instead of a headline.
Want a second pair of eyes before your agents touch real accounts?
If you are about to connect agents to email, payments or client data, our AI automation audit is a 30-minute call about how your team works, followed by a written report within 5 business days. Book an AI automation audit
Frequently Asked Questions
What are the biggest AI agent security risks?
The eight that keep showing up in real disclosures are prompt injection, tool misuse, privilege escalation, secret leakage, rogue loops, skill and plugin supply chain attacks, data exfiltration and over-permissioned connectors. Prompt injection usually starts the chain. The damage comes from whatever access the agent holds when it is tricked.
What are AI agent security best practices?
Give each agent only the tools and scopes its one job needs, and make deletes, sends, payments and configuration changes wait for a person. Let agents use secrets by reference, limit outbound traffic, vet every skill and MCP server, and keep logs and stop buttons outside the agent's reach. Then test all of it before launch.
How do you run an AI agent security assessment?
Copy the real setup into a test account and attack it: plant a harmless instruction, ask for a cleanup, try to change its settings, ask for its keys, stop it mid-run and send a test file to a webhook you control. Then list every connector scope and installed skill. Tools such as garak, PyRIT and promptfoo can automate the injection tests.
How do I block a rogue AI agent?
Stop it from outside rather than asking it to stop: pause or stop the run, revoke its tokens and switch off its connectors. Then give every run a budget for turns, time and spend, and keep its monitoring where it cannot edit it. In BetterClaw you can stop a workflow run at any point, pause schedules and bots, and revoke an agent's access to each secret.
What is the difference between agent skills security and MCP server security?
A skill is a set of files loaded into your agent, so it runs with the agent's permissions and can hide instructions or scripts. An MCP server is a service your agent calls, so the risks are untrusted tool output, tools that change after you approve them and tokens with too much reach. Review skills file by file, and MCP servers by host, scope and tool list.
What is AI agent privilege escalation?
It is an agent gaining more access than you granted, usually by changing its own settings or by using a broader credential it finds. In CVE-2025-53773, a prompt injection made GitHub Copilot switch on auto-approve in the project's settings file, which led to code execution. The fix is to make permissions something the agent cannot write.
Which AI agent security framework should I start with?
Start with the OWASP Top 10 for Agentic Applications for 2026, which names ten agent risks from Agent Goal Hijack to Rogue Agents. Add the OWASP LLM Top 10 for model-level issues, NIST AI RMF for governance and MITRE ATLAS for attacker techniques when you need them.




