Skip to main content

AG-UI Community SDK CVE-2026-101099

| EUVDEUVD-2026-88369 MEDIUM
Improper Handling of Exceptional Conditions (CWE-755)
2026-09-28 VulDB GHSA-pcr3-24cw-387c
5.3
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Client connects to malicious/MitM SSE endpoint
  2. Delivery
    Server streams unbounded oversized SSE line/event
  3. Exploit
    Parser buffers payload without size cap
  4. Execution
    Client memory exhausted
  5. Impact
    Denial of service on client process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling procedures
Exploitation Conditions

Exploitation requires the AG-UI Kotlin/Java client (HttpAgent / SseEventParser) to consume a Server-Sent Events response from an attacker-controlled or man-in-the-middle-positioned agent endpoint. The client must connect to that endpoint (the trust flows from server to client), and the attacker supplies an oversized SSE wire line or decoded event data payload. What limits exploitation: impact is confined to availability (memory exhaustion) of the client process, with no confidentiality or integrity effect; the attacker must be in a position to serve or intercept the SSE stream; and the pre-patch default has no caps whereas patched deployments can set SseLimits (default 1 MiB/line, 8 MiB/event) to neutralize it.

Impact

This is a memory-exhaustion / unbounded-buffering defect (CWE-755) in the SSE parser (SseParser.kt / SseEventParser) of the AG-UI Kotlin/Java Community SDK. The fix in PR #2657 introduces SseLimits that bound each SSE wire line to 1 MiB and each decoded event data payload to 8 MiB - confirming that the pre-patch client buffered SSE lines/events without any size cap, allowing a malicious or MitM agent endpoint to feed an oversized stream and drive the client into out-of-memory / resource exhaustion. This is a reverse-trust availability issue: the vulnerable party is the HTTP client consuming the Server-Sent Events response, not a server. The vendor CVSS 4.0 vector (5.3) scores impact as VA:L only (no confidentiality or integrity), which is consistent with a bounded, non-catastrophic DoS. No EPSS score, no CISA KEV listing, and no public exploit code are provided - status is 'no public exploit identified at time of analysis'. The 'Information Disclosure' tag conflicts with the actual impact profile (VC:N in the vendor vector; the fix is purely about size limits), so that tag appears mislabeled. Real-world risk is modest: it requires the client to connect to an attacker-controlled or intercepted SSE stream, the impact is limited to availability of the client process, and the fix is still an unmerged PR at time of analysis.

Exploit ScenarioDerived

An application using the AG-UI Kotlin/Java Community SDK's HttpAgent connects to a remote agent endpoint that is attacker-controlled (or intercepted via MitM). The malicious endpoint returns an SSE response containing an enormous single line or event data payload; because the parser applied no size caps, the client buffers it in memory and exhausts heap, degrading or crashing the consuming process. No public exploit code is identified, but the mitigating patch clearly documents the missing bounds.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 28, 2026

Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in-the-middle-positioned agent endpoint drive a client-side memory exhaustion condition, degrading or killing the consuming process. All ag-ui-protocol ag-ui builds up to 2026-09-23 are flagged by CPE, specifically the Kotlin Community SDK SseParser.kt and its Java counterpart SseEventParser, which had no per-line or per-event size caps before the fix. Impact is availability-only (no confidentiality or integrity effect), an upstream fix exists as PR #2657 but was still awaiting acceptance, and no public exploit was identified at time of analysis.

RemediationAI

Adopt the upstream fix in PR https://github.com/ag-ui-protocol/ag-ui/pull/2657 (referenced as the vendor patch) once it is merged and a tagged release is published, then rebuild against that release; because the PR was still awaiting acceptance, verify the released artifact actually contains the SseLimits class before assuming you are fixed - no exact fixed version number is confirmed by the input data. Roll forward by explicitly constructing HttpAgent with a bounded SseLimits (for example 256 KiB per line and 2 MiB per event) instead of relying on pre-patch defaults, since the patched defaults of 1 MiB per line and 8 MiB per event still leave a large allocation window for high-volume streams and there is no lifetime byte budget per stream; the trade-off is that legitimate large agent tool-call payloads can be truncated or errored, so tune caps to observed maximums. On the server side, use the JdkAgentHttpHandler constructor accepting maxRequestBodyBytes and keep the 8 MiB default so oversized requests receive 413 before parsing. Where the SDK cannot be patched, the practical compensating control is to consume SSE only from endpoints you control or that are reached over mutually authenticated TLS, and to front the client with a stream proxy that terminates any connection whose line or event size exceeds a fixed ceiling - accepting that this can break chatty or large-payload agents - while also configuring the underlying JSON Serializer with nesting, token, and string limits so library-level failures surface as SerializationException rather than exhausting memory. Full advisories: https://vuldb.com/vuln/410974 and https://vuldb.com/cve/CVE-2026-101099.

Affected VersionsENISA

ag-ui 2026-09-23

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

AG-UI is a protocol for streaming agent events over HTTP using Server-Sent Events; the affected component is the community Kotlin/Java SDK (sdks/community/java/ag-ui) whose client-side parser reads the SSE byte/line stream and decodes each event's data payload into AG-UI events. The root-cause class is CWE-755 (Improper Handling of Exceptional Conditions): an attacker-supplied SSE stream containing an extremely long wire line or a very large multi-field data payload is accumulated without bound, and the resulting exception or memory pressure is not contained, so the parser/consumer fails. The upstream fix introduces an SseLimits abstraction that bounds every wire line and every decoded event payload by UTF-8 byte count (documented defaults 1 MiB per line and 8 MiB per decoded data payload, with newline bytes between multiple data: fields counted toward the event cap), and adds a matching server-side guard in the JDK HTTP adapter that rejects bodies over 8 MiB with 413 Payload Too Large before parsing. The vendor-published CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, VA:L, E:X, score 5.3) rates this low-severity, availability-only; our independent assessment is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, i.e., remote, low complexity, availability impact only, and exploitation hinges on the client trusting and consuming a hostile SSE stream.

Know when Kotlin 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 (VulDB) PRIMARY 5.3 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 5.3 MEDIUM

Remote malicious/MitM SSE server needs no client-side privileges (PR:N) and no user interaction; unbounded buffering yields availability-only impact (A:L), no C/I effect.

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

A vulnerability was detected in ag-ui-protocol ag-ui up to 2026-09-23. This affects an unknown part of the file SseParser.kt of the component Kotlin Community SDK. Performing a manipulation results in handling of exceptional conditions. The attack may be initiated remotely. The pull request to fix this issue awaits acceptance.

Threat Intelligence Overview

EPSS Score
0.5%
Top 59% exploitable
Prevalence
Low
community Kotlin/Java SDK for an emerging agent-UI protocol, niche footprint
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

27
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

More in Kotlin

View all

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy