Skip to main content

Omnigent EUVDEUVD-2026-64016

| CVE-2026-62674 CRITICAL
Code Injection (CWE-94)
2026-08-21 GitHub_M GHSA-jrrm-9hc7-2v3h
9.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Authenticate with session edit rights
  2. Delivery
    Target bound shared/template agent (session_id None)
  3. Exploit
    PUT /sessions/{id}/agent to inject stdio MCP server
  4. Execution
    Victim session launches poisoned shared agent
  5. Persist
    Runner spawns attacker command via mcp.py
  6. Impact
    RCE 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
1 public PoC Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

omnigent < 0.3.0

Affected Packages

pypi omnigent fix: 0.3.0

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

Vendor (GitHub_M) PRIMARY 9.0 CRITICAL
AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H
vuln.today AI 9.0 CRITICAL

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
Required
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Aug 21, 2026 - 18:01 EUVD
CVE Published
Aug 21, 2026 - 17:47 cve.org
CRITICAL 9.0

DescriptionCVE.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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 72% exploitable
Prevalence
Low
niche open-source AI agent framework, limited production footprint
Threat Intel
1
1 source
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 CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
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
Out-of-Cycle
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact
Very High

Priority Score

65
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +45
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