Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPublish malicious agent config to repository
-
ExploitVictim loads config via load_agent_from_repository
-
ExecutionUnsafe reflection imports attacker module
-
ImpactArbitrary code runs as service account
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V15 - Secure Coding and Architecture Reflection safety, class allowlisting
|
| Exploitation Conditions | Exploitation requires that the victim actively load a malicious or tampered agent configuration from a repository through the load_agent_from_repository function; the function fails to restrict the user-supplied argument used to import a module (CWE-470). The primary limiting factor is the required user interaction (CVSS UI:R): the attack cannot succeed unless a user is induced to load the attacker-controlled configuration, making this dependent on social engineering, a compromised/shared repository, or a trusted-config supply-chain vector. No authentication to the target is required (PR:N), and code executes with the privileges of the CrewAI service account, so impact scales with how the service is run. |
| Impact | This is a credible, high-priority RCE but one gated by a meaningful precondition. The CVSS 3.0 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) reflects network vector, low complexity, no privileges, and full compromise of confidentiality, integrity, and availability - but the UI:R metric is doing heavy lifting: the victim must be convinced to load a malicious agent configuration from an attacker-controlled repository, making this a social-engineering / supply-chain-style attack rather than a drive-by remote exploit. The underlying weakness (CWE-470, unsafe reflection in load_agent_from_repository importing a user-supplied module name) is a well-understood and reliable code-execution primitive, so once a victim loads the malicious config, exploitation is deterministic rather than probabilistic. No EPSS score, KEV listing, or public POC was provided in the input, so there is no signal of active or widespread exploitation at this time - consistent with a freshly disclosed ZDI advisory. The signals are internally consistent (no CVSS-vs-description conflict), but note the AV:N rating depends on treating remote repository retrieval as the network vector; the actual trigger is a local user action loading the config, which tempers real-world risk below what the raw 8.8 suggests. |
| Exploit ScenarioDerived | An attacker publishes or tampers with an agent configuration in a repository that a CrewAI user is likely to load (e.g., a shared or community agent definition). When the victim loads that configuration via load_agent_from_repository, the unsafe reflection imports an attacker-specified module, executing arbitrary code in the context of the service account. No public exploit code was identified at time of analysis, but the CWE-470 pattern makes reliable exploitation straightforward once the victim loads the crafted config. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Unsafe reflection in CrewAI's load_agent_from_repository function enables unauthenticated remote code execution when a victim loads an attacker-controlled agent configuration from a repository, with code running under the CrewAI service account's privileges. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and is gated by required user interaction: the target must be induced to load the malicious configuration, making exploitation dependent on social engineering, a compromised or shared repository, or a trusted-config supply-chain vector. No public exploit was identified at time of analysis, and no CISA KEV confirmation is present.
RemediationAI
No vendor-released patch was identified at time of analysis, so remediation currently centers on compensating controls. Do not load agent configurations from untrusted, shared, or externally writable repositories through load_agent_from_repository; restrict repository sources to an allowlist and require code review or signature/checksum verification for agent configuration files. Where the feature is not essential, disable repository-based agent loading entirely, accepting the functional loss of dynamic agent distribution. Harden the CrewAI service by running it in a least-privilege container or dedicated account with no unnecessary filesystem, network, or secret access, since exploitation yields code execution as the service account; this limits blast radius but does not prevent the initial import. If custom modules must be supported, constrain dynamic imports to a fixed allowlist of known-safe modules and reject user-controlled module paths, with the trade-off that legitimate custom agent modules may need explicit onboarding. Monitor for unexpected module imports or outbound callbacks from the CrewAI process and consult advisory ZDI-26-706 at https://www.zerodayinitiative.com/advisories/ZDI-26-706/ for updates.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-470 (Use of Externally-Controlled Input to Select Classes or Code, or 'unsafe reflection'). The load_agent_from_repository function takes a user-supplied argument and uses it to perform a dynamic module import without adequately restricting which module or code path can be selected. In Python-based agent frameworks, this pattern can turn a configuration-loading workflow into arbitrary code execution because importing an attacker-chosen module executes module-level code in the CrewAI service process. The supplied CPE entry, cpe:2.3:a:crewai:crewai:*:*:*:*:*:*:*:*, treats the CrewAI package across versions as affected because the input does not enumerate a specific fixed release. The CVSS vector CVSS:3.0/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H indicates a network-reachable attack that needs no authentication but does require the victim to load the malicious agent configuration; impact is limited to the CrewAI service's security scope but includes full confidentiality, integrity, and availability effects within that context.
Know when Crewai 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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Malicious config is fetched/loaded remotely (AV:N) with no auth (PR:N) but requires the victim to load it (UI:R); reflection yields full code execution (C/I/A:H).
Primary rating from Vendor (zdi).
CVSS VectorVendor: zdi
DescriptionCVE.org
CrewAI crewAI Framework Agent Loading Unsafe Reflection Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of CrewAI crewAI. User interaction is required to exploit this vulnerability in that the target must load a malicious agent configuration from the repository.
The specific flaw exists within the load_agent_from_repository function. The process does not properly restrict a user-supplied argument before using it to import a module. An attacker can leverage this vulnerability to execute code in the context of the service account. Was ZDI-CAN-28387.
Executive ViewAI
CrewAI's load_agent_from_repository feature creates a path to unauthenticated remote code execution when a user is induced to load an attacker-controlled agent configuration, affecting the CrewAI service account and any systems or data it can reach. Exploitation depends on user interaction or a compromised/shared repository, so the highest risk sits with teams that source agent configurations from external or loosely controlled repositories. Leadership should treat this as a supply-chain and social-engineering exposure and prioritize containment until a vendor fix is available.
No vendor-released patch identified at time of analysis; interim mitigations include restricting load_agent_from_repository to trusted internal repositories, enforcing configuration signing or integrity verification, running CrewAI service accounts with least privilege, blocking untrusted public or shared repository ingestion, and monitoring for anomalous process execution by those accounts.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Server-side request forgery in CrewAI's scraping tools before version 1.15.1 lets remote attackers reach internal servic
Sandbox escape in CrewAI's CodeInterpreterTool allows untrusted Python code to break out of the in-process restricted ex
CrewAI fails to validate Docker runtime availability during execution and silently reverts to an insecure sandbox mode,
Server-side request forgery in CrewAI's RAG search tools allows remote attackers to access internal and cloud services b
CrewAI's JSON loader tool fails to validate file paths before reading, allowing arbitrary local file access that exposes
EUVD-2026-107404
GHSA-pgwr-r23p-38mr
NVD
CVE.org
EPSS
Exploit-DB