Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlant prompt injection in untrusted content
-
ExploitAgent emits run_python_code tool call
-
ExecutionUngated exec()/subprocess runs attacker code
-
ImpactArbitrary code execution on agent host
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Dynamic code resource control
|
| Exploitation Conditions | Requires (1) the agent to be built with agno's PythonTools toolkit exposing the code-executing tools (run_python_code, save_to_file_and_run, run_python_file_return_variable, pip_install_package, uv_pip_install_package) without an explicit requires_confirmation_tools gate - which was the vulnerable default in versions up to 3.0.6/3.1.1 - and (2) the attacker to be able to influence the model's input (prompt injection via untrusted data the agent ingests). LIMITING FACTORS: agents that do not load PythonTools code-execution tools, that run them inside a real sandbox, or that already set requires_confirmation_tools are not exploitable; deployments that never feed attacker-controlled content to the model sharply reduce realistic risk. No end-user click is needed (the agent calls the tool autonomously), but the operator-chosen toolkit configuration is the key prerequisite. |
| Impact | This is a moderate-but-conditional risk whose raw CVSS 4.0 base score of 6.9 (E:P) understates the technical impact while the deployment precondition understates it in the other direction. The VulDB vector (AV:N/AC:L/PR:N/UI:N/VC:L/VI:L/VA:L) rates confidentiality/integrity/availability as only 'Low', but the source-code evidence shows the actual defect is a missing human-confirmation gate on PythonTools' code-executing functions (run_python_code, save_to_file_and_run, run_python_file_return_variable, pip_install_package, uv_pip_install_package), so a model-influenced tool call reaches exec()/runpy()/subprocess with NO pause - i.e. arbitrary code execution in the host process, which I assess as High impact, not Low. The '4.0/E:P' exploit-maturity flag plus the published advisory and POC confirm public exploit code exists, but there is NO CISA KEV listing and no EPSS value supplied, so there is no evidence of widespread active exploitation - treat as proof-of-concept, not in-the-wild. The decisive limiter is deployment: exploitation only matters where an operator has enabled the PythonTools code-execution tools AND exposes the agent to attacker-influenced input (prompt injection). CONFLICT TO VERIFY: VulDB impact metrics (VC/VI/VA:L) contradict the code evidence of full code execution - the 'Low' impacts and the 'Information Disclosure' tag appear to under-rate an RCE-class flaw. Priority is elevated for anyone running agno's PythonTools against untrusted content and low for everyone else. |
| Exploit ScenarioDerived | An agno-based agent is configured with the default PythonTools toolkit and processes untrusted content (a web page, email, document, or user message). An attacker embeds a prompt-injection payload that causes the model to emit a run_python_code tool call; because the code-executing tools were not gated by confirmation in versions up to 3.0.6/3.1.1, the orchestration loop runs the attacker's Python immediately via exec()/subprocess. Public exploit code and a detailed advisory exist, and the referenced test (test_default_assembly_pauses_model_requested_code_execution) demonstrates a marker-file write proving execution. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 12, 2026
Model-influenced tool calls in the Agno agent framework (agno-agi) through 3.0.6 and 3.1.1 reach Python exec()/runpy()/subprocess without any confirmation gate, so an attacker who can steer the model's input - typically through prompt injection in untrusted data the agent ingests - can cause the agent to run attacker-chosen code on the host or container running the agent. The issue is remotely reachable and unauthenticated (CVSS:4.0 vector AV:N/PR:N/UI:N; our assessed CVSS:3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), and publicly available exploit code exists - although no CISA KEV entry indicates confirmed exploitation in the wild at time of analysis. Real-world risk is conditional: only agents built with the PythonTools toolkit that expose the code-executing tools under the vulnerable default (no explicit requires_confirmation_tools) and that accept attacker-influenceable input are exposed.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - the fix lives in https://github.com/agno-agi/agno/pull/10523, which changes PythonTools to require confirmation by default for run_python_code, save_to_file_and_run, run_python_file_return_variable, pip_install_package and uv_pip_install_package, and that pull request awaits acceptance, so verify whether your installed release already contains it (check the code-execution defaults in libs/agno/agno/tools/python.py) before assuming a version number is safe. Until a tagged release carrying the change is confirmed, the most direct mitigation on vulnerable versions is to pass the gate explicitly at construction time - PythonTools(base_dir=..., requires_confirmation_tools=["run_python_code", "save_to_file_and_run", "run_python_file_return_variable", "pip_install_package", "uv_pip_install_package"]) - with the trade-off that gated calls now pause with tool_call_paused and require a human or programmatic approval step, which breaks unattended pipelines unless you implement resume handling. Alternatively, drop the execution tools from the toolkit entirely (exclude_tools or omitting PythonTools) where the agent does not need them; note that passing requires_confirmation_tools=[] restores immediate execution and is only acceptable inside a genuine sandbox. As compensating controls, run the agent in a container or VM with no host mounts, no long-lived cloud credentials, and egress-restricted networking, and keep untrusted content out of model context where possible, since prompt injection is the delivery vector; these reduce blast radius but do not remove the code-execution primitive. See the VulDB entry (https://vuldb.com/vuln/416596) and the upstream issue (https://github.com/Agno-agi/Agno/issues/10053) for status.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is CWE-913 (Improper Control of Dynamically-Managed Code Resources) in Agno's Agent Orchestration Layer, specifically the PythonTools toolkit. In versions up to 3.0.6/3.1.1, PythonTools was constructed with an empty requires_confirmation_tools default, so the orchestration loop executed a model-requested tool call immediately with no pause. The gated functions are run_python_code, save_to_file_and_run, run_python_file_return_variable, pip_install_package and uv_pip_install_package - each of which reaches the host process's exec(), runpy(), or subprocess, and the pip/uv installers execute package setup code as a side effect. Because the tool arguments are produced by the LLM, any prompt injection that reaches the model (untrusted documents, web content, tool outputs, user-supplied text) can be laundered into an arbitrary-code-execution primitive. The upstream PR #10523 inverts the default to deny: PythonTools now seeds requires_confirmation_tools with the five dangerous tools unless the caller explicitly passes a value (including []), so the orchestration loop emits tool_call_paused instead of executing, and the accompanying unit tests add an attacker-influenced model stub that demonstrates the pause. This maps to a full compromise of the agent runtime rather than mere information disclosure, despite the 'Information Disclosure' tag attached by the reporter.
Know when Agno gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
Remotely reachable via attacker-influenced model input (AV:N, PR:N, UI:N); the ungated default makes the tool call fire without extra hurdles (AC:L); unsandboxed code execution in the host process yields full C/I/A impact.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
2DescriptionCVE.org
A security flaw has been discovered in agno-agi agno up to 3.0.6/3.1.1. This vulnerability affects the function exec of the component Agent Orchestration Layer. Performing a manipulation of the argument code results in dynamically-managed code resources. Remote exploitation of the attack is possible. The exploit has been released to the public and may be used for attacks. The pull request to fix this issue awaits acceptance.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Missing authentication in Agno (agno-agi) through version 2.7.3 and 3.0.6 causes AgentOS agent endpoints to be reachable
Remote code execution in Agno prior to version 2.3.24 allows attackers to execute arbitrary Python code by manipulating
SQL injection in agno 2.6.5's ClickHouse vector database backend allows authenticated attackers to inject arbitrary SQL
OS command injection in the Agno agent framework's CodingTools.run_shell helper (versions up to and including 3.0.9) let
Agno's Team Delegation Feature runs member agents without a confirmation gate, allowing an actor who can influence deleg
Code injection in the PythonTools component of Agno (agno-agi/agno) through version 3.0.6 lets an attacker who can influ
EUVD-2026-97318
GHSA-fxvj-hc6f-3f6v
NVD
CVE.org
EPSS
VulDB
Exploit-DB