Join our Newsletter — 33% off our NHI Course
Agentic AI & Autonomous Identity

Agent Plugin

← Back to Glossary
By NHI Mgmt Group Updated October 30, 2026 Domain: Agentic AI & Autonomous Identity

An agent plugin is a packaged bundle of skills, tools, and MCP server configuration that can be installed into a client. In identity terms, it is not just software distribution, but a runtime access object whose risk depends on the client’s policy, secret handling, and tool-scoping decisions.

What an agent plugin actually is

An agent plugin is best understood as an installable runtime capability, not just a software add-on. It packages skills, tools, and MCP server configuration into something a client can load, which means the plugin can expand what the agent is able to reach, invoke, or delegate at runtime.

That matters because the security boundary is not the package alone, but the combination of the plugin, the client policy, and the secrets or credentials the client is willing to expose to it. In other words, the plugin becomes part of the agent’s access surface the moment it is installed.

Why agent plugins change the security model

Traditional plugins usually extend product features. Agent plugins can extend authority. If the plugin can call tools, reach an MCP server, or access bearer tokens and other secret material, it can influence external systems on the user’s behalf. That shifts the risk from ordinary code execution toward delegated action and scoped trust.

Because of that, the real question is not only whether the plugin is malicious, but whether it is over-scoped, poorly validated, or allowed to use more tool power than the task requires. A plugin that is technically legitimate can still create excessive access if the client treats it as trusted by default.

The same issue appears in tool selection and prompt-driven orchestration, where the agent may invoke functions that were never meant to be broadly available. AI Agent Tool and Plugin Security Guide is useful background for understanding how tool permissions, validation, and sandboxing shape this runtime boundary.

How exposure is created in practice

Exposure usually comes from three places: the plugin’s source, the permissions it requests, and the secrets or sessions it can touch once installed. A plugin distributed through a marketplace or repository may be fine on paper, yet still become dangerous if it can exfiltrate tokens, shadow approved tools, or call broader infrastructure than intended.

That is why plugin review should focus on what the bundle can do after installation, not only on whether the package is signed or the vendor is known. Marketplace trust, token handling, and tool scoping all interact, especially when the plugin can speak to external services through MCP configuration.

History shows that plugin ecosystems can become a delivery path for credential theft. For example, JetBrains Marketplace AI Plugin Campaign shows how malicious plugins can use legitimate distribution channels to steal secrets at scale, while JetBrains GitHub plugin token exposure illustrates how a plugin flaw can turn into token exposure and account risk.

What good governance looks like for agent plugins

Governance for agent plugins should start from the assumption that installation is a delegation decision. The client needs to decide which plugin classes are allowed, which tools they may call, what secret material they may read, and whether human approval is needed for higher-impact actions.

That is especially important when plugins are used inside coding assistants, IDE clients, or workflow agents, because the same plugin may be safe for one task and unsafe for another. Scoped permissions, explicit tool allowlists, and lifecycle review for plugin updates are all part of keeping the runtime boundary intelligible.

Related guidance on agent operating models can help teams separate product convenience from authority. AI Agent Authorisation Guide explains why least privilege, per-action decisions, and delegated authority matter when software is allowed to act for a user.

How to think about agent plugins during review

When reviewing an agent plugin, treat the package as an access object with behavior, not as inert software. Ask what it can read, what it can invoke, where it can send data, and whether its tool access is broader than the user’s intent.

That perspective also helps distinguish trustworthy extensibility from hidden privilege escalation. A plugin that only adds a narrow, well-scoped capability is very different from one that inherits broad client trust, silent secret access, or unsupervised tool reach.

For teams building or selecting agents, a wider control view is useful. AI Coding Agents Security Guide and AI Agent Observability, Audit and Incident Response Guide both help frame the operational questions that follow once plugins begin to influence real actions and real secrets.

Risk and Threat Considerations

Agent plugins can become a direct compromise path because they sit at the intersection of code execution, tool access, and secret handling. If a plugin is malicious, tampered with, or simply over-permissioned, it can misuse the client’s trust to reach external systems, exfiltrate credentials, or trigger actions the user did not intend.

Failure mechanism: The plugin inherits broad runtime trust, then abuses exposed tools, MCP connections, or cached secrets to move from benign extension to unauthorized action or data theft.

Impact: The result can be token theft, unauthorized downstream actions, persistence through installed tooling, and a widened blast radius across every system the client can reach on the user’s behalf.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

OWASP Agentic AI Top 10 and OWASP Non-Human Identity Top 10 define the specific risk controls and attack patterns relevant to this term.

FrameworkControl / ReferenceRelevance
OWASP Agentic AI Top 10ASI03 — Identity & Privilege AbuseAgent plugins can expand an agent's authority and tool reach.
ASI02 — Tool MisusePlugins package tools and MCP configuration that agents can invoke.
ASI04 — Agentic Supply Chain VulnerabilitiesMarketplace-delivered plugins can be a supply-chain delivery path.
Recommendation — Enforce per-action authorization for plugin-invoked capabilities and reject excess privilege. Restrict plugin tool access to approved actions and validate every tool invocation. Vet plugin provenance and update channels before allowing installation into clients.
OWASP Non-Human Identity Top 10NHI-02 — Secret LeakagePlugins may expose tokens, API keys, and other secret material at runtime.
NHI-05 — Overprivileged NHIA plugin can function as a runtime access object with excessive permissions.
Recommendation — Prevent plugins from reading or exporting secrets beyond the minimum required scope. Minimise plugin permissions and remove any access not needed for the task.

Practitioner Guidance

Why practitioners should care: Treat plugin installation as an authority decision, not a convenience feature. The most important control question is whether the plugin needs the access it is asking for, and whether the client can enforce that boundary at runtime.

Governance implication: Review plugin permissions, tool scope, and secret exposure as part of approval and renewal, especially for plugins that can interact with external APIs, MCP servers, or developer credentials.

Practitioner takeaway: If a plugin cannot be explained in terms of narrowly scoped runtime access, it is probably too powerful for default trust.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Reviewed and updated by the NHIMG editorial team on October 30, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org