Artificial intelligence is moving beyond chatbots and content generation.
Organizations are increasingly deploying AI agents that can read documents, access databases, call APIs, interact with applications, execute workflows, use external tools and make decisions with limited human intervention.
That additional capability creates a new cybersecurity challenge.
An AI agent is not simply another application input. It can become an active participant in an organization's technology environment.
If an agent has access to sensitive data, APIs, cloud resources, business applications or external tools, compromising the agent or manipulating its instructions can potentially turn an AI security weakness into an application, API, identity or infrastructure security problem.
This is why AI agent security has become an important part of modern application security.
NIST's 2026 analysis of AI-agent security found broad agreement that AI agents introduce novel security threats and that traditional cybersecurity practices need to be adapted to address agent-specific risks.
OWASP's dedicated AI Agent Security Cheat Sheet identifies risks including prompt injection, tool abuse, privilege escalation, data exfiltration, memory poisoning, excessive autonomy, supply-chain attacks and sensitive-data exposure.
This guide explains what AI agent security means, why AI agents create a different attack surface, the major risks businesses should understand, how to test AI applications and agents, and how organizations can build a practical AI security program in 2026.
Table of Contents
- What Is AI Agent Security?
- What Is an AI Agent?
- Why AI Agents Create a New Attack Surface
- AI Agent Security vs Traditional Application Security
- Top AI Agent Security Risks in 2026
- Prompt Injection and Indirect Prompt Injection
- Excessive Agency and Excessive Permissions
- AI Agent and API Security
- MCP Security
- Sensitive Data Exposure
- Memory and Context Security
- AI Supply Chain Security
- AI Agent Security Testing
- AI Penetration Testing
- AI Red Teaming
- Vulnerability Scanning vs AI Security Testing
- AI Agent Security Checklist
- How to Secure AI Agents
- AI Security Throughout the SDLC
- When Should Businesses Perform AI Security Testing?
- AI Agent Security for Different Industries
- How Nexoryn Can Help
- Frequently Asked Questions
- Conclusion
What Is AI Agent Security?
AI agent security is the practice of protecting AI-powered agents, their models, applications, data, tools, APIs, identities and workflows from unauthorized access, manipulation, abuse and unintended actions.
Traditional application security primarily focuses on protecting software from vulnerabilities such as:
- SQL injection
- Cross-site scripting
- broken authentication
- broken access control
- insecure APIs
- remote code execution
- security misconfiguration
- vulnerable dependencies
AI agents can still contain these traditional vulnerabilities.
However, they introduce additional security concerns because an agent can interpret instructions, process untrusted information, interact with tools and potentially take actions.
A simplified AI-agent architecture may look like this:
USER
|
v
AI APPLICATION
|
v
LLM
|
+-------------+-------------+
| | |
v v v
APIs Tools Memory
| | |
v v v
Databases SaaS Apps Knowledge Base
|
v
Cloud ResourcesEvery connection can potentially introduce another security boundary.
The objective of AI agent security is therefore not simply to make the model produce safe responses.
It is to make sure the entire system remains secure even when the model receives malicious, manipulated or unexpected input.
What Is an AI Agent?
An AI agent is a software system that can use an AI model to perform tasks, make decisions, interact with tools and execute actions toward a defined objective.
A conventional chatbot might:
Receive a question → generate an answer.
An AI agent might:
Receive a request → interpret the objective → retrieve information → call an API → modify data → verify the result → perform another action.
This difference is fundamental to security.
The more capabilities an agent has, the more important its security boundaries become.
Why AI Agents Create a New Attack Surface
AI agents can interact with many components simultaneously.
These may include:
- Large language models
- Web applications
- APIs
- Databases
- Cloud services
- SaaS platforms
- Email systems
- File storage
- Internal applications
- External websites
- RAG systems
- Vector databases
- MCP servers
- Plugins and tools
- Agent memory
This creates a dynamic attack surface.
Google Threat Intelligence reported in September 2026 that threat actors are increasingly moving from basic AI prompting toward agentic AI workflows and automation, including attacks involving AI-assisted operations and software supply chains.
The security question is therefore changing from:
"Can someone compromise this application?"
to:
"What can happen if an attacker manipulates the application, model, data, tool or agent into performing an unauthorized action?"
AI Agent Security vs Traditional Application Security
AI security does not replace traditional cybersecurity.
It expands it.
| Traditional Application Security | AI Agent Security |
|---|---|
| Authentication | Authentication + agent identity |
| Authorization | Authorization + tool permissions |
| Input validation | Input + contextual content validation |
| API security | API + agent-to-API security |
| Data protection | Data + model context protection |
| Application logic | Application + model-driven behavior |
| Session security | Session + memory security |
| Logging | Application + agent action logging |
| Vulnerability scanning | Scanning + AI-specific testing |
| Penetration testing | Application + AI attack-path testing |
A secure AI system therefore needs both traditional application security controls and AI-specific controls.
Top AI Agent Security Risks in 2026
The most important risks vary depending on the architecture and permissions of the system.
However, organizations should pay particular attention to:
- Prompt injection
- Indirect prompt injection
- Excessive agency
- Excessive permissions
- Tool abuse
- Sensitive data exposure
- Insecure APIs
- Memory poisoning
- Context manipulation
- Supply-chain vulnerabilities
- Malicious or compromised tools
- Insufficient monitoring
- Unauthorized actions
- Weak authentication and authorization
- Cost and resource abuse
OWASP's AI Agent Security guidance specifically highlights prompt injection, tool abuse, privilege escalation, data exfiltration, memory poisoning, goal hijacking, excessive autonomy, high-impact action abuse, cascading failures and supply-chain attacks among the risks organizations should consider.
1. Prompt Injection
Prompt injection occurs when malicious or unintended instructions influence an AI model's behavior.
OWASP identifies prompt injection as a major LLM application risk and distinguishes between direct and indirect prompt injection.
A simplified example:
User
|
v
AI Agent
|
v
Reads external document
|
v
Document contains malicious instruction
|
v
Agent interprets instruction
|
v
Agent calls a privileged toolThe security issue becomes much more serious when the agent has access to:
- Internal documents
- Databases
- Cloud systems
- Financial systems
- Administrative APIs
- Customer records
The potential impact depends heavily on what the agent is allowed to do.
2. Indirect Prompt Injection
Direct prompt injection comes from a user's input.
Indirect prompt injection can come from content the AI system retrieves or processes.
Examples include:
- Web pages
- PDFs
- Emails
- Documents
- Search results
- API responses
- Database records
- Knowledge bases
For example:
User:
"Summarize this document."
AI Agent:
Reads document
↓
Document contains hidden malicious instruction
↓
Agent interprets it as relevant context
↓
Agent behavior changesOWASP notes that indirect prompt injection can occur when external sources such as websites or files contain instructions that influence model behavior.
This is one reason organizations should treat external content as untrusted data, rather than automatically treating model-readable content as trusted instructions.
3. Excessive Agency
One of the most important concepts in AI agent security is agency.
An AI system becomes riskier when it can take high-impact actions without sufficient restrictions.
Consider an agent that can:
- Send emails
- Delete files
- Modify customer records
- Create accounts
- Access financial information
- Execute code
- Change cloud configurations
- Deploy software
The security principle should be:
Give the agent only the capabilities it actually needs.
OWASP recommends least-privilege controls and per-tool permission scoping for AI agents.
4. Excessive Permissions
An AI agent should not automatically receive the same privileges as a human administrator.
Instead, permissions should be scoped according to:
- User
- Agent
- Tool
- Action
- Resource
- Environment
- Risk level
For example:
Agent A
├── Read customer data ✓
├── Update customer data ✓
├── Delete customer data ✗
├── Access payroll ✗
└── Modify cloud resources ✗This limits the potential impact if the agent is manipulated.
5. AI Agent and API Security
APIs are one of the most important components of agentic systems.
An AI agent may communicate with:
- Internal APIs
- Payment APIs
- CRM APIs
- Cloud APIs
- Authentication APIs
- Search APIs
- Database APIs
- Third-party SaaS APIs
That means an AI security assessment should not stop at the model.
It should also evaluate the APIs that the agent can access.
Important controls include:
- Strong authentication
- Authorization
- Least privilege
- Rate limiting
- Input validation
- Output validation
- Secret management
- API monitoring
- Logging
- Abuse detection
A vulnerable API can become a high-impact path even when the underlying AI model is behaving as designed.
6. MCP Security
Model Context Protocol (MCP) is becoming an important part of the AI tooling ecosystem because it provides a standardized way for AI applications to connect to tools, data sources and services.
But connecting an AI agent to more tools also creates additional security boundaries.
OWASP's MCP security guidance identifies risks including:
- Tool poisoning
- Rug-pull attacks
- Tool shadowing
- Confused-deputy problems
- Excessive permissions
- Supply-chain attacks
- Data exfiltration
- Sandbox escapes
- Message tampering
- Prompt injection through tool responses
A secure MCP implementation should therefore consider:
- Server authenticity
- Tool permissions
- Package integrity
- OAuth scopes
- Tool descriptions
- Tool responses
- Logging
- Monitoring
- Dependency security
- Change detection
- Human approval for sensitive operations
7. Sensitive Data Exposure
AI systems may process highly sensitive information.
Examples include:
- Personally identifiable information
- Customer records
- Financial information
- Source code
- Credentials
- API keys
- Business documents
- Intellectual property
- Internal communications
Security teams should determine:
What data can the agent access?
What data can it retrieve?
What data can it send to external systems?
What data is stored in memory or logs?
Who can retrieve that information?
Data protection should be designed into the architecture rather than relying exclusively on the model to avoid exposing sensitive information.
8. Memory and Context Security
Many AI agents use memory to retain information between interactions.
Memory can improve functionality but creates another security boundary.
Potential concerns include:
- Cross-user data leakage
- Persistent malicious instructions
- Sensitive information retention
- Unauthorized memory modification
- Context poisoning
- Excessive retention
OWASP recommends validating and sanitizing information before storing it in agent memory and implementing isolation between users and sessions.
9. AI Supply Chain Security
Modern AI applications may depend on:
- Open-source models
- AI libraries
- Plugins
- MCP servers
- APIs
- Third-party datasets
- Vector databases
- Model providers
- Open-source packages
Every external dependency introduces additional supply-chain risk.
Security teams should evaluate:
- Package provenance
- Dependency vulnerabilities
- Model sources
- Third-party permissions
- Secrets
- Update mechanisms
- Integrity controls
- Vendor security
How to Test an AI Agent for Security
AI agent security testing should evaluate the complete application, not only the underlying model.
A practical assessment can include several layers.
Layer 1: Application Security Testing
Test:
- Authentication
- Authorization
- Sessions
- Input validation
- Access control
- File handling
- Business logic
- Security configuration
Layer 2: API Security Testing
Evaluate:
- API authentication
- Authorization
- Rate limiting
- Input validation
- Data exposure
- API abuse
- Broken object-level authorization
- API configuration
Layer 3: AI Security Testing
Evaluate:
- Prompt injection
- Indirect prompt injection
- Sensitive information disclosure
- Unsafe output handling
- Context manipulation
- System-prompt exposure
- Agent behavior
- Tool selection
- Tool permissions
Layer 4: Agent Security
Evaluate:
- Tool access
- Agent permissions
- Memory
- External content
- High-impact actions
- Human approval
- Agent-to-agent communication
- Logging
- Monitoring
Layer 5: Infrastructure Security
Evaluate:
- Cloud configuration
- IAM
- Secrets
- Containers
- Network segmentation
- Storage
- CI/CD
- Dependencies
This layered approach is important because an AI agent can be secure at the model layer but vulnerable at the application or infrastructure layer.
What Is AI Penetration Testing?
AI penetration testing is a security assessment that evaluates AI-powered applications and systems for exploitable weaknesses.
Depending on the scope, it may assess:
- AI applications
- LLM applications
- AI chatbots
- RAG applications
- AI agents
- AI APIs
- AI plugins
- MCP implementations
- AI-powered SaaS products
A professional AI penetration test should consider both traditional application vulnerabilities and AI-specific attack paths.
AI Red Teaming vs AI Penetration Testing
The terms are sometimes used interchangeably, but they can describe different scopes.
AI penetration testing
Generally focuses on identifying and validating technical vulnerabilities within a defined scope.
AI red teaming
Generally takes a broader adversarial approach and may evaluate whether an attacker can achieve specific objectives across multiple controls and attack paths.
A mature AI security program may use both.
Can DAST Test AI Applications?
Yes—but with an important qualification.
DAST (Dynamic Application Security Testing) can help identify conventional vulnerabilities in the exposed web application and API attack surface of an AI application.
For example:
- Injection vulnerabilities
- Authentication issues
- Authorization problems
- Security misconfiguration
- Exposed endpoints
- Common web vulnerabilities
However, DAST by itself should not be treated as a complete AI security assessment.
DAST may not fully evaluate:
- Prompt injection
- Model behavior
- Agent reasoning
- Tool misuse
- AI-specific data leakage
- Agent memory
- Excessive agency
This is why automated security scanning should complement—not replace—specialized AI security testing and penetration testing.
For organizations using continuous application security monitoring, Nexoryn Shield can fit into the broader security workflow by helping identify application-level vulnerabilities that should be investigated and remediated.
AI Agent Security Testing Checklist
Use this checklist as a starting point for evaluating an AI agent.
Identity & Access
Strong authentication implemented
Authorization enforced
Agent identity separated from human identities
Least-privilege access implemented
Short-lived credentials used where appropriate
AI Security
Direct prompt injection tested
Indirect prompt injection tested
Sensitive data disclosure tested
Output handling tested
System instructions protected
Untrusted content clearly separated
Tools & APIs
Tool permissions restricted
API authorization tested
Rate limits implemented
Tool responses treated as untrusted data
High-risk actions require approval
Secrets are not exposed to the model unnecessarily
Memory
Memory isolated between users
Sensitive data retention reviewed
Memory poisoning considered
Stored context validated
Retention limits implemented
Infrastructure
Cloud permissions reviewed
Dependencies scanned
Secrets protected
Network access restricted
Containers isolated where appropriate
CI/CD security controls implemented
Monitoring
Agent actions logged
Tool calls logged
Sensitive information protected in logs
Abnormal behavior monitored
Security alerts configured
Incident response procedures tested
How to Secure AI Agents
A secure AI-agent architecture should use multiple layers of defense.
1. Apply Least Privilege
Give each agent only the permissions necessary to perform its assigned task.
Do not give an AI agent administrator privileges simply because doing so is convenient.
2. Separate Instructions From Data
Treat external content as untrusted.
Documents, web pages, API responses and emails should not automatically be treated as trusted instructions.
3. Restrict Tool Access
Every tool should have clearly defined:
- Permissions
- Inputs
- Outputs
- Allowed resources
- Rate limits
- Authentication requirements
4. Require Human Approval for High-Risk Actions
For sensitive actions, introduce human approval.
Examples:
- Financial transactions
- Account deletion
- Privilege changes
- Production deployment
- Customer-data exports
- Security configuration changes
5. Validate Outputs
Do not assume that because an AI model generated something, the result is safe.
Validate outputs before they reach:
- Databases
- APIs
- Shell commands
- HTML
- SQL queries
- Financial systems
- Administrative functions
6. Monitor Agent Activity
Log:
- User
- Agent
- Tool
- Action
- Timestamp
- Resource
- Result
This creates an audit trail for investigation.
7. Test Continuously
Security should not be a one-time exercise.
Use a combination of:
Automated scanning + vulnerability management + manual testing + AI-specific security testing + penetration testing
AI Security Throughout the SDLC
AI security should begin before production.
Planning
↓
Threat Modeling
↓
Secure Development
↓
Automated Security Testing
↓
AI Security Testing
↓
Penetration Testing
↓
Deployment
↓
Continuous Monitoring
↓
RetestingThis approach helps organizations discover weaknesses earlier rather than waiting until an incident occurs.
When Should Businesses Perform AI Security Testing?
Consider security testing:
Before launching an AI application
Test the system before it becomes publicly accessible.
After major architectural changes
For example:
- New model
- New agent
- New API
- New tool
- New MCP integration
- New database
- New permissions
Before connecting sensitive systems
Additional testing is appropriate when an AI system receives access to:
- Customer data
- Financial systems
- Healthcare information
- Internal systems
- Production infrastructure
After a security incident
Retest the affected components and review the underlying attack path.
Continuously
Automated security scanning and monitoring can complement periodic manual assessments.
AI Agent Security for Different Industries
AI security requirements depend heavily on the organization's data and workflows.
Financial Services
Important areas include:
- Financial data
- Payment systems
- Fraud detection
- Customer accounts
- API security
- Regulatory requirements
Healthcare
AI systems may process:
- Patient information
- Medical records
- Diagnostic information
- Insurance data
Data protection and access controls are particularly important.
E-commerce
Security teams should consider:
- Customer accounts
- Payment workflows
- Order systems
- Inventory APIs
- Recommendation systems
- Customer-service agents
SaaS Companies
SaaS providers should consider:
- Multi-tenant isolation
- APIs
- Authentication
- Customer data
- AI agents
- Integrations
- Third-party tools
Enterprises
Enterprise AI deployments can connect to:
- ERP
- CRM
- HR
- Finance
- Cloud infrastructure
- Internal knowledge bases
The larger the permission footprint, the more important least privilege and monitoring become.
AI Agent Security: A Practical Security Architecture
A mature architecture can look like:
INTERNET
|
v
WAF / API GATEWAY
|
v
APPLICATION LAYER
|
v
AI AGENT LAYER
/ | \
/ | \
v v v
LLM TOOLS MEMORY
|
+---------+---------+
| | |
v v v
APIs SaaS Databases
|
v
CLOUD / INFRASTRUCTURE
SECURITY CONTROLS ACROSS ALL LAYERS
-----------------------------------
Identity
Least Privilege
Validation
Logging
Monitoring
Scanning
Penetration Testing
AI Security TestingThe goal is not to rely on a single AI security control.
It is to establish defense in depth.
How Nexoryn Can Help With AI and Application Security
AI applications require a combination of security technologies and human-led testing.
Nexoryn's broader security approach can address different parts of this lifecycle.
Application Security
Assess web applications, APIs and software for vulnerabilities that could affect AI-enabled systems.
Vulnerability Assessment
Identify weaknesses across applications and infrastructure and prioritize remediation.
Penetration Testing
Validate whether security weaknesses can be exploited and understand their potential impact.
AI Security Testing
Assess AI-enabled applications for AI-specific risks such as prompt injection, unsafe tool use and data exposure, where included within the agreed assessment scope.
Automated Security Scanning
Use automated scanning to continuously identify common application vulnerabilities and provide security visibility between manual assessments.
Nexoryn Shield
For organizations looking to continuously monitor application security, Nexoryn Shield can complement manual security assessments by providing automated application security scanning and vulnerability visibility.
Important: Automated scanning and AI security testing solve different problems. A scanner should not be positioned as a replacement for a specialized AI security assessment.
How to Build an AI Security Program in 2026
A practical roadmap is:
Phase 1 — Discover
Identify:
- AI applications
- Models
- Agents
- APIs
- Tools
- MCP servers
- Data sources
- External integrations
Phase 2 — Assess
Perform:
- Threat modeling
- Vulnerability assessment
- API security assessment
- AI risk assessment
- Configuration review
Phase 3 — Test
Combine:
- Automated scanning
- Manual security testing
- AI security testing
- Penetration testing
- Adversarial testing
Phase 4 — Remediate
Prioritize issues based on:
- Exploitability
- Business impact
- Data sensitivity
- Privilege level
- Exposure
- Likelihood of abuse
Phase 5 — Monitor
Continuously monitor:
- Agent behavior
- Tool calls
- APIs
- Authentication
- Vulnerabilities
- Dependencies
- Infrastructure
- Security events
AI Agent Security vs AI Governance
These concepts are related but different.
AI governance focuses on how organizations manage AI responsibly, including policies, risk, accountability and compliance.
AI security focuses specifically on protecting AI systems and their surrounding infrastructure against security threats and unauthorized actions.
A mature organization needs both.
What Businesses Should Ask Before Deploying an AI Agent
Before putting an AI agent into production, ask:
Access
What can the agent access?
Permissions
What can the agent change?
Data
What sensitive information can it read?
Tools
Which tools can it call?
APIs
Which APIs can it access?
Trust
Which external information can influence its behavior?
Monitoring
Can we see exactly what the agent did?
Recovery
Can we stop or reverse an unsafe action?
Testing
Has the complete system been security tested?
These questions are often more useful than simply asking whether the underlying AI model is secure.
AI Agent Security Best Practices: Quick Reference
| Security Area | Recommended Practice |
|---|---|
| Identity | Use strong, scoped identities |
| Permissions | Apply least privilege |
| APIs | Enforce authentication and authorization |
| Tools | Restrict tool capabilities |
| Data | Minimize sensitive data exposure |
| Prompt Injection | Treat external content as untrusted |
| Memory | Isolate and validate stored context |
| MCP | Verify servers, tools and permissions |
| Secrets | Keep credentials outside model context where possible |
| Monitoring | Log agent and tool activity |
| Testing | Combine automated and manual testing |
| High-risk actions | Require additional validation or approval |
| Dependencies | Monitor supply-chain risk |
| Incident Response | Prepare agent-specific response procedures |
Frequently Asked Questions About AI Agent Security
What is AI agent security?
AI agent security is the practice of protecting AI agents, models, applications, APIs, tools, data, identities and workflows against unauthorized access, manipulation, data exposure and unintended actions.
Why is AI agent security important?
AI agents can interact with applications, APIs, databases and external tools. If an attacker manipulates an agent or exploits a connected component, the impact can extend beyond the AI model itself.
What are the biggest AI agent security risks?
Major risks include prompt injection, indirect prompt injection, excessive permissions, tool abuse, sensitive-data exposure, memory poisoning, insecure APIs, supply-chain attacks and unauthorized agent actions.
What is prompt injection?
Prompt injection occurs when an attacker or untrusted content influences an AI model to behave contrary to the intended instructions or security boundaries.
Can prompt injection be completely prevented?
There is no single control that should be treated as a complete solution. OWASP recommends layered mitigations including constrained behavior, output validation, input and output filtering, privilege controls, human approval for high-risk actions and adversarial testing.
What is MCP security?
MCP security refers to protecting Model Context Protocol implementations and the AI applications, servers, tools, data and permissions connected through them.
OWASP identifies risks including tool poisoning, excessive permissions, confused-deputy problems, supply-chain attacks and prompt injection through tool responses.
What is AI penetration testing?
AI penetration testing is a security assessment designed to identify and validate vulnerabilities in AI-powered applications, agents, APIs and connected systems.
Depending on scope, it can include both traditional application vulnerabilities and AI-specific risks.
Can normal penetration testing secure an AI application?
Traditional penetration testing remains important, but an AI application may also require AI-specific testing for risks such as prompt injection, agent permissions, tool abuse, memory and AI-specific data exposure.
Can DAST replace AI security testing?
No.
DAST can identify many conventional web and API vulnerabilities, but it should not be considered a complete assessment of AI-specific risks such as prompt injection, agent behavior or excessive agency.
How often should AI agents be security tested?
Testing frequency should depend on risk, architecture and how frequently the system changes.
Testing should be considered before production, after major architectural or permission changes, after significant security incidents and as part of an ongoing security program.
How can I secure an AI agent?
Start with:
- Least-privilege access
- Strong authentication
- Restricted tools
- API security
- Input and output validation
- Protection of sensitive data
- Memory isolation
- Monitoring and logging
- Automated vulnerability scanning
- AI-specific security testing
- Penetration testing
- Human approval for high-impact actions
Final Thoughts
AI agents are changing how software interacts with people, data and infrastructure.
That creates significant opportunities for businesses—but it also changes the security model.
An AI agent that can access a database, call an API, retrieve documents or execute business workflows must be treated as part of the organization's security architecture.
The most effective approach is not to choose between AI security and traditional cybersecurity.
It is to combine them.
A mature AI security program should bring together:
Secure architecture
Identity and least privilege
API security
Application security
Automated vulnerability scanning
AI-specific security testing
Penetration testing
Continuous monitoring
NIST's 2026 analysis emphasizes that AI-agent security introduces new challenges while still relying on foundational cybersecurity practices.
OWASP similarly recommends controls around least privilege, prompt-injection defenses, memory security, tool security and monitoring.
As AI agents move from experiments into production systems, organizations should evaluate not only what the AI can generate, but also what the AI can access, what it can execute, what it can change and what happens if its instructions are manipulated.
That is the foundation of AI agent security.
Need an AI Security Assessment?
If your organization is developing or deploying an AI application, AI agent, RAG system, AI-powered SaaS platform or API-connected AI workflow, a security assessment can help identify weaknesses before they become production incidents.
Nexoryn Security can help organizations evaluate application, API and AI-related security risks through vulnerability assessment, penetration testing, security testing and automated application security monitoring.
Talk to Nexoryn Security about your AI security requirements →
Sources & Further Reading
- OWASP AI Agent Security Cheat Sheet — guidance covering agent-specific risks including prompt injection, tool abuse, excessive agency, memory poisoning and data exposure.
- OWASP LLM01:2025 Prompt Injection — guidance on direct and indirect prompt injection and mitigation strategies.
- OWASP MCP Security Cheat Sheet — security considerations for Model Context Protocol deployments.
- NIST: Security Considerations for AI Agents — 2026 analysis of AI-agent security risks and mitigation considerations.
- ISACA: Cybersecurity Recommendations for Securing AI Agents — 2026 practitioner guidance for securing AI agents.
- Google Threat Intelligence Group: From Prompting to Autonomy — 2026 analysis of adversarial AI and the shift toward agentic work
Comments
Post a Comment