The OWASP Top 10 for Agentic Applications lists ten risks, ASI01 to ASI10, for AI systems that plan and act with tools, memory and other agents. A static check of the code and config that builds an agent covers two of them well: what the agent's tools can do (ASI02) and model output that reaches a shell or eval (ASI05). It covers parts of goal hijack, identity and privilege abuse, and supply chain (ASI01, ASI03, ASI04). The other five need runtime testing, red-teaming and architecture review, and a scanner that claims more is stretching its mapping.
OWASP and tool facts checked on 21 Nov 2026. Skylos facts are for 5.7.0.
The OWASP GenAI Security Project published the list on 9 Dec 2025 as Version 2026 (download page, opened 21 Nov 2026). Each entry has a description, examples, attack scenarios and mitigations. Most of the mitigations are runtime and design controls: least agency, human approval for high-impact actions, sandboxes, signed messages, monitoring. This page goes through the list risk by risk and separates the part a code scan can reach from the part it cannot. Skylos, which we build, is one static tool. Where other tools cover what it does not, we name them.
Which OWASP agentic risks can a static check cover?
| ASI | Risk (OWASP name) | Static check of agent code | Skylos coverage at 5.7.0 | What else you need |
|---|---|---|---|---|
| ASI01 | Agent Goal Hijack | Partly: where untrusted text enters a prompt | skylos defend prompt checks. SKY-D261 (Python), SKY-D353 (AI agents in GitHub Actions), SKY-D260 and D266 (hidden instructions in committed files) | Red-teaming of every input channel, runtime intent checks, approval for goal-changing actions |
| ASI02 | Tool Misuse and Exploitation | Well: what each tool can reach | tool-scope, tool-schema-present, no-dangerous-sink. SKY-D264 (shell and REPL tools handed to agents), SKY-D212 | Per-tool runtime policy, egress allowlists, approval for destructive actions |
| ASI03 | Identity and Privilege Abuse | Partly: credentials in code and CI | tool-scope. Secrets (SKY-S101, L014), SKY-D244 (MCP), SKY-D350 and D351 (CI agents holding secrets or write tokens) | Identity design: per-agent identities, short-lived scoped tokens, delegation monitoring |
| ASI04 | Agentic Supply Chain Vulnerabilities | Partly: what is declared and pinned in the repo | model-pinned. Dependency advisories, SKY-D222, D367 to D369 (MCP configs), D240, D265. Agent hooks for coding agents | Signed tool definitions and prompts, runtime re-checks of what the agent loads |
| ASI05 | Unexpected Code Execution (RCE) | Well: model output reaching sinks in your code | no-dangerous-sink, output-validation, tool-scope. SKY-D262 (Python), D212, D265 | Sandboxes, no root, approval before running generated code |
| ASI06 | Memory & Context Poisoning | Little: prompt layout | Prompt and RAG layout checks. Nothing checks memory writes | Validation of memory writes, tenant isolation, provenance, cross-session tests |
| ASI07 | Insecure Inter-Agent Communication | Little | Nothing mapped. SKY-D241 and D243 cover MCP server transport (Python) | Mutual TLS, signed messages, anti-replay, attested agent registries |
| ASI08 | Cascading Failures | Little: missing bounds | Ops checks logging-present, cost-controls, rate-limiting (never gate). SKY-D267 | Circuit breakers, quotas, replay tests before widening permissions |
| ASI09 | Human-Agent Trust Exploitation | No | Mapped to output-validation. We count it as not covered | Confirmation design, provenance in the UI, human-factors testing |
| ASI10 | Rogue Agents | No, preconditions at most | Mapped to tool-scope and logging-present, which are preconditions | Behavioural monitoring, kill switches, credential revocation |
In short: two risks well, three in part, and five where a code scan reaches little or nothing. The rest of this page explains each row and shows the output behind it.
How does skylos defend map to ASI01 to ASI10?
skylos defend finds each LLM integration in Python and TypeScript/JavaScript source (provider SDK calls, agent frameworks, MCP servers and their tools) and runs 13 deterministic checks on it. It calls no model. With --owasp-framework agentic it reports each ASI ID as the share of its mapped checks that passed. The mapping lives in skylos/defend/owasp.py. Here it is at 5.7.0:
| ASI | Checks Skylos maps to it | Our note |
|---|---|---|
| ASI01 | untrusted-input-to-prompt, prompt-delimiter, input-length-limit, rag-context-isolation | Checks prompt construction, not whether the model follows injected text |
| ASI02 | tool-schema-present, tool-scope, no-dangerous-sink | The strongest fit |
| ASI03 | tool-scope | One check for a risk that is mostly about identity design |
| ASI04 | model-pinned, tool-schema-present | A typed tool schema says little about supply chain |
| ASI05 | no-dangerous-sink, output-validation, tool-scope | A strong fit for sinks in your own code |
| ASI06 | prompt-delimiter, untrusted-input-to-prompt, rag-context-isolation | Checks prompt layout, not memory contents |
| ASI07 | none | Not covered |
| ASI08 | logging-present, cost-controls, rate-limiting | Ops checks: scored apart and never gate CI |
| ASI09 | output-validation | A parser check does not tell you whether a person is misled |
| ASI10 | tool-scope, logging-present | Preconditions for containing a rogue agent, not detection |
Read the percentages with that in mind. A risk whose mapped checks all pass shows as fully covered, which does not mean the risk is handled. A risk with no applicable check is left out of the report.
What does a scan of a real agent show?
We built a small agent for this page and wrote known problems into it by hand:
support_bot/agent.py: a Flask endpoint that calls OpenAI with two tools,run_shellandread_file, runs whichever tool the model picks, then asks the model for a fix command and runs that too. The API key is hard-coded.support_bot/ops_agent.py: a LangChain agent givenShellTool()..mcp.json: a file-system MCP server started withnpx -yand given/..github/workflows/issue-triage.yml: a Gemini CLI agent that runs on every new issue, with the issue title and body pasted into its prompt.
import json
import subprocess
from flask import Flask, request
from openai import OpenAI
OPENAI_API_KEY = "sk-proj-MwzY..." # a 56-character fake key in the real file
client = OpenAI(api_key=OPENAI_API_KEY)
app = Flask(__name__)
def run_shell(command):
return subprocess.run(command, shell=True, capture_output=True, text=True).stdout
def read_file(path):
with open(path) as handle:
return handle.read()
TOOLS = [
{
"type": "function",
"function": {
"name": "run_shell",
"description": "Run a shell command on the support server",
"parameters": {
"type": "object",
"properties": {"command": {"type": "string"}},
},
},
},
# read_file is declared the same way, with a "path" string
]
HANDLERS = {"run_shell": run_shell, "read_file": read_file}
@app.post("/ask")
def ask():
question = request.json["question"]
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a support agent for our servers."},
{"role": "user", "content": f"Customer question: {question}"},
],
tools=TOOLS,
)
call = response.choices[0].message.tool_calls[0]
output = HANDLERS[call.function.name](**json.loads(call.function.arguments))
followup = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": f"Suggest one fix command for: {output}"}],
)
fix = followup.choices[0].message.content
subprocess.run(fix, shell=True)
return {"answer": fix}
support_bot/agent.py, shortened for the page: the key is cut and the second tool definition is replaced by a comment. Line numbers in the output below refer to the full file.
skylos defend against the agentic list:
$ skylos defend . --owasp-framework agentic
┌──────────────────────────────────────────────────────────────────────────┐
│ Skylos AI app safety report │
│ Scanned: 2 files | Found: 4 LLM integration(s) | Score: 26% (HIGH) │
├──────────────────────────────────────────────────────────────────────────┤
Integration 1: support_bot/agent.py:53
Weighted Score: 8/38 (21%) — CRITICAL RISK
✗ no-dangerous-sink Dangerous sink(s) detected in same scope as LLM call: subprocess.run (L69); Model
output reaches a dangerous sink one call hop away: tool-call arguments → run_shell() → subprocess.run (L14)
[-8]
✗ tool-scope Tools with unrestricted dangerous operations: run_shell: subprocess.run (L14)
[-8]
✗ output-validation Output validation uncertain: An unresolved call receives this value before the
result is used [-5]
✗ output-pii-filter No PII filtering on LLM output returned to users [-5]
✗ model-pinned Model uses floating alias 'gpt-4o' [-3]
✗ logging-present No logging detected around LLM call [-3]
✗ cost-controls No max_tokens set — unbounded token consumption [-3]
✗ rate-limiting No rate limiting on LLM endpoint [-3]
✗ input-length-limit Unbounded user input reaches LLM call [-1]
✓ tool-schema-present All 2 tool(s) have typed schemas [+8]
Integration 2: support_bot/agent.py:64
Weighted Score: 0/22 (0%) — CRITICAL RISK
✗ no-dangerous-sink Dangerous sink(s) detected in same scope as LLM call: subprocess.run (L69) [-8]
✗ output-validation Output used without proven validation: LLM output may reach subprocess.run
without a sink-specific guard [-5]
✗ output-pii-filter No PII filtering on LLM output returned to users [-5]
✗ model-pinned Model uses floating alias 'gpt-4o' [-3]
✗ logging-present No logging detected around LLM call [-3]
✗ cost-controls No max_tokens set — unbounded token consumption [-3]
✗ rate-limiting No rate limiting on LLM endpoint [-3]
✗ input-length-limit Unbounded user input reaches LLM call [-1]
Integration 3: support_bot/ops_agent.py:5
Weighted Score: 8/16 (50%) — MEDIUM RISK
✗ output-validation Output validation uncertain: A nested scope may read this captured value [-5]
✗ model-pinned Model uses floating alias 'gpt-4o' [-3]
✗ logging-present No logging detected around LLM call [-3]
✗ cost-controls No max_tokens set — unbounded token consumption [-3]
✓ no-dangerous-sink No dangerous sink detected in same scope as LLM call or reached by its output one
call hop away [+8]
Integration 4: support_bot/ops_agent.py:15
Weighted Score: 8/16 (50%) — MEDIUM RISK
✗ output-validation Output used without proven validation: Raw LLM output is used without validation
[-5]
✗ model-pinned No model parameter found in LLM call [-3]
✗ logging-present No logging detected around LLM call [-3]
✗ cost-controls No max_tokens set — unbounded token consumption [-3]
✓ no-dangerous-sink No dangerous sink detected in same scope as LLM call or reached by its output one
call hop away [+8]
──────────────────────────────────────────────────────────────────────────
Defense score: 26% (HIGH)
24/92 weighted points | 3/18 checks passing
AI Ops Score: 0% (POOR)
0/10 ops checks passing
OWASP Agentic Top 10 2026 Coverage:
✗ ASI01 Agent Goal Hijack 0% (0/2)
◐ ASI02 Tool Misuse and Exploitation 50% (3/6)
✗ ASI03 Identity and Privilege Abuse 0% (0/1)
◐ ASI04 Agentic Supply Chain Vulnerabilities 20% (1/5)
◐ ASI05 Unexpected Code Execution (RCE) 22% (2/9)
✗ ASI08 Cascading Failures 0% (0/10)
✗ ASI09 Human-Agent Trust Exploitation 0% (0/4)
✗ ASI10 Rogue Agents 0% (0/5)
Skylos 5.7.0, skylos defend . --owasp-framework agentic, scratch repository built for this page, run on 21 Nov 2026 with no API key. Output unedited apart from trailing spaces. Exit code 0: defend reports and does not gate unless asked. The same run with --fail-on critical exits 1.
What that run shows:
- It found the dangerous paths in the tool-calling agent.
tool-scopefailed onrun_shell, andno-dangerous-sinktraced model-written tool arguments intosubprocess.runone call away and found the second reply run in a shell at line 69. - A typed schema is not a narrow one.
tool-schema-presentpassed becausecommandis typed as a string. Any shell command is a string. - ASI06 and ASI07 are missing from the coverage list. No ASI06 check applied to this code, and nothing is mapped to ASI07.
- ASI01 shows 0/2, and both are
input-length-limit. The two checks that look at how the customer question enters the prompt did not run. We explain why in where Skylos falls short. - The LangChain agent shows up as a chat call with no tools.
defenddid not seeShellTool(). The full scan did.
The full scan, skylos . -a, reads the rest of the repository: the CI workflow, the MCP config, secrets and dependencies.
$ skylos . -a --format concise
support_bot/agent.py:14 SKY-D212 Possible command injection (subprocess shell=True): tainted input.
support_bot/agent.py:53 SKY-D267 Unbounded LLM consumption risk: no max token limit; no request timeout. Set token, timeout, and iteration limits before invoking the model.
support_bot/agent.py:64 SKY-D267 Unbounded LLM consumption risk: no max token limit; no request timeout. Set token, timeout, and iteration limits before invoking the model.
support_bot/agent.py:69 SKY-D262 LLM output flows into shell command execution without validation.
support_bot/ops_agent.py:7 SKY-D264 Agent is granted dangerous tool capability (shell execution tool); restrict tools to allowlisted, scoped functions and require human approval for mutating actions.
support_bot/ops_agent.py:7 SKY-D267 Unbounded LLM consumption risk: agent executor has no iteration or time cap. Set token, timeout, and iteration limits before invoking the model.
.github/workflows/issue-triage.yml:13 SKY-D350 issues (anyone who can open an issue) → run-gemini-cli (the prompt interpolates github.event.issue.title) with read-only tools (no GEMINI_CLI_TRUST_WORKSPACE, so settings and YOLO approval are off) and secrets GEMINI_API_KEY; issues: write. Nothing checks that the account starting job triage has write access (no author_association, actor or permission gate).
.github/workflows/issue-triage.yml:16 SKY-D353 github.event.issue.title is interpolated into run-gemini-cli input prompt on issues (anyone who can open an issue); text written by anyone who can trigger the workflow becomes part of the agent's instructions, and the agent has read-only tools (no GEMINI_CLI_TRUST_WORKSPACE, so settings and YOLO approval are off).
.github/workflows/issue-triage.yml:16 SKY-D353 github.event.issue.body is interpolated into run-gemini-cli input prompt on issues (anyone who can open an issue); text written by anyone who can trigger the workflow becomes part of the agent's instructions, and the agent has read-only tools (no GEMINI_CLI_TRUST_WORKSPACE, so settings and YOLO approval are off).
.mcp.json:3 SKY-D367 MCP server 'filesystem' is not pinned: npx -y @modelcontextprotocol/server-filesystem /. Each start fetches whatever @modelcontextprotocol/server-filesystem resolves to at that moment (npx); postmark-mcp shipped fifteen clean versions before 1.0.16 started copying every email to the attacker. Pin an exact, reviewed version (pkg@1.2.3, pkg==1.2.3, a full git commit or an image digest).
support_bot/agent.py:7 SKY-L014 Hardcoded credential in 'OPENAI_API_KEY'. Use environment variables or a secrets manager instead.
support_bot/agent.py:7 SKY-S101 High-entropy value detected (entropy=5.09)
requirements.txt:3 SKY-SCA-GHSA-3644-q5cj-c5c7 langchain@0.3.27: LangSmith SDK: Public prompt pull deserializes untrusted manifests without trust boundary warning
requirements.txt:3 SKY-SCA-GHSA-gr75-jv2w-4656 langchain@0.3.27: LangChain: Path traversal and sandbox escape in LangChain file-search middleware and loaders
requirements.txt:5 SKY-SCA-GHSA-r7w7-9xr2-qq2r langchain-openai@0.3.35: langchain-openai: Image token counting SSRF protection can be bypassed via DNS rebinding
Skylos 5.7.0, same repository and date. Trimmed to the lines this page discusses, in printed order. Left out: three dependency summary lines, shell=True (SKY-D209, twice), workflow pinning and token hygiene (SKY-D292, D293, D299), an unauthenticated POST route (SKY-F102), a Flask advisory, a whole-file read (SKY-P401), an unused function and four repository policy notes.
Two things neither command flagged: the read_file tool reads any path on the server, and the MCP server is given the whole file system (/). SKY-D367 is about the unpinned version, not about /.
What can a code check find for each risk?
Each entry: the risk in one sentence, what a scan of the agent's code can find, what Skylos 5.7.0 checks, and what it takes beyond code.
ASI01: Agent Goal Hijack
The risk. Text an attacker controls, in a prompt, a document, a web page, a tool result or another agent's message, changes what the agent is trying to do. OWASP's reason is that agents "cannot reliably distinguish instructions from related content".
What a code check can find. Where untrusted input is formatted into a prompt with no separation, where issue or pull request text is pasted into a CI agent's prompt, and hidden instructions in prompt templates and agent instruction files committed to the repository. It cannot tell whether the model will follow injected text. Most injected text arrives at runtime, in content the repository never sees.
Skylos 5.7.0. skylos defend maps untrusted-input-to-prompt, prompt-delimiter, input-length-limit and rag-context-isolation here. The full scan adds SKY-D261 (Python: request data in a prompt without an instruction and data boundary), SKY-D353 (untrusted issue, comment or pull request text interpolated into an AI agent's prompt in GitHub Actions) and SKY-D260 and SKY-D266 (hidden or instruction-override text in prompt, config and agent instruction files). In our run, D353 fired on both interpolated fields. Neither defend nor D261 reported the customer question in agent.py. For workflows in general, zizmor's template-injection audit finds ${{ }} expansions that can become code. Its audit list has no audit aimed at AI agents (checked 21 Nov 2026).
Beyond code. Red-team every input channel with injected content, check intent before goal-changing actions, require approval for high-impact actions, and log goal state so drift shows. promptfoo has an owasp:agentic:asi01 red-team plugin that sends attacks to your running agent. LlamaFirewall runs at runtime: its docs describe PromptGuard 2 for injection attempts in inputs and AlignmentCheck, which audits the agent's reasoning for goal hijacking.
ASI02: Tool Misuse and Exploitation
The risk. The agent uses a tool it is allowed to use in a harmful way: it deletes data, sends mail, calls a costly API in a loop or sends data out.
What a code check can find. What each tool's handler can reach (a shell, eval, file deletion, any path, any URL), model-written arguments that reach a shell or SQL call, agents handed a shell, REPL or code-interpreter tool, and tools without typed schemas. Tools are code, so this is the part of the list a scanner reads most directly.
Skylos 5.7.0. defend maps tool-scope, tool-schema-present and no-dangerous-sink. The full scan adds SKY-D264 (Python: LangChain ShellTool and PythonREPLTool, load_tools with terminal or requests_all, OpenAI code_interpreter and computer_use_preview tools, a Tool wrapping subprocess.run) and SKY-D212 (command injection). In our run all four reported the shell paths. Nothing reported read_file or the MCP server given /.
Beyond code. Least privilege per tool at runtime (scopes, rate limits, egress allowlists), a policy check on arguments before each call, approval for destructive actions, and monitoring for unusual tool chains. OWASP's examples include data sent out through repeated calls to an auto-approved ping tool, which is about how tools are used, not how they are written. promptfoo lists its excessive-agency, mcp and tool-discovery plugins under ASI02.
ASI03: Identity and Privilege Abuse
The risk. The agent acts with credentials or permissions it inherited, cached or was handed by another agent, beyond what the task needs.
What a code check can find. Keys hard-coded in agent code or MCP tool parameters, and CI jobs that hand an AI agent secrets or a write token on events anyone can trigger. Whether an OAuth scope or cloud role is too broad usually lives in an identity provider or cloud console, outside the repository.
Skylos 5.7.0. defend maps tool-scope here. The full scan adds secrets (SKY-S101, SKY-L014), SKY-D244 (hard-coded secrets in MCP tool parameters, Python), SKY-D350 (an AI agent in GitHub Actions started by an untrusted event, holding secrets or a write token, with no check on who started it) and SKY-D351 (the agent action's own write-access check widened with *). In our run: S101 and L014 on the key, and D350 on the triage workflow, which anyone who can open an issue can start while it holds GEMINI_API_KEY and issues: write.
Beyond code. Per-agent identities, short-lived task-scoped tokens, re-authorisation on each privileged step, and monitoring of delegation chains. This is an identity design review. promptfoo lists rbac, bfla, bola and imitation plugins under ASI03.
ASI04: Agentic Supply Chain Vulnerabilities
The risk. A model, tool, MCP server, prompt template, package or peer agent from a third party is malicious or is swapped, often while the agent runs.
What a code check can find. Dependencies with known advisories, packages that do not exist, MCP servers started without an exact version, floating model aliases, pickle-based model loading and hidden instructions in committed prompt files. Anything the agent discovers at runtime (a tool registry, an agent card, a remote prompt) is not in the repository to scan.
Skylos 5.7.0. defend maps model-pinned and tool-schema-present. The full scan adds dependency advisories from OSV, SKY-D222 (imports and manifest entries for packages that do not exist), SKY-D367 to SKY-D369 (MCP servers not pinned, started from a hidden home or temp path, or imitating a vendor), SKY-D240 (tool description poisoning in Python MCP servers), SKY-D265 (pickle-backed model loading) and SKY-D260. If the agent is your coding agent, skylos agent install-hooks blocks installs of packages that do not exist, versions reported as malware, too-new releases and unpinned MCP servers. In our run: D367 on .mcp.json, advisories on the langchain and langchain-openai pins, and model-pinned failed on gpt-4o.
Beyond code. Signed and attested tool definitions and prompts, an inventory of AI components, runtime re-checks of what was loaded, and a way to switch off a bad tool everywhere. Snyk Agent Scan (the old invariantlabs-ai/mcp-scan repository redirects there) connects to the MCP servers configured on a machine and checks their tool descriptions for injected instructions and tool poisoning. Its README says it sends tool names, descriptions and configs to Snyk's API and needs a SNYK_TOKEN.
ASI05: Unexpected Code Execution (RCE)
The risk. Text becomes code: model output or a chain of tool calls reaches a shell, eval, a deserializer or a code runner.
What a code check can find. Model output flowing into subprocess, eval, exec, SQL or pickle in the agent's own code. This is taint analysis with the model as the source. It cannot judge code the agent writes and runs later in a sandbox you gave it on purpose.
Skylos 5.7.0. defend maps no-dangerous-sink, output-validation and tool-scope. The full scan adds SKY-D262 (Python: model output into code execution, shell, SQL or network calls without validation), SKY-D212 and SKY-D265. In our run, D262 flagged line 69, where the second reply runs with shell=True, and no-dangerous-sink failed both OpenAI calls. General SAST tools help with the sink: Bandit's B602 flags shell=True whatever the input, and CodeQL's py/command-line-injection follows user input to a command. Whether a tool treats model output as untrusted depends on its list of sources.
Beyond code. Sandboxes with no root and limited network, approval before generated code runs, a reviewed allowlist for auto-run commands, and runtime monitoring. OWASP names mcp-run-python as one sandbox option. LlamaFirewall's CodeShield scans generated code at runtime.
ASI06: Memory & Context Poisoning
The risk. Bad data written into memory, summaries or a RAG store steers later sessions, for the same user or others.
What a code check can find. Little. A scan can check that retrieved context sits apart from instructions in the prompt, and could check that model output is not written back to trusted memory unchecked. The poison itself is in the data.
Skylos 5.7.0. defend maps prompt-delimiter, untrusted-input-to-prompt and rag-context-isolation, which check how the prompt is laid out. Nothing checks what is written to memory or how long it is kept. In our run ASI06 did not appear in the report, because no mapped check applied.
Beyond code. Validate memory writes, isolate sessions and tenants, record where each entry came from, expire unverified entries, and test across sessions. promptfoo lists agentic:memory-poisoning and cross-session-leak plugins under ASI06.
ASI07: Insecure Inter-Agent Communication
The risk. Messages between agents, over A2A, MCP or a message bus, are read, forged, replayed or downgraded because they lack authentication or integrity checks.
What a code check can find. Some of the setup: plain HTTP between agents, MCP transports without authentication, servers listening on every interface. Message signing, replay protection and registry trust are design properties that rarely show up as one line of code.
Skylos 5.7.0. Nothing is mapped to ASI07, and defend leaves it out of the report. Two Python MCP server rules sit nearby, SKY-D241 (unauthenticated transport) and SKY-D243 (server bound to 0.0.0.0). Neither looks at messages between agents.
Beyond code. An architecture review: mutual TLS, signed messages, nonces and timestamps, pinned protocol versions, attested agent cards. Agentic Radar (Apache-2.0) scans LangGraph, CrewAI, n8n, OpenAI Agents and AutoGen projects and draws the workflow graph with its tools and MCP servers, a useful map for that review. It maps findings to the OWASP LLM Top 10 and OWASP's Agentic AI Threats and Mitigations guide, not to the ASI list.
ASI08: Cascading Failures
The risk. One fault, such as a hallucination, a poisoned memory or a broken tool, spreads across agents and workflows and grows.
What a code check can find. Missing bounds: no token limits, no timeouts, no iteration caps on agent loops, no rate limit on the endpoint, no logging. Bounds shrink the blast radius. They do not stop a cascade.
Skylos 5.7.0. defend maps its three ops checks, logging-present, cost-controls and rate-limiting. Ops checks are scored apart and never gate CI. The full scan adds SKY-D267 (Python: LLM calls or agent executors with no token, timeout or iteration limit). In our run all three ops checks failed, and D267 flagged both OpenAI calls and the LangChain agent.
Beyond code. Circuit breakers and quotas between planner and executor, a policy engine outside the agent, and replay tests in a copy of production before an agent gets wider permissions. That is architecture and operations work.
ASI09: Human-Agent Trust Exploitation
The risk. A fluent, confident agent persuades a person to approve something harmful, so the person performs the final action.
What a code check can find. Close to nothing. Whether a confirmation step exists before a payment may be visible in code. Whether the explanation misleads is not.
Skylos 5.7.0. defend maps output-validation here. That check confirms model output passes a parser or schema before use. It says nothing about whether a person is being misled, so we count ASI09 as not covered.
Beyond code. Confirmation steps for risky actions, provenance shown next to recommendations, previews that cannot trigger side effects, and human-factors testing. promptfoo lists overreliance and imitation plugins under ASI09.
ASI10: Rogue Agents
The risk. An agent drifts from its intended function and keeps acting harmfully or deceptively, even when each action looks legitimate.
What a code check can find. Preconditions at most: logging exists around model calls, and tools are narrow enough to limit damage.
Skylos 5.7.0. defend maps tool-scope and logging-present. Both are preconditions for containing and spotting a rogue agent. A pass means you could investigate, not that it cannot happen.
Beyond code. Behavioural monitoring against a baseline, kill switches, credential revocation and quarantine. promptfoo lists goal-misalignment among its ASI10 plugins, and LlamaFirewall's AlignmentCheck watches the agent's reasoning at runtime.
Where Skylos falls short
- Prompt detection uses keywords.
defendtreats an f-string as a prompt when its fixed text holds words such as "answer", "prompt", "user" or "context".f"Customer question: {question}"has none, sountrusted-input-to-promptandprompt-delimiterdid not run onagent.py. Reworded tof"Answer this customer question: {question}", both failed. SKY-D261 did not report it either, by design: a user message beside a fixed system prompt is the separation that rule looks for. - Tool handlers are followed one hop, in the same file.
defendfollows a tool handler called with the model's output in the LLM call's scope. Calls further away and handlers in other files are not followed (docs/agent-verification.md at 5.7.0). defenddid not see the LangChain shell tool. SKY-D264 in the full scan did. Run both commands.- Misses in our run. A tool that reads any path, and an MCP server given
/, went unreported. - Languages differ per check.
defendreads Python and TypeScript/JavaScript. The SKY-D26x and MCP server rules are Python. The CI agent rules read GitHub Actions workflows, and the MCP config rules read.mcp.jsonand similar files. - The percentages count checks. A fully covered risk means its mapped checks passed, nothing more.
- False positives happen. Silence a scan finding on its line with a reason, which shows in review:
# skylos: ignore[SKY-D262] reply is parsed to an int above. Fordefend, askylos-defend.yamlpassed with--policycan turn a check off or change its severity, and the policy's hash goes into the report's attestation digest.
Run it on your agent
No account or API key is needed:
pip install skylos
skylos discover . # list LLM calls, agent tools and MCP servers
skylos defend . --owasp-framework agentic # guardrail checks, reported against ASI01 to ASI10
skylos defend . --owasp-framework agentic --fail-on critical # exit 1 on a failed critical check
skylos defend . --format md -o evidence.md # evidence report with the LLM and agentic lists
skylos . -a # security, secrets, dependencies, CI agent and MCP config rules
skylos cicd init --defend --no-upload # GitHub Actions workflow with a defend step
Then put a red-team tool in front of the running agent, and keep the design review for identities, messaging between agents and failure containment. A scan answers "what can this code do?". The ASI list also asks "what will this agent do?", and that needs the agent running.
Sources
- OWASP GenAI Security Project, OWASP Top 10 for Agentic Applications for 2026, Version 2026, December 2025, CC BY-SA 4.0. PDF downloaded 21 Nov 2026.
- OWASP GenAI Security Project, announcement post, 9 Dec 2025, opened 21 Nov 2026.
- promptfoo, OWASP Agentic AI red teaming, page dated 21 Nov 2026, opened 21 Nov 2026.
- Snyk Agent Scan, Agentic Radar, LlamaFirewall docs, Bandit B602, CodeQL py/command-line-injection, zizmor audits, all opened 21 Nov 2026.
- Skylos 5.7.0:
skylos/defend/owasp.py,docs/agent-verification.md,docs/agent-hooks.mdanddictionary.mdat tag v5.7.0.
Changelog
- 2026-11-21: First version. OWASP list Version 2026 (December 2025). Skylos facts for 5.7.0, with real
skylos defendandskylos . -aoutput from a scratch repository. Other tools' docs checked on 21 Nov 2026.