Skip to main content

Agno EUVDEUVD-2026-97299

| CVE-2026-108816 LOW
Code Injection (CWE-94)
2026-10-12 VulDB GHSA-jxpq-35pp-m3rc
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain low-privilege agent access
  2. Exploit
    Supply malicious payload to run_python_code
  3. Execution
    Execute arbitrary Python in host process
  4. Impact
    Access application data or resources

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the attacker to control the 'code' argument passed to the run_python_code function of the PythonTools component - i.e. the Agno agent must be deployed with PythonTools enabled and reachable, and the attacker must be able to influence the code string it executes. CVSS PR:L indicates a low-privilege authenticated foothold is needed, so this is not an unauthenticated drive-by: realistic paths are an authorized-but-malicious user of the agent, or indirect prompt injection that steers the LLM into invoking the tool with attacker-chosen code. LIMITING FACTORS: PythonTools must be configured/active (it is an optional agent tool, not a default endpoint), the attacker needs at least low-level access per PR:L, and the vendor's LOW impact rating suggests execution may occur in a constrained context - verify whether a sandbox bounds the resulting access.

Impact

Signals point to a LOW real-world priority despite the alarming CWE-94 'code injection' / RCE framing. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) with uniformly LOW impacts (VC:L/VI:L/VA:L, SC:N/SI:N/SA:N) yields only 2.1, and E:P marks exploitation as proof-of-concept rather than active. A public exploit advisory exists (GitHub), so 'publicly available exploit code exists' - but there is NO CISA KEV listing and NO EPSS score was provided in the input, so widespread or automated exploitation cannot be asserted. The core tension: the affected function run_python_code in PythonTools is, by design, a code-execution primitive - an Agno agent tool whose purpose is to run Python. 'Code injection' here is close to intended behavior, which likely explains why the vendor rated impact LOW rather than the High you would expect from true arbitrary RCE. This also explains why the project 'has not responded' to the issue report. CONFLICT TO VERIFY: a function that executes attacker-controlled Python should, on a naive reading, produce High confidentiality/integrity/availability impact, yet the vector claims only Low - verify with the vendor whether a sandbox or restricted execution context limits the blast radius, because if not, real impact is materially higher than the 2.1 score implies. PR:L means an attacker needs some authenticated/privileged foothold (or, in agent deployments, the ability to steer the LLM into calling the tool via prompt injection), which further narrows realistic exploitation to already-authorized or already-compromised agent contexts rather than opportunistic internet-wide attack.

Exploit ScenarioDerived

An attacker with low-privilege access to an Agno-based agent application (or who can influence agent input to trigger tool use) supplies a malicious payload to the PythonTools run_python_code function, causing attacker-chosen Python to execute within the application process. A public proof-of-concept advisory demonstrating this is available on GitHub, and because the attack vector is network-based with low complexity, it can be reproduced remotely once the attacker holds the required low-level access.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
No patch listed yet 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 12, 2026

Code injection in the PythonTools component of Agno (agno-agi/agno) through version 3.0.6 lets an attacker who can influence the 'code' argument of run_python_code execute arbitrary Python in the host process. The CVSS v4.0 vector supplied with the record is low (2.1, PR:L), and our independent assessment confirms that a low-privilege foothold is required - realistic paths are an authorized-but-malicious user of an agent that has PythonTools enabled, or indirect prompt injection steering the model into calling the tool with attacker-chosen code; PythonTools is an optional agent tool rather than a default network-exposed endpoint. Publicly available exploit code exists (a third-party advisory and PoC repository are linked), and the vendor was notified via a GitHub issue but has not responded, so no vendor patch is confirmed; despite the RCE framing, the signals point to a low real-world priority.

RemediationAI

No vendor-released patch identified at time of analysis: the project was notified through issue #10047 and has not responded, and no fixed version is confirmed for agno-agi/agno, so treat any upgrade as verification-required rather than a guaranteed fix. Until a patched release is available, the highest-value control is to disable PythonTools, or remove run_python_code from the agent's registered tool set, wherever arbitrary Python execution is not strictly required - the trade-off is loss of that capability in the agent workflow. Where the tool must stay enabled, run the code-execution path in a hardened sandbox (separate container or micro-VM with seccomp/AppArmor profiles, a non-privileged user, dropped capabilities, a read-only filesystem and no outbound network egress) so that a successful injection cannot reach host resources - this adds latency and operational complexity and can break legitimate scripts that need filesystem or network access. Restricting agent access to fully trusted users and adding human-in-the-loop approval before tool invocation reduces the malicious-user path but does not eliminate indirect prompt-injection paths. Treat model output as untrusted input: apply strict allow-listing/parsing of the code argument, monitor agent tool-call logs for anomalous Python invocations, and keep PythonTools off any agent endpoint reachable by untrusted content while awaiting a vendor response; consult https://github.com/Agno-agi/Agno/issues/10047 and https://vuldb.com/vuln/416593 for updates.

Affected VersionsENISA

agno 3.0.1
agno 3.0.2
agno 3.0.6
agno 3.0.4
agno 3.0.3
agno 3.0.5
agno 3.0.0

Affected Packages

euvd agno no fix

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 root cause class is CWE-94 (Improper Control of Generation of Code / code injection). Agno is an agent framework in which tools are exposed to an LLM and invoked with model-supplied arguments; the PythonTools component implements run_python_code in python.py, which takes a 'code' string and evaluates/executes it. Because the argument originates from the model's output rather than from a validated, constrained input path, any party able to shape that string - a malicious authenticated user of the agent or an attacker who can inject instructions into the model's context - controls what Python is executed. The CPE cpe:2.3:a:agno-agi:agno:*:*:*:*:*:*:*:* indicates the issue is tracked against the Agno package generally rather than a single pinned release, with 3.0.6 as the highest confirmed affected version in the report. The CVSS v4.0 vector AV:N/AC:L/AT:N/PR:L/UI:N with E:P characterizes it as network-reachable but requiring low privileges, with a proven exploit; the vendor/VulDB impact rating is low, which suggests execution may occur in a constrained or sandboxed context. Our assessed CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects the potential worst case if that code runs unsandboxed in the agent process, while the practical precondition - PythonTools enabled and attacker control of the code string - is what bounds real impact.

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

Vendor (VulDB) PRIMARY 2.1 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
vuln.today AI 8.8 HIGH

A tool that runs attacker-controlled Python yields arbitrary execution in the host process (C/I/A:H), but requires low-privilege access to invoke it (PR:L); scope unchanged as code runs within the same process.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

3
Severity Changed
Oct 12, 2026 - 09:22 NVD
MEDIUM LOW
CVSS changed
Oct 12, 2026 - 09:22 NVD
5.3 (MEDIUM) 2.1 (LOW)
CVE Published
Oct 12, 2026 - 08:30 cve.org
LOW 2.1

DescriptionCVE.org

A vulnerability was found in agno-agi agno up to 3.0.6. Affected by this vulnerability is the function run_python_code of the file python.py of the component PythonTools. The manipulation of the argument code results in code injection. The attack can be launched remotely. The exploit has been made public and could be used. The project was informed of the problem early through an issue report but has not responded yet.

Threat Intelligence Overview

EPSS Score
0.3%
Top 79% exploitable
Prevalence
Medium
popular open-source Python AI-agent framework, growing but not enterprise-ubiquitous
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity LOW
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Low

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy