A high-severity denial-of-service vulnerability in vLLM versions 0.10.1 through 0.30.x allows remote clients to exhaust preprocessing workers when serving Cohere2 Vision models by submitting small image requests with large, request-controlled max_patches values. The vendor released version 0.31.0 to fix the issue.
Quick Take
- What: vLLM versions 0.10.1 through 0.30.x forward a request-controlled
mm_processor_kwargs.max_patchesvalue to the Hugging Face processor for Cohere2 Vision models without a server-side upper bound, causing quadratic CPU work during multimodal preprocessing. - Who is affected: Operators running vLLM Python OpenAI-compatible servers that serve Cohere2 Vision models and accept image chat-completion requests.
- Impact: Remote clients can send small image requests with large, varying
max_patchesvalues to bypass the LRU cache, exhaust preprocessing workers, substantially increase request latency, and deny service to other clients. - Fixed version: 0.31.0
- What to do: Upgrade to vLLM 0.31.0 or later if you serve Cohere2 Vision models.
In plain English
vLLM is a Python library that serves large language models, including vision models that process images. A flaw in versions 0.10.1 through 0.30.x lets anyone who can send image chat requests include a special parameter with a very large number. The server does not check this number before using it in a calculation that takes much longer for larger values. An attacker can send many small requests with different large numbers to overwhelm the server’s image-processing workers, making the service slow or unavailable for everyone else.
What you should do: If you run vLLM to serve Cohere2 Vision models, upgrade to version 0.31.0. If you do not use vLLM or do not serve Cohere2 Vision models, you can ignore this issue.
What happened
The vLLM project disclosed CVE-2026-126397 on October 27, 2026, and published details in GitHub Security Advisory GHSA-9g3c-x747-c6wr. The vulnerability affects vLLM versions from 0.10.1 up to but not including 0.31.0.
When vLLM serves a Cohere2 Vision model through its Python OpenAI-compatible frontend, it accepts a ChatCompletionRequest that includes an optional mm_processor_kwargs dictionary. This dictionary is defined as an unrestricted dict[str, Any] and can contain a max_patches key with any positive integer value supplied by the client.
The server forwards this request-controlled value directly to the Hugging Face processor without applying a server-side upper bound. The processor then enumerates candidate tile aspect ratios using two nested loops, both of which have bounds controlled by max_patches. This design causes the preprocessing work to grow quadratically with the supplied value.
Because the expensive enumeration occurs during request preprocessing, before the request reaches normal model execution, a small request body can trigger work disproportionate to its size. Clients can also vary the max_patches value across requests to avoid reuse of the helper’s small LRU cache, further amplifying the impact.
The issue was rechecked on September 8, 2026, against upstream main commit f6326f53bda46898a331c2d24500332c285d9a2b. The vulnerable data flow was present at that revision.
What you should do
Upgrade to vLLM version 0.31.0 or later if you are running a vLLM server that serves Cohere2 Vision models and accepts image chat-completion requests.
The default vLLM server does not require an API key. If you have configured API authentication, exploitation requires a client authorized to call the affected endpoint. Review your access controls and logs for unusual patterns of image requests with large mm_processor_kwargs.max_patches values.
What it means
CVE-2026-126397 is a high-severity denial-of-service vulnerability with a CVSS v3.1 score of 7.5 and a CVSS v4.0 score of 8.7. The flaw does not permit code execution, confidentiality impact, or integrity impact.
The issue is model-specific and affects only deployments serving Cohere2 Vision models. Operators serving other models or not using the multimodal preprocessing path are not affected.
The vulnerability demonstrates a common pitfall in AI serving infrastructure: accepting request-controlled computational budgets without server-side validation. The quadratic complexity of the preprocessing step, combined with the ability to bypass caching, makes this a practical denial-of-service vector for remote attackers.



