Cursor opens its ecosystem: the official plugin spec arrives on GitHub trending (4,700 stars in just a few days)

Cursor opens up its ecosystem: the official plugin spec hits GitHub trending (4,700 stars in a few days)

🔎 A frontier IDE bets on openness — and GitHub validates it

While the community is still arguing over the best model for coding, Cursor just played a different card: opening up its ecosystem. The cursor/plugins repository, which hosts the official Cursor plugin specification and 31 official plugins, climbed to the top spot on the weekly GitHub Trending list with 4,794 stars and +1,693 in a single week (RepoRadar, week 34 of 2026). That's nearly 250 stars per day.

The timing is no accident. The "skills" wave — driven by obra/superpowers, mattpocock/skills, and community agent configs — has dominated GitHub trending for weeks. A frontier IDE publishing its official plugin spec is the next step: the trend becomes a standard.

The stakes go far beyond Cursor. If this spec takes hold, extensibility for coding agents becomes the norm, exactly as VS Code did for editors in 2015. And in this game, whoever controls the registry controls distribution.

Key Takeaways

• The spec is public and official: cursor/plugins defines the Cursor plugin format — .cursor-plugin/plugin.json manifest, skills, rules, and MCP servers — under the MIT license.
• 31 official plugins connect Cursor agents to Gmail, Salesforce, Zoom, HubSpot, DocuSign, GitHub, Playwright, or Google Drive/Calendar (Metallab, August 2026).
• The repository exploded: created on January 23, 2026, #1 in weekly trending with 4,794 stars in late August, then 8,114 stars and +5,182 as of September 19, 2026 (GitNova).
• The open Agent Plugins standard, announced on August 6, 2026 by OpenAI with AWS, GitHub, Vercel, and Cursor as participants, brings together Agent Skills and MCP configuration — Cursor is aligning with it.
• Total convergence: Claude Code (142,000 stars), Codex (114,000 stars), and Cursor are adopting the same extensibility model — skills + MCP.
• The real challenge is the registry, not the spec: the official list of plugins that everyone installs.

Recommended Tools

cursor/plugins: what exactly is it?

It's the public specification and official registry that enable integrating external tools into Cursor via the Model Context Protocol (MCP): standardized manifests, scaffold utilities, and agent workflow plugins (RepoRadar). In other words, the technical contract between Cursor and its future extension ecosystem.

Concretely, each plugin lives in its own folder, with a .cursor-plugin/plugin.json manifest that declares its capabilities. At the root of the repository, a marketplace.json lists all the plugins — enough to imagine a real marketplace built into the IDE one day.

The format: a manifest, skills, rules, and MCP

A plugin's structure reads like the identity card of a complete agent (GitTrend, September 2026):

• plugin.json: the manifest, which declares the plugin and its entry points.
• skills/: SKILL.md folders with frontmatter — the procedures the agent loads on demand.
• rules/: .mdc files — the permanent rules of conduct, versioned.
• mcp.json: MCP server definitions — the plumbing to external APIs.
• README, CHANGELOG, LICENSE: the hygiene of any normal open source project.

Two details show how serious this project is. First, the MIT license: Cursor keeps no lock on the format; anyone can reimplement it. Then there's the create-plugin scaffold, which generates a spec-compliant skeleton — the barrier to entry for publishing a plugin drops to just a few minutes.

The skills/rules distinction deserves a closer look. A rule applies at all times: it's a constraint. A skill loads on demand: it's a procedure. This separation, inherited from community experiments, avoids saturating the agent's context with instructions it won't use. This is mature agent design, not tinkering.

The 31 official plugins: the agent plugged into the enterprise

The most interesting part isn't in the development tools. The 31 official plugins break down into Developer Tools (12, i.e., 39%), Integrations (15, i.e., 48%), Productivity (3, i.e., 10%), and Utilities (1, i.e., 3%) (Metallab, August 2026). Nearly half plug the agent into business tools: Gmail, Salesforce, Zoom, HubSpot, Gong, Clay, DocuSign, Intercom, Ashby, Navan, Circleback — not to mention GitHub, Playwright, and Google Drive/Calendar.

Look at this list for two seconds. Gong and Clay, that's sales prospecting. Ashby, recruiting. Navan, business travel. Circleback, meeting summaries. DocuSign, signatures. When a coding agent can read your tickets, send a meeting recap, and prepare a contract, it stops being a glorified autocomplete. It becomes a universal interface.

My take: it's this "Integrations" block that constitutes the real signal. Cursor keeps the model interchangeable — you can run Claude, GPT, or Gemini in the IDE, and the company is training its internal Composer model in parallel. The model is a commodity. The plugin ecosystem, on the other hand, is the defensive moat.

An off-the-charts trending trajectory

The numbers tell of a remarkably fast acceleration for a specification repository — a genre with a reputation for being thankless:

Around ten contributors and more than 200 commits (RepoRadar): this isn't a showcase repository, it's a maintained project. And 391 open issues and PRs as of September 19 (GitNova) signal a community that isn't content to just watch.

The "skills" wave that paved the way

