Summary
NousResearch hermes-agent up to 2026.4.30 contains an input injection vulnerability in the _serve_plugin_skill/skill_view handler within tools/skills_tool.py.
Remote attackers can manipulate skill-related inputs to inject crafted data into downstream interpreters or execution contexts, potentially leading to unauthorized actions or responses by the agent.
Affected context
The vulnerability occurs in deployments of hermes-agent (through version 2026.4.30) that expose the plugin/skill-serving functionality, particularly the _serve_plugin_skill/skill_view endpoint in tools/skills_tool.py.
It is relevant whenever external clients or integrated services can supply parameters or payloads that the agent uses to invoke skills, tools, or plugins, and where those values are passed into downstream processing components without strict validation, encoding, or constraints.
Exploit preconditions
- Attack surface: Network-accessible hermes-agent instances exposing plugin/skill endpoints.
- Required access: Ability to send crafted requests or messages to the
_serve_plugin_skill/skill_viewcode path (e.g., via HTTP, WebSocket, or an integrated API gateway). - Trigger point: Submission of malicious input fields (such as skill identifiers, arguments, or configuration values) that the endpoint incorporates into subsequent operations without proper sanitization or contextual encoding.
- Why exploitation is possible: The endpoint appears to directly propagate attacker-controlled data into internal interpreters, templating logic, or execution environments, aligning with CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component) and CWE-707 (Improper Neutralization at Multiple Layers).
Why this happens
At its core, this is an injection bug where user-controlled input is not correctly constrained or neutralized before being used by downstream components.
The _serve_plugin_skill/skill_view function likely takes parameters such as skill names, arguments, or configuration fragments and passes them into interpreters, command wrappers, prompt templates, or plugin dispatch logic.
Because these values are treated as trusted, special characters or structured payloads can alter how the downstream component parses or executes them, which matches the CWE-74 pattern of improper neutralization.
CWE-707 highlights that multiple layers (request parsing, skill routing, and underlying tool invocation) may each lack robust input handling, compounding the risk and making injection easier.
Potential impact
- Remote triggering of unintended plugin or skill executions with attacker-controlled parameters.
- Manipulation of the agent's behavior, including data exfiltration, unauthorized actions, or misleading responses.
- Potential access to sensitive internal data that the agent or its tools can reach.
- Abuse of integrations (e.g., databases, external APIs, or automation backends) invoked by skills, possibly leading to data modification or service misuse.
- Expanded attack surface for chaining into more severe impacts, depending on what underlying tools or environments skills can control.
General mitigation guidance
Risk reduction for this class of injection issues centers on strict input handling and careful boundary control between the agent and its skills or tools.
Recommended patterns include:
- Constraining inputs: Treat skill identifiers, arguments, and configuration values as untrusted and validate them against allowlists, schemas, or strict type checks before use.
- Contextual encoding and neutralization: When passing user data into templating, interpreters, or any execution-like context, apply encoding/escaping appropriate to that context so special control characters cannot alter logic.
- Clear separation of data and control: Design skill interfaces so that control flow (which skill to call, what operation to perform) is decided by static mappings rather than user-provided strings wherever possible.
- Principle of least privilege: Ensure skills and plugins run with minimal privileges and narrowly scoped capabilities so that even if injection occurs, the blast radius is limited.
- Defensive defaults: Disable or restrict dynamic skill discovery and arbitrary parameter forwarding from external inputs; require explicit configuration for any high-risk tool or integration.
How teams detect issues like this
Effective detection relies on a combination of code-centric and behavior-centric approaches:
- Static analysis patterns:
- Flag functions that route or dispatch based on unvalidated external input (e.g., dynamic lookup of skills or tools from user-provided strings).
- Detect concatenation or direct interpolation of user data into templates, command-like strings, or interpreter calls used by skills.
- Highlight any code paths that pass raw request parameters into plugin execution APIs or dynamic evaluators.
- Code review signals:
- Endpoints where external inputs map directly to skill or tool selection, or where caller-provided parameters are forwarded without transformation.
- Lack of schema validation, type coercion, or allowlist checks for skill names, parameters, or configuration blocks.
- Complex, multi-layer flows (HTTP → agent → tool) where input validation appears only at the perimeter or is entirely missing.
- Policy and automated review:
- Establish secure coding guidelines that prohibit dynamic execution or interpretation of user-controlled data within skills or plugins.
- Use automated code review tools or CI checks to enforce validation and encoding patterns on exposed endpoints and plugin interfaces.

