Summary
The A2U (Agent-to-User) event stream server in PraisonAI exposed all agent activity over multiple HTTP endpoints without any authentication controls.
An attacker who can reach these endpoints could passively view live and historical agent events and metadata, potentially leaking sensitive user interactions and system behavior.
Affected context
This vulnerability affects PraisonAI deployments using the A2U event stream component where the A2U HTTP endpoints are reachable from a network an attacker can access.
The issue arises in environments where:
- The A2U service is deployed as part of a multi-agent teams setup
- A2U routes are exposed on an internal or external network interface
- No additional reverse-proxy or network-layer authentication is enforced in front of the A2U endpoints
In such setups, the affected endpoints could be queried by any party able to connect to the service port.
Exploit preconditions
- Attack surface: HTTP endpoints exposed by the A2U event stream server:
/a2u/info/a2u/subscribe/a2u/events/{stream_name}/a2u/events/sub/{id}/a2u/health- Required access: Network-level access to the PraisonAI A2U service (e.g., same LAN, VPN, or Internet, depending on deployment).
- Trigger point: Sending ordinary HTTP requests (GET/subscribe) to the listed endpoints; no credentials or session are required.
- Why exploitation is possible: The
create_a2u_routes()function registers the A2U routes without any authentication or authorization checks, so the server does not verify user identity or enforce access policies before streaming agent activity.
Why this happens
The root cause is a missing authentication and authorization layer on the A2U event stream endpoints.
In the create_a2u_routes() function, routes are registered and exposed publicly without enforcing any security middleware or token validation.
This aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, where data intended only for authenticated or privileged users is made available to any requester.
Conceptually, the design assumes a trusted environment but fails to codify that trust boundary in the application logic, leaving sensitive agent-to-user activity streams unprotected.
Potential impact
- Unauthorized viewing of live agent activity streams and events
- Disclosure of user queries, prompts, and responses handled by agents
- Exposure of internal system metadata, stream identifiers, and operational details
- Leakage of potentially sensitive business logic or workflow patterns used by multi-agent teams
- Facilitation of further attacks via insight into system behavior and interaction flows
General mitigation guidance
Addressing this class of vulnerability generally involves enforcing strong access control at the application and deployment layers.
Common patterns include:
- Wrapping all event-stream and introspection endpoints in mandatory authentication (e.g., API keys, OAuth, JWT) and role-based authorization.
- Applying a default-deny policy for new routes, requiring explicit opt-in for public exposure.
- Segmenting internal observability or event-stream endpoints onto private networks or service meshes, inaccessible from the public Internet.
- Minimizing the amount of sensitive data carried over diagnostic or informational endpoints, and redacting user content where possible.
- Using least-privilege principles for any client allowed to subscribe to A2U streams, restricting them to only the streams they are intended to consume.
How teams detect issues like this
Organizations can detect and monitor for similar issues through a mix of review and automated checks:
- Static analysis & code review:
- Flag route registrations that omit authentication/authorization middleware, especially for endpoints returning live data streams.
- Review functions such as
create_*_routes()for assumptions about trusted networks that are not enforced programmatically. - Configuration and policy enforcement:
- Define security policies requiring all non-health endpoints to verify identity and authorization.
- Use API gateway configurations that require tokens or keys for access to streaming or event endpoints.
- Runtime monitoring:
- Log and alert on unusual subscription patterns or accesses from unexpected IP ranges.
- Periodically run internal security scans or API discovery tools to identify unauthenticated endpoints exposing non-trivial data.

