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?

ASIRisk (OWASP name)Static check of agent codeSkylos coverage at 5.7.0What else you need
ASI01Agent Goal HijackPartly: where untrusted text enters a promptskylos 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
ASI02Tool Misuse and ExploitationWell: what each tool can reachtool-scope, tool-schema-present, no-dangerous-sink. SKY-D264 (shell and REPL tools handed to agents), SKY-D212Per-tool runtime policy, egress allowlists, approval for destructive actions
ASI03Identity and Privilege AbusePartly: credentials in code and CItool-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
ASI04Agentic Supply Chain VulnerabilitiesPartly: what is declared and pinned in the repomodel-pinned. Dependency advisories, SKY-D222, D367 to D369 (MCP configs), D240, D265. Agent hooks for coding agentsSigned tool definitions and prompts, runtime re-checks of what the agent loads
ASI05Unexpected Code Execution (RCE)Well: model output reaching sinks in your codeno-dangerous-sink, output-validation, tool-scope. SKY-D262 (Python), D212, D265Sandboxes, no root, approval before running generated code
ASI06Memory & Context PoisoningLittle: prompt layoutPrompt and RAG layout checks. Nothing checks memory writesValidation of memory writes, tenant isolation, provenance, cross-session tests
ASI07Insecure Inter-Agent CommunicationLittleNothing mapped. SKY-D241 and D243 cover MCP server transport (Python)Mutual TLS, signed messages, anti-replay, attested agent registries
ASI08Cascading FailuresLittle: missing boundsOps checks logging-present, cost-controls, rate-limiting (never gate). SKY-D267Circuit breakers, quotas, replay tests before widening permissions
ASI09Human-Agent Trust ExploitationNoMapped to output-validation. We count it as not coveredConfirmation design, provenance in the UI, human-factors testing
ASI10Rogue AgentsNo, preconditions at mostMapped to tool-scope and logging-present, which are preconditionsBehavioural 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:

ASIChecks Skylos maps to itOur note
ASI01untrusted-input-to-prompt, prompt-delimiter, input-length-limit, rag-context-isolationChecks prompt construction, not whether the model follows injected text
ASI02tool-schema-present, tool-scope, no-dangerous-sinkThe strongest fit
ASI03tool-scopeOne check for a risk that is mostly about identity design
ASI04model-pinned, tool-schema-presentA typed tool schema says little about supply chain
ASI05no-dangerous-sink, output-validation, tool-scopeA strong fit for sinks in your own code
ASI06prompt-delimiter, untrusted-input-to-prompt, rag-context-isolationChecks prompt layout, not memory contents
ASI07noneNot covered
ASI08logging-present, cost-controls, rate-limitingOps checks: scored apart and never gate CI
ASI09output-validationA parser check does not tell you whether a person is misled
ASI10tool-scope, logging-presentPreconditions 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_shell and read_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 given ShellTool().
  • .mcp.json: a file-system MCP server started with npx -y and 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-scope failed on run_shell, and no-dangerous-sink traced model-written tool arguments into subprocess.run one call away and found the second reply run in a shell at line 69.
  • A typed schema is not a narrow one. tool-schema-present passed because command is 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. defend did not see ShellTool(). 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. defend treats 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, so untrusted-input-to-prompt and prompt-delimiter did not run on agent.py. Reworded to f"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. defend follows 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).
  • defend did 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. defend reads 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.json and 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. For defend, a skylos-defend.yaml passed with --policy can 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

Changelog

  • 2026-11-21: First version. OWASP list Version 2026 (December 2025). Skylos facts for 5.7.0, with real skylos defend and skylos . -a output from a scratch repository. Other tools' docs checked on 21 Nov 2026.