Threat Library

LiteLLM's /prompts/test endpoint passes user-controlled input into an unsandboxed jinja2.Environment, allowing an unauthenticated attacker to inject template syntax and execute arbitrary OS commands on the server. Since LiteLLM is widely deployed as an LLM gateway/proxy in front of many AI agent stacks, this gives attackers a direct path to full host compromise without any credentials.

DocsGPT's custom prompt feature renders user-supplied prompt text through Jinja templates without sanitization, allowing an unauthenticated attacker to inject template expressions that execute arbitrary code on the server. This is a classic server-side template injection bug rather than a novel agent-specific attack, but because the vulnerable input is an LLM 'system prompt' customization field, it directly links prompt-engineering surfaces to full RCE. Any deployment exposing this custom prompt feature should be considered fully compromised until patched.

LaVague, an LLM-driven web browsing agent, contains a critical flaw where Python code extracted from LLM-generated markdown is executed without validation or sandboxing. Because the LLM's output is influenced by untrusted web page content, an attacker who controls a web page can smuggle malicious instructions that get translated into arbitrary code execution on the operator's machine. This is a textbook indirect prompt injection escalating directly to remote code execution.

Attackers are actively exploiting an unauthenticated remote code execution vulnerability (CVE-2026-0768) in Langflow, a popular open-source framework for building AI agent workflows. Successful exploitation allows attackers to execute arbitrary code on exposed Langflow instances and harvest sensitive credentials such as OpenAI and AWS keys stored in the environment. This poses a critical supply-chain risk to organizations running AI application pipelines built on this framework.

MCPHub, a management hub for MCP servers, fails to restrict server configuration endpoints to admin users and does not sanitize the command/args used to spawn MCP server processes. Any authenticated non-admin user can register a malicious MCP server configuration that MCPHub immediately executes, resulting in full remote code execution as the host's OS user, often root. This is a critical, easily exploitable authorization flaw with a severe real-world impact.

Eclipse Theia's AI Agent Mode file-editing tools fail to validate that model-supplied file paths stay within the workspace, allowing a malicious or manipulated model output to write or delete arbitrary files on the host. Since these tools execute without user confirmation, an attacker who can influence model output via indirect prompt injection can escalate to full code execution on the backend by overwriting files like shell startup scripts or SSH authorized_keys. This is a critical, high-impact vulnerability combining a classic path traversal flaw with the AI-specific attack surface of untrusted model-controlled tool arguments.

The ash_ai library for the Elixir Ash framework evaluates user-influenced prompt content as live EEx templates, allowing an unauthenticated remote attacker to inject Elixir code that executes on the server before any LLM call is made. This is a classic code injection flaw exposed through an AI agent's prompt-construction pipeline, not a prompt injection against a model itself, but it is trivially reachable via any agent action that lets request data flow into a prompt template. Any deployment using ash_ai versions before 1.0.0 with dynamic prompt content is at critical risk of full server compromise.

A critical flaw in IBM Langflow OSS allows an authenticated user to escalate from limited flow-building privileges to full arbitrary command execution on the server. By crafting a malicious 'type' field in a saved flow and triggering a build via a wrapper flow, an attacker bypasses the LANGFLOW_ALLOW_CUSTOM_COMPONENTS=false safeguard intended to block custom code execution. This effectively hands the attacker OS-level control of the agent server process.

IBM Langflow versions 1.0.0 through 1.11.1 contain a critical flaw in the Agent-to-Agent (A2A) public endpoint that fails to properly enforce security restrictions, allowing a remote unauthenticated attacker to execute arbitrary code. With a CVSS score of 9.8, this is a severe, easily exploitable vulnerability that could grant full control of the affected system.

The Telnyx MCP server listened on all network interfaces without enforcing caller authentication, allowing any network-reachable client to invoke tools without credentials. Because the server forwarded its own stored Telnyx API key, client secret, and code-execution key to upstream services on every dispatch, an unauthenticated attacker could execute privileged actions and code as if they were a legitimate caller. This is a critical, unauthenticated remote compromise of an AI tool-serving component.