Cursor isn't inventing anything: it's industrializing. For weeks now, skills repositories — those reusable recipes that agents load on demand — have been occupying GitHub Trending, with obra/superpowers, mattpocock/skills, and the ECC configs among them (see our analysis of the skills invading GitHub trending). The Cursor spec makes official what the community was already tinkering with in its own corners.

The repository, for that matter, already hosts an active community scene. As of August 22, 2026, there were more than 25 standalone integrations (Four Signals): thermos for branch audits, orchestrate for launching cloud agents in parallel, cursor-team-kit for team configurations, or pstack, signed by Lauren Tan, for parallelizable agent workflows. And an unapologetic ralph-loop, dedicated to iterative self-referential loops — the agent that feeds itself, in full transparency.

The continual-learning plugin deserves a closer look: it incrementally updates the agent's memory, from transcripts into AGENTS.md. It's a symptom of a broader movement — agent memory is becoming a product in its own right, as we saw with Hindsight and its 1,653 stars in a single day. Skills, rules, memory: the three layers of the agent are now being built as separate components, versionable and shareable.

Let's be clear about what this implies: when a frontier vendor adopts a hacker community's format, it's not flattery — it's absorption. The question is whether that absorption happens in open source — as is the case here, the MIT license obliging — or through a quiet buyout of the format.

What this concretely changes for developers

Three immediate changes: agents become extensible like editors, team configuration becomes versioned code, and a plugin marketplace opens up. Just that.

Agent extensions, not interface extensions

A VS Code plugin adds buttons and panels. A Cursor plugin adds capabilities: the agent now knows how to call GitHub, drive Playwright, query Salesforce. The boundary between "the IDE" and "what the agent can do" disappears. To choose the agent that suits you, our comparison of the best AI tools for coding remains the best entry point.

This is a change of category, not of degree. Editor extensions improved the developer's working environment. Agent plugins expand the machine's scope of action. You're no longer installing a theme — you're handing over the keys.

Team config becomes versioned code

This is the most underrated change. Today, an agent's configuration — rules, MCP servers, skills — lives in scattered files, somewhere between the local .cursor and meeting notes. With the spec, everything gets versioned: a rules/ folder, an mcp.json, SKILL.md files, in a repository. The new hire clones the project and inherits six months of team experience — which, in 2026, is roughly equivalent to a decade.

Community plugins are already showing the way: thermos industrializes branch review, orchestrate parallelizes cloud agents. Code review, onboarding, audits — everything that used to be human process becomes executable config.

I've seen this dynamic reach absurd scales elsewhere — MiroFish and its 700,000 agents generated in 10 days is the most spectacular illustration — but cursor/plugins is the first case where it's a frontier editor providing the framework. That changes everything: the spec of a dominant editor carries a legitimacy that a hacker project will never have.

A marketplace opens — and it will be meritocratic

The root marketplace.json and the create-plugin scaffold sketch the contours of an economy: publishing a compliant plugin takes minutes, and distribution goes through the official registry. No announced commission, no opaque validation process — for now. Let's make the most of it: open markets rarely stay that way for long.

Claude Code, Codex, Cursor: the convergence on skills

The three major coding agents are converging on the same extensibility model: declarative skills and MCP as the transport. The clearest proof: the open Agent Plugins standard, announced on August 6, 2026 by OpenAI with AWS, GitHub, Vercel, and Cursor as participants, brings together precisely Agent Skills and MCP server configuration in a single format (Metallab).

When OpenAI invites AWS, GitHub, and Vercel to the table, the message is clear: nobody wants to relive the 2024 fragmentation of agent frameworks. One format, multiple engines. By publishing its compliant spec, Cursor chooses to be on board the train rather than on a parallel track.

The ecosystem's numbers capture the scale of the phenomenon (GitHub, September 2026): claude-code tops out at 142,000 stars, codex at 114,000 stars, and the Karpathy-style prompts repository exceeds 205,000 stars. The terminal is waking up too — DeepSeek-TUI exploded with 5,800 stars in a single day, proof that demand for coding agents extends far beyond the confines of the IDE.

On the enterprise side, the hierarchy is already settled: the Gartner Magic Quadrant 2026 places OpenAI Codex, Cursor, and GitHub Copilot as leaders in coding agents (see our MQ 2026 analysis). When market leaders agree on an extension format, it's no longer a trend — it's infrastructure.

And the beauty of it is that the plugins are model-agnostic. Whether you're running Claude Opus 4.7, GPT-5.5, or Gemini 3.1 Pro in Cursor, the same plugins apply — agentic capability remains a matter of the chassis, not the engine. To settle the choice of model under your agents, our guide to the best LLMs for AI agents details the scores: GPT-5.5 dominates the agentic ranking there with 98.2, ahead of Gemini 3 Pro Deep Think and Claude Opus 4.7.

The Real Stakes: Owning the Registry

Anyone can write a spec. What matters is who hosts the registry — the reference list of plugins that developers install en masse. That's the lesson of VS Code: Microsoft's victory in 2015 wasn't the editor, it was the marketplace. Cursor just planted its own, open source and under MIT, which defuses in advance any accusation of lock-in.

The strategy can be read on three levels. The open format (Agent Plugins, MIT) neutralizes the criticism. Distribution (the official registry) captures the value. The integrated experience (the IDE, the Composer model) builds loyalty. It's a classic platform play, executed with disconcerting speed: less than two months between the #1 spot on the weekly trending list and the analysis of the 31 official plugins.

One risk remains that no one can rule out: fragmentation. If Claude Code and Codex each drift toward their own variant of the format, developers will have to maintain three versions of every plugin — and the history of standards shows that this kills ecosystems. The Agent Plugins standard exists precisely to avoid that scenario. Its real test will come the day a popular plugin has to work everywhere without a fork.

For autonomous AI agents in general — not just code — this standardization movement is only just beginning, as covered in our feature on the best autonomous AI agents. Code is merely the first domain where agentic extensibility is becoming normalized. It won't be the last.

How to get started with cursor/plugins in one evening

The most efficient path: read the spec, try a low-risk official plugin, then scaffold your own. Budget an evening, not a sprint.

1. Read the spec at github.com/cursor/plugins: the root marketplace.json gives you the lay of the land, and the README details the manifest and the expected structure.
2. Test a safe official plugin: GitHub or Playwright are the ideal candidates — immediately useful, with no access to your business data.
3. Scaffold your plugin with create-plugin, the official spec-compliant utility: you get the full directory tree (skills, rules, mcp.json) ready to fill in.

git clone https://github.com/cursor/plugins

1. Put your team's config under version control: your rules/ and your mcp.json in the project repo, with a CHANGELOG that traces every decision. That's where the real value lies — not in the plugin, but in the memory it builds up.

One last tactical tip: start with Developer Tools before business Integrations. An agent driving Playwright can do little harm. An agent wired into Gmail and DocuSign deserves proper governance.

❌ Common Mistakes

Mistake 1: Confusing a Cursor plugin with a VS Code extension

A plugin doesn't add an interface; it adds capabilities to the agent — MCP tools, skills, rules. If you're looking for panels, themes, or keyboard shortcuts, you're in the wrong place. The solution: read the spec with the eyes of a sysadmin, not a front-end developer.

Mistake 2: Hooking up business integrations without governance

Gmail, Salesforce, DocuSign: every official plugin widens the agent's attack surface. A prompt injected into a ticket can turn into an email sent or a contract signed. The solution: least privilege — enable business integrations one at a time, with dedicated service accounts and a systematic review of the permissions requested in mcp.json.

Mistake 3: Copying the rules from official plugins as-is

The .mdc files in official plugins embody Cursor's choices, not yours. Stacked up without review, they contradict each other, dilute the context, and degrade agent performance. The solution: treat rules as team decisions — review them, adapt them, version them, and delete anything that doesn't apply to your stack.

Mistake 4: Betting on portability without verifying

The spec aligns with the Agent Plugins standard, but actual compatibility between Cursor, Claude Code, and Codex still needs to be verified plugin by plugin. The solution: keep your skills and MCP configuration in generic files, and deliberately keep the editor-specific layer thin. You'll thank yourself at the next tool switch.

❓ Frequently Asked Questions

Is cursor/plugins free?

Yes. The repository is MIT-licensed: the spec, the 31 official plugins, and the create-plugin scaffold are free to use and fork. Only the Cursor IDE itself may be paid depending on your plan (Pro plan at $20/month as of September 2026 — check cursor.com).

What's the difference between a Cursor plugin and an MCP server?

An MCP server is a channel: it exposes tools to the agent via the Model Context Protocol. A Cursor plugin is a broader package: it bundles MCP server definitions (mcp.json), skills, rules, and a manifest. The plugin is the finished product, MCP is the plumbing underneath.

Do Cursor plugins work with Claude Code or Codex?

In theory, increasingly so: the Agent Plugins standard, announced on August 6, 2026 by OpenAI together with AWS, GitHub, Vercel, and Cursor, unifies Agent Skills and MCP configuration. In practice, portability must be verified case by case — SKILL.md skills are the most portable, .mdc rules the least.

How many stars does the repository have today?

The trajectory speaks for itself: 4,794 stars when it hit #1 on the weekly trending list (week 34 of 2026, RepoRadar), 7,300 stars as of September 10 (GitTrend), then 8,114 stars, 742 forks, and 391 issues/PRs as of September 19, 2026 (GitNova). Check today's number directly on GitHub.

Do you need a paid subscription to use the plugins?

The plugins themselves are free and open source. However, running them requires using the Cursor IDE, whose Pro plan costs around $20/month (September 2026, check cursor.com). The Claude Code and Codex alternatives follow the same model: the agent is included in the subscription.

✅ Conclusion

By publishing its plugin spec as open source and propelling it to the top of GitHub Trending — 4,794 stars in one week, 8,114 a month later — Cursor has just laid the first stone of a code agent marketplace. The question is no longer whether agentic extensibility will become standardized, but who will hold the registry. Our comparison of the best AI tools for coding is up to date to help you pick a side.