CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-J659-8XH6-5PQ5

GHSA-J659-8XH6-5PQ5: Financial Guardrail Bypass in atomic-agents-stack via Parallel Execution of Unlisted Models

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 18, 2026·7 min read·17 visits

Executive Summary (TL;DR)

Unrecognized LLMs evaluate to a $0.00 reservation cost, completely bypassing batch cost guardrails and allowing infinite execution spend.

A high-severity vulnerability in the atomic-agents-stack framework allows complete bypass of cost-cap guardrails during parallel model execution when utilizing unlisted, local, or self-hosted models.

Vulnerability Overview

The atomic-agents-stack framework is an orchestration platform designed to run and coordinate multi-agent artificial intelligence pipelines. The package exposes interfaces for running concurrent helper tasks, which utilize parallel processing to improve overall response times. To prevent runaway financial costs, the framework implements a cost-tracking mechanism configured via a budget ceiling.

This vulnerability resides in the automated cost-estimation logic responsible for evaluating potential transaction charges prior to execution. When an operator integrates custom or self-hosted models that are not cataloged within the local library definitions, the system fails to apply safety thresholds. The security boundaries are consequently bypassed, presenting a significant financial risk to deployments.

The vulnerability represents a classic example of CWE-770 (Allocation of Resources Without Limits or Throttling). It specifically exposes the framework to parallel execution exhaustion attacks, wherein concurrent agent processes skip the reservation queue. The resulting unmonitored activity can result in unrestrained token consumption.

Root Cause Analysis

In multi-agent architectures, parallel processes run concurrently and execute tasks independently. To implement cost limits, the system must evaluate estimated costs before dispatching requests. Because multiple threads initialize at the exact same moment, they face a concurrency hazard known as a fan-out race.

If a standard database lookup occurs, each concurrent process checks the current spent total against the budget ceiling. Since no operations have finished writing back their completed costs, all processes read the same outdated ledger value. Each individual thread registers the transaction as safe, which bypasses the configured cap and allows the group to execute fully.

To mitigate this issue, the framework uses a pessimistic reservation mechanism. Before dispatching any batch, the framework estimates the cost of the entire transaction group and locks this reservation value on disk. Subsequent execution threads read this reservation and instantly halt if the combined projected costs exceed the budget ceiling.

The primary defect exists because the reservation calculation evaluates to zero when handling unrecognized models. This null valuation tricks the validation function into skipping the reservation entirely, disabling the defensive locking mechanism.

Code Analysis

The vulnerability is located within the _estimate_batch_cost function in the atomic_agents/agent.py source file. The code attempts to retrieve the model configuration from a predefined pricing table using a default dictionary retrieval method. When the model is absent, it yields an empty dictionary.

# Vulnerable Code block in atomic_agents/agent.py
def _estimate_batch_cost(model, ...):
    # If the model is not found, get() returns an empty dictionary
    pricing = PRICING.get(model, {})
    
    # An empty dictionary causes .get() to evaluate to the fallback float value
    output_price = pricing.get('output', 0.0) 
    input_price = pricing.get('input', 0.0)
    
    # The calculation results in a total reservation value of 0.0
    total_estimated_reservation_cost = (input_price * estimated_inputs) + (output_price * estimated_outputs)
    return total_estimated_reservation_cost

This calculation returns exactly 0.0. Subsequently, the system executes the validation check through the helper function _check_batch_reservation. If the calculated cost reservation is equal to or less than zero, the security logic returns immediately without writing any state to the disk database.

# Vulnerable reservation validation in atomic_agents/agent.py
def _check_batch_reservation(reservation, ...):
    # If the reservation is zero or negative, the security logic is bypassed
    if reservation <= 0:
        return  # Early exit blocks reservation registry

The system fixes this defect by standardizing lookup strategies across all modules. The patched version incorporates a defensive helper method _costs._fallback_pricing() to supply safe default financial valuations when a model identifier is missing.