ToolUniverse's python_code_executor tool exposes a Python sandbox that can be trivially escaped using the classic __class__.__base__.__subclasses__() technique to reach process and subprocess modules, because its security relies on an incomplete denylist rather than real isolation. This sandbox is served over HTTP and MCP endpoints that bind to all network interfaces with no authentication and debugging enabled, meaning any network-reachable attacker can achieve full remote code execution as the server process. This is a maximum-severity, trivially exploitable vulnerability with no prerequisites.

The mcp-router CLI's serve command bound to all network interfaces by default and only enforced authentication if an operator explicitly requested it, meaning a standard invocation exposed the MCP aggregator and every downstream MCP server it fronts to anyone who could reach the port. This is a straightforward insecure-default configuration flaw rather than a novel attack technique, but its impact is severe because it grants unauthenticated network access to an aggregation point for multiple MCP tool servers. Version 0.6.3 fixes this by defaulting to loopback binding and refusing non-loopback starts without a token.

Agno versions up to 2.5.8 allow an unauthenticated attacker to achieve remote code execution by embedding malicious instructions in content the agent processes, such as a web page or document. Because LLM-generated arguments are passed unsanitized into exec(), runpy.run_path(), and subprocess.run(), the agent itself becomes the execution vector for attacker-controlled code. This is a critical, actively exploitable framework vulnerability with no authentication required.

A vulnerability in gpt-researcher (v0.14.7 and earlier) allows an unauthenticated remote attacker to achieve code execution by sending malicious Model Context Protocol configurations through the application's WebSocket endpoint. Because the endpoint lacks authentication, any network-reachable attacker can trigger this without valid credentials, making it a high-impact, low-effort exploitation path.

Researchers demonstrated that a simple malicious website summary request can hijack Claude Code Opus 5's 'Auto Mode' and achieve remote code execution with a 60-80% success rate. This directly contradicts Anthropic-commissioned third-party evaluations that reported a 0.00% prompt injection success rate, showing the safety classifier that replaced human approval prompts is far more bypassable in practice than claimed.

Google's langfun library (versions before 0.1.2) evaluates Python expressions generated by an LLM in response to lf.query prompts without any sandboxing. A remote unauthenticated attacker who can influence prompt input can cause the model to emit malicious Python code that gets executed directly in the host application, resulting in full arbitrary code execution.

The Nextcloud MCP Server's webhook endpoint lacks authentication by default because a required secret defaults to None, letting any network attacker send forged requests. These forged requests can delete or force re-indexing of another user's semantic search embeddings in Qdrant, effectively destroying or manipulating the AI assistant's retrieval memory. This is a critical, unauthenticated remote vulnerability fixed in version 0.117.2.

mcp-shell, an MCP server designed to run shell commands securely, contains a filter bypass that allows a malicious or compromised caller to execute arbitrary OS commands via a crafted Git alias, even with 'secure mode' enabled. Because the default Docker deployment includes Git and runs the vulnerable filters out of the box, any agent or user with MCP connectivity to the tool can achieve full arbitrary code execution as the mcpuser process. This is a critical tool-layer vulnerability affecting the trust boundary between an AI agent and the command-execution tool it calls.

mcp-shell, an MCP server that exposes shell command execution to LLM agents, ships with security disabled by default and the documented installation steps never enable it. As a result, any LLM or agent connected to a default deployment can run arbitrary OS commands as the mcp-shell process user, giving effectively unrestricted remote code execution through a trusted tool interface. The issue is fixed in version 0.6.0.

QWED, an infrastructure component used to verify LLM/agent tool outputs and math expressions before production execution, passes untrusted expressions directly to SymPy's parse_expr() without restricting namespaces, allowing arbitrary Python code execution in the API server. Because signup and API key issuance are open by default, any external attacker can register a tenant, obtain a valid API key, and trigger remote code execution via the math verification endpoints, fully compromising the server and other tenants in shared deployments.