Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with session edit rights
-
DeliveryTarget bound shared/template agent (session_id None)
-
ExploitPUT /sessions/{id}/agent to inject stdio MCP server
-
ExecutionVictim session launches poisoned shared agent
-
PersistRunner spawns attacker command via mcp.py
-
ImpactRCE exposing files, credentials, internal services
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 an authenticated account (PR:L per CVSS) that holds edit access (LEVEL_EDIT) to at least one session, and that session must be bound to a shared or template agent whose agent.session_id is None; the attacker abuses PUT /sessions/{session_id}/agent to replace that shared agent bundle and add a stdio MCP server. Exploitation is limited by several factors: the attacker cannot be fully unauthenticated (edit privilege on a session is mandatory), the deployment must actually use shared/template agents that other sessions reuse, and code execution only triggers when a later session launches the poisoned shared agent (UI:R), so a purely single-user or non-shared-agent deployment is not exposed. Only versions prior to 0.3.0 are affected. |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H, base 9.0) reflects a network-reachable, low-complexity attack requiring only low privileges but also user interaction and involving a scope change - the attacker's action in one session affects later, separate sessions using the shared agent. The privilege requirement (PR:L) means this is not an unauthenticated internet-wide threat: the attacker must already be an authenticated user holding edit access to some session, which points to insider or compromised-account abuse rather than mass exploitation. The UI:R component reflects that the malicious command fires only when a later session actually launches the poisoned shared agent, introducing a delay and a dependency on victim activity. No CISA KEV listing and no EPSS score were provided, and no public exploit code was identified, so real-world exploitation appears theoretical at present, but the payoff (RCE with runner-process permissions across shared infrastructure) is high, so operators running multi-tenant or team-shared Omnigent deployments should patch promptly. The scope change is the key aggravator here: one privileged tenant can poison an agent that other tenants unknowingly execute. |
| Exploit ScenarioDerived | An authenticated Omnigent user who has been granted edit access to a session sends a PUT /sessions/{session_id}/agent request that targets a bound shared/template agent and injects a stdio MCP server pointing at an attacker-controlled command. Later, when a different session launches that shared agent, omnigent/tools/mcp.py spawns the malicious command with the runner process's permissions, exposing files, credentials, and internal services. No public exploit code was identified, but the low attack complexity makes weaponization straightforward for a user with the required session edit rights. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 21, 2026
Remote code execution in Omnigent, an open-source AI agent framework and meta-harness, before version 0.3.0 allows an authenticated user with session edit access to hijack shared/template agents and achieve command execution on the runner host. The PUT /sessions/{session_id}/agent endpoint enforces LEVEL_EDIT on the session but fails to reject a bound shared or template agent (whose agent.session_id is None), letting the attacker replace the shared agent bundle and inject a malicious stdio MCP server that later executes an attacker-controlled command. There is no public exploit identified at time of analysis, but a vendor patch (0.3.0) and the fixing commit are public.
RemediationAI
Upgrade to Omnigent 0.3.0, which adds an explicit guard rejecting edits to built-in shared/template agents (agent.session_id is None) via the session agent endpoint (Vendor-released patch: 0.3.0; see release https://github.com/omnigent-ai/omnigent/releases/tag/v0.3.0, fix PR https://github.com/omnigent-ai/omnigent/pull/1418, and commit 25a22dc9e6da4648d23749f0a589e47e6aed991b). If immediate upgrade is not possible, restrict LEVEL_EDIT session access to trusted operators only and audit shared/template agent bundles for unexpected stdio MCP server entries, since a compromised editor account is the precondition for abuse; note this reduces exposure but does not close the authorization gap. Additionally, run the Omnigent runner process with least privilege and in an isolated/sandboxed environment so that any injected MCP command has minimal access to files, credentials, and internal services, accepting that sandboxing may constrain legitimate tool functionality. Consult advisory GHSA-jrrm-9hc7-2v3h for vendor guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Omnigent orchestrates coding agents and integrates external tooling through the Model Context Protocol (MCP). Sessions can bind to shared or template agents that are not owned by any single session, identified by agent.session_id being None. The vulnerability (CWE-94, Improper Control of Generation of Code / Code Injection) stems from an authorization gap in omnigent/server/routes/sessions.py: the update handler checks LEVEL_EDIT against the session but does not verify that the target agent is actually editable, so a shared/template agent can be mutated through a session the attacker can edit. Because MCP stdio servers (handled in omnigent/tools/mcp.py) launch local commands, an attacker who can persist a crafted stdio MCP server into a shared agent bundle turns a configuration write into command execution. CPE cpe:2.3:a:omnigent-ai:omnigent identifies the single affected product across all versions prior to 0.3.0.
Know when Omnigent 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:L/UI:R/S:C/C:H/I:H/A:H
Network endpoint reachable with low complexity; requires an authenticated session-editor (PR:L) and a later victim launch (UI:R); poisoning a shared agent affecting other sessions is a scope change (S:C) yielding full RCE impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Omnigent is an open-source AI agent framework and meta-harness for orchestrating coding agents. Prior to 0.3.0, PUT /sessions/{session_id}/agent checks LEVEL_EDIT permission for a session but does not reject a bound shared or template agent whose agent.session_id is None. An authenticated user with edit access to a session can replace that shared agent bundle through omnigent/server/routes/sessions.py, add a stdio MCP server, and cause later sessions that use the shared agent to launch an attacker-controlled command through omnigent/tools/mcp.py. The command executes with the Omnigent runner process permissions and can expose files, credentials, workspace data, internal services, and runner availability. This issue is fixed in version 0.3.0.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Omnigent versions before 0.3.0 contain a critical remote code execution vulnerability that enables authenticated users with session edit privileges to execute arbitrary commands on framework runner infrastructure. An attacker can hijack shared or template agents to inject malicious code executing on the host system. Organizations deploying affected versions of this open-source AI agent framework face potential compromise of automation infrastructure and any downstream systems dependent on the execution environment.
Apply vendor patch.
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
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.
Remote code execution in Omnigent's multi-tenant runner allows any authenticated user to hijack the runner process by up
Path traversal in Omnigent AI agent framework (versions prior to 0.3.0) allows authenticated users to escape the session
Shell-command parser bypass in Omnigent's policy layer allows an authenticated or prompt-injected agent to push code to
EUVD-2026-64016
GHSA-jrrm-9hc7-2v3h
NVD
CVE.org
EPSS
VulDB
Exploit-DB