Anthropic launched its official Claude Code plugin directory in early 2026, turning the terminal-based AI coding assistant into an extensible platform. As of July 17, the official claude-plugins-official marketplace lists 256 entries: 36 internal Anthropic plugins and 220 external listings. The community ecosystem includes directories such as wshobson/agents, which publishes 94 plugins spanning language tooling, external integrations, and multi-agent orchestration. Together they let developers customize Claude Code for specific workflows without modifying the core client.
What is the Claude Code Plugin Ecosystem?
Claude Code is an agentic coding tool that lives in the terminal, understands codebases, and helps developers code faster through natural language commands. (GitHub. “Claude Code Repository.”) The plugin ecosystem extends this foundation through a modular architecture that allows developers to add custom capabilities without modifying core functionality.
The official marketplace is available under the reserved name claude-plugins-official, while third-party marketplaces can be added with /plugin marketplace add. Plugins are distributed through catalogs that provide centralized discovery and version resolution. The marketplace documentation supports relative directories, GitHub repositories, generic Git URLs, repository subdirectories, and npm packages as plugin sources.
The ecosystem supports multiple extension types:
| Extension Type | Description | Example Use Cases |
|---|---|---|
| Skills | Custom slash commands with specialized instructions | Code review, deployment workflows |
| Agents | Specialized AI assistants for specific domains | Security auditing, architecture review |
| MCP Servers | Model Context Protocol connections to external services | GitHub, Slack, databases |
| LSP Servers | Language Server Protocol for code intelligence | TypeScript, Python, Rust |
| Hooks | Automated triggers based on tool events | Post-save validation |
How Does the Plugin System Work?
The plugin architecture operates on a two-level marketplace system. First, users add a marketplace catalog using /plugin marketplace add <source>, which registers available plugins without installing them. Second, users install individual plugins with /plugin install plugin-name@marketplace-name.
Installed marketplace plugins are copied into ~/.claude/plugins/cache/ rather than executed in place. A conventional plugin directory can contain the following components (Claude Code reference):
plugin-name/├── .claude-plugin/│ └── plugin.json # Plugin metadata├── .mcp.json # MCP server configuration (optional)├── commands/ # Slash commands (optional)├── agents/ # Agent definitions (optional)├── skills/ # Skill definitions (optional)└── README.md # DocumentationThe plugin.json manifest defines metadata, version information, and component locations. A marketplace’s marketplace.json catalogs plugins and their sources. Claude Code resolves a plugin version from the plugin manifest, the marketplace entry, or the source commit, in that order; this makes an explicit version bump part of the release process rather than an optional label. (Claude Code reference)
The Model Context Protocol (MCP) Foundation
Claude Code plugins build on the Model Context Protocol (MCP), an open standard Anthropic developed for connecting AI applications to external systems. MCP functions like a USB-C port for AI, providing standardized connections to data sources, tools, and workflows. (Model Context Protocol. “What is MCP?”)
An MCP server is only one component a plugin can bundle. Skills and agents add model instructions, hooks run deterministic lifecycle actions, and LSP servers provide code intelligence. Packaging them together is the practical advantage: a team can version the instructions, tool connection, and automation policy as one installable unit.
What Plugins Are Available?
As of July 2026, the ecosystem spans multiple categories with plugins maintained by both Anthropic and the community.
Official Anthropic Plugins
The official marketplace includes several plugin categories (GitHub):
Code Intelligence Plugins enable automatic diagnostics and code navigation through Language Server Protocol (LSP) connections. Supported languages include TypeScript, Python, Go, Rust, C/C++, Java, C#, Kotlin, PHP, Lua, and Swift.
External Integration Plugins bundle pre-configured MCP servers:
- Source control: GitHub, GitLab
- Project management: Jira, Confluence, Asana, Linear, Notion
- Infrastructure: Vercel, Firebase, Supabase
- Communication: Slack
- Monitoring: Sentry
Development Workflow Plugins add commands and agents for common tasks like git commit workflows, PR review toolkits, and plugin development tools.
The claude-plugins-official repository is split into two directories: /plugins for Anthropic-developed extensions and /external_plugins for vetted third-party contributions, including integrations from Supabase, Firebase, Discord, and Telegram. Internal plugins are developed and maintained by Anthropic directly; external plugins must meet quality and security standards for approval before listing. (GitHub)
Official vs. Community Marketplaces
Understanding when to use each distribution channel helps teams balance breadth against trust:
| Dimension | Official (claude-plugins-official) | Community (e.g., wshobson/agents) |
|---|---|---|
| Curation | Anthropic-reviewed; standards-gated listing | Author-maintained; no central review |
| Plugin count | 256 entries (36 internal, 220 external) | 94 in wshobson/agents |
| Specialization depth | Broad integrations; general workflow | Deep domain expertise (e.g., 16 Python skills) |
| Update cadence | Tied to Anthropic release cycle | Author-driven; can be faster for niche tools |
| Enterprise suitability | Pre-approved for strictKnownMarketplaces | Requires explicit admin allowlisting |
| Best for | Teams needing vetted, stable integrations | Individual developers optimizing a specific stack |
Community Plugin Marketplaces
The largest community marketplace is wshobson/agents, featuring 94 plugins with 203 agents, 175 skills, 109 commands, and 16 multi-agent orchestrators. (GitHub) This marketplace demonstrates the ecosystem’s depth (for more on the skills architecture powering these agents, see Specialized Skills for Claude Code):
| Category | Example Coverage |
|---|---|
| Development | Backend, frontend, debugging, multi-platform |
| Languages | Python, JavaScript/TypeScript, Rust, Go |
| Infrastructure | Kubernetes, cloud, CI/CD |
| AI & ML | LLM apps, agent orchestration, MLOps |
| Security | Scanning, compliance, auditing |
| Workflows | Git, full-stack, TDD, multi-agent teams |
The marketplace has also outgrown Claude Code. The same Markdown source now generates native packages for OpenAI Codex CLI, Cursor, OpenCode, Gemini CLI, and GitHub Copilot, so a plugin written once runs across all of them. (GitHub)
Why Does the Plugin Ecosystem Matter?
The plugin architecture addresses three fundamental challenges in AI-assisted development:
1. Context Preservation
Subagents and specialized skills run in isolated contexts, preventing the main conversation from being cluttered with exploration results or intermediate steps. When Claude delegates to an Explore agent for codebase analysis, that work happens in a separate context window, with only the summary returned to the main session.
2. Specialization Without Bloat
The progressive disclosure architecture ensures only relevant capabilities load into context. A Python development plugin loads 3 agents and 16 skills, not the entire marketplace. (GitHub) This keeps Claude Code responsive while enabling deep expertise when needed.
3. Enterprise Control
Organizations can enforce plugin restrictions through managed settings. The strictKnownMarketplaces configuration allows administrators to:
- Block all marketplace additions (
[]) - Allow specific approved marketplaces only
- Permit all marketplaces from internal git servers via regex patterns
Installation and Getting Started
Installing Claude Code itself through npm is deprecated; the project recommends its native installers instead. (GitHub) Plugins can be installed through the interactive UI or CLI:
# Add the official marketplace/plugin marketplace add anthropics/claude-plugins-official
# Install a specific plugin/plugin install <plugin-name>@claude-plugins-official
# Browse available plugins/pluginPlugins support three installation scopes:
- User scope: Available across all projects (default)
- Project scope: Shared with all repository collaborators
- Local scope: Available only in the current repository, gitignored
Use the --scope flag to specify a target:
# Install for the current project team (committed to .claude/settings.json)/plugin install <plugin-name>@claude-plugins-official --scope project
# Install locally without sharing via git/plugin install <plugin-name>@claude-plugins-official --scope localChecking What’s Installed
The /plugin command opens the interactive plugin UI. For scripted inspection, claude plugin list --json returns installed plugins and claude plugin details <name> shows the component inventory and projected token cost. The details output separates always-on listing cost from the tokens consumed when a skill or agent is invoked. (Claude Code reference)
For a hands-on tour of writing your own marketplace, see our companion piece on Claude Code skills and our walkthrough of Anthropic’s official extension model for the policy-level differences between official and community marketplaces.
How to Audit a Plugin Before Installation
A marketplace listing is distribution metadata, not a sandbox or a security guarantee. The official repository says external plugins must meet listing standards, but it also warns that Anthropic does not control the MCP servers, files, or other software bundled by third parties. Treat every plugin as code that will run with your account’s permissions.
Before installation, inspect four surfaces:
- Instructions: Read every skill, command, and agent definition. Look for broad tool permissions, hidden network calls, and instructions that attempt to override repository policy.
- Deterministic execution: Review hooks, MCP server launch commands, package install scripts, and referenced binaries. These execute outside the model’s prose layer and can be more consequential than a suspicious prompt.
- Source pinning: Check how the marketplace resolves the plugin version. An explicit version or commit pin is easier to audit than a moving branch. Claude Code stores installed versions separately and removes orphaned cache entries after a grace period, but that does not make an unreviewed update safe. (Claude Code reference)
- Scope: Start at local scope, verify the installed inventory with
claude plugin details, and promote to project scope only when the repository is prepared to share the dependency with every collaborator.
Enterprise allowlists reduce accidental installation but do not replace code review. A compromised approved marketplace can still distribute a malicious update. The useful control is a narrow allowlist combined with version pinning, reviewable ownership, and an update process that rechecks changed hooks and executable dependencies.
For shared repositories, record the marketplace source, selected plugin version, approving owner, and review date next to the project-scope configuration. That small inventory makes an unexpected update diagnosable and gives security teams a concrete dependency list instead of forcing them to reconstruct plugin state from individual developer machines after an incident.
Frequently Asked Questions
Q: Are Claude Code plugins free to use? A: A marketplace can list plugins without charging for the package, but individual plugins may depend on paid APIs or external services. Claude Code usage is billed according to the user’s existing plan or API arrangement.
Q: Can I create and distribute my own plugins? A: Yes. Create a marketplace.json file in a GitHub repository, define your plugins with their sources, and share the repository. Users add your marketplace with /plugin marketplace add owner/repo.
Q: How do plugins differ from MCP servers? A: Plugins are a Claude Code-specific packaging format that can bundle MCP servers along with skills, agents, and hooks. MCP servers are the underlying protocol implementation that can be used by any MCP-compatible client.
Q: What security measures exist for plugins? A: Plugins execute with user permissions. Anthropic recommends reviewing plugin code before installation, especially from third-party sources. Enterprise users can restrict marketplace access through strictKnownMarketplaces settings, and individual users can disable specific skills through permission rules.
Q: Can plugins modify Claude’s core behavior? A: Plugins extend capabilities but cannot modify core Claude Code functionality. They add commands, agents, and integrations while the base tool behavior remains unchanged.