# Patched Code block in atomic_agents/agent.py
def _estimate_batch_cost(model, ...):
    # Leverage fallback pricing to ensure a non-zero estimation
    pricing = PRICING.get(model, _costs._fallback_pricing())
    
    output_price = pricing.get('output')
    input_price = pricing.get('input')
    
    # Non-zero reservation enforces the cost check logic
    return (input_price * estimated_inputs) + (output_price * estimated_outputs)

Exploitation & Attack Methodology

Exploiting this flaw does not require complex remote shellcode or injection vectors. The primary threat vector manifests when the orchestration layer processes parallel tasks using unlisted model identifiers. This occurs naturally in installations using local deployments, such as Ollama or vLLM endpoints.

An attacker can trigger this state if they possess the ability to manipulate input parameters that dictate the choice of downstream helper models. If an agent system dynamically routes requests to models based on user input, the attacker can pass an arbitrary string as the model parameter. The system accepts the unrecognized string, maps it to the empty configuration, and disables the safety checks.

Once the reservation mechanism is bypassed, the attacker can deploy massive parallel batch requests. Since no reservation is registered on disk, the system launches multiple worker processes concurrently. The processes run to completion and consume API resources before the master tracker updates the global usage statistics.

> [!NOTE] > While this behavior is often triggered accidentally by developers running local models, it represents an exploitable vector for denial-of-service and direct financial resource exhaustion.

Impact Assessment

The vulnerability is evaluated with a CVSS v4 score of 8.7, indicating a high-impact threat to operational and financial integrity. Although the defect does not allow an attacker to read arbitrary files or execute code on the host machine, the lack of throttling represents a severe threat to operational stability.

The primary consequence is unrestricted financial depletion. Organizations that deploy multi-agent workflows often rely on cost guardrails to contain costs from malfunctioning logic, recursive agent feedback loops, or automated spam. A bypass of these limits can consume thousands of dollars in API credits within a very short timeframe.

Because the bypass occurs pre-execution, standard internal monitoring tools will not raise alerts until after the resource consumption has occurred. This makes detecting active exploitation or runaway execution loops extremely difficult using localized application logs. The organization must rely on downstream API provider alerts, which are typically delayed.

Remediation & Mitigations

The definitive remediation is to upgrade the atomic-agents-stack package to version 1.1.0 or higher. This update unifies the cost estimation logic across all active components, ensuring that unknown models resolve to safe, non-zero fallback prices. This forces the validation logic to register a reservation and effectively blocks unauthorized parallel executions.

For systems where an immediate upgrade is not feasible, operators must manually pre-populate the pricing catalog. This can be achieved by writing a startup routine that injects custom model keys and rates directly into the framework's internal registry.

# Safe workaround configuration at application bootstrap
from atomic_agents import _costs
 
# Register custom self-hosted or local model definitions
_costs.PRICING["ollama/unlisted-model"] = {
    "input": 0.0015,  # Input token cost per thousand
    "output": 0.0020, # Output token cost per thousand
}

Organizations should also implement rate limits at the API proxy layer. Restricting the maximum number of concurrent requests allowed by the API key provides an independent safety boundary that mitigates the impact of application-layer bypasses.

Technical Appendix

CVSS Score
8.7/ 10

Affected Systems

atomic-agents-stack

Affected Versions Detail

Product
Affected Versions
Fixed Version
atomic-agents-stack
dep0we
<= 1.0.01.1.0
AttributeDetail
CWE IDCWE-770
Attack VectorNetwork
CVSS v4 Score8.7
Exploit StatusProof of Concept Available
CISA KEV StatusNot Listed
Affected Componentsatomic_agents/agent.py

References & Sources

  • [1]GitHub Security Advisory GHSA-j659-8xh6-5pq5
  • [2]Repository Advisory Details
  • [3]Project GitHub Release Notes (v1.1.0)
  • [4]Source Code Repository

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 6 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
4 views•10 min read
•about 7 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
5 views•12 min read
•about 8 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
5 views•12 min read
•about 9 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 10 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
9 views•10 min read
•about 11 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
5 views•9 min read