cursor/plugins: the Cursor plugin specification and official plugins
Cursor plugin specification and official plugins
At a glance
- What is it?
- Cursor's official plugin repository defines what a plugin is through a manifest and a directory of standalone plugins, most of them developer tooling, plus a third_party tree for SaaS integrations. The specification is thin, the plugin list is long, and the licence is not stated.
- Who is it for?
- Adopt cursor/plugins if you are building or evaluating Cursor plugins rather than installing a product: the repository is a specification plus a set of reference directories, and create-plugin is the entry point for scaffolding your own. Do not adopt it expecting a single installable package or a documented plugin API surface; the README is a plugin table, and the repository has no published releases.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- cursor/plugins16,420 ★ · +8,021
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| cursor/plugins | 8.4k | 16.4k |
8,021 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What cursor/plugins actually ships: a specification and a directory of plugins
The README describes the repository as official Cursor plugins for popular developer tools, frameworks, and SaaS products. That framing hides the more important half: the repository is also the specification. Each plugin is a standalone directory at the repository root with its own .cursor-plugin/plugin.json manifest, and the top-level entries include both .cursor-plugin/ and schemas/, which is where the manifest format itself lives.
The audience is therefore narrower than the plugin list suggests. If you want to use Gmail or GitHub from Cursor, the README's table points you at third_party/gmail/ and third_party/github/ and describes what each does in a single line. If you want to write a plugin, the interesting directories are create-plugin, agent-compatibility, and schemas. Those are two different jobs, and the README serves the first one better than the second.
The plugin table is organised by name, author, category, and a description taken from the marketplace. Authors are mixed: Cursor itself, Eric Zakariasson, Lauren Tan, and Dylan Gattey. Categories are Utilities, Developer Tools, Productivity, and Integrations. That mix matters, because a plugin authored by an individual contributor is not governed the same way as one authored by Cursor, even though both sit at the repository root.
The .cursor-plugin/plugin.json manifest is the whole contract
The one structural fact the README states plainly is that a plugin is a directory with a .cursor-plugin/plugin.json manifest. Everything else in the repository is content that the manifest points at: skills, agents, commands, or whatever a given plugin defines.
This is a directory-convention design rather than a registry design. The README's plugin table shows no package manager step, no version resolution, and no dependency graph between plugins. A plugin is discovered by its manifest, not by an entry in a lockfile. The practical consequence is that plugin contents are reviewable as files in the repository: you can read thermos/ or ralph-loop/ the same way you read any other directory, and the diff of a plugin update is a diff of those files.
The trade-off is that the README's introduction and plugin table do not say how a manifest is validated, what fields are required, or how version compatibility between a plugin and a Cursor release is expressed. The schemas/ directory at the top level is presumably where that answer lives. If you are writing a plugin, treat schemas/ as the authority and the README as an index.
Scaffolding a plugin with create-plugin
The README lists create-plugin with the description "Scaffold and validate new agent plugins", authored by Cursor and categorised under Developer Tools. That is the only entry point the README gives for starting a plugin, and it is a directory in this repository rather than a published package.
The plugin table gives no command for running create-plugin, so the starting point is the layout it states: a plugin directory containing a .cursor-plugin/plugin.json manifest. That path is the one concrete thing to reproduce.
.cursor-plugin/plugin.jsonThe safest first real use is to copy the layout of a small existing plugin such as teaching/ or continual-learning/, rename the directory, and edit the manifest, then compare your result against the validation that create-plugin provides. What you should see afterwards is a directory that sits alongside the others at the repository root, with a .cursor-plugin/plugin.json inside it. What you should not expect is a build step, a compiled artifact, or an install command, because the plugin table describes none of those.
Where the plugin set is thin, and where it is not
The Developer Tools category is where the repository has depth. Thermos describes deep security and correctness audits with parallel subagents. Orchestrate fans large tasks across parallel cloud agents with planners, workers, verifiers, and structured handoffs. Agent Compatibility runs CLI-backed repository compatibility scans. CLI for Agents is a set of patterns for designing CLIs that coding agents can run reliably, naming flags, help with examples, pipelines, errors, idempotency, and dry-run. PR Review Canvas and Docs Canvas render diffs and documentation as canvases. Cursor SDK covers building apps with the TypeScript SDK.
The Productivity and Integrations categories are a different kind of thing. Gmail searches, reads, drafts, and manages email. Google Sheets reads, writes, and appends spreadsheet data. Salesforce queries, creates, and updates records. These are connector descriptions, one line each, and the table does not say how authentication is configured, what scopes are requested, or whether credentials live in the manifest, in Cursor settings, or elsewhere. For a plugin that touches a company's CRM or mailbox, that is the first question a reviewer asks, and the README does not answer it.
That asymmetry is worth naming. The repository is strongest as a set of worked examples of agent workflow design, and weakest as documentation for the third-party integrations whose names will draw most of the traffic.
What the README does not tell you
There is no licence file visible in the top-level entries. The entries are .claude-plugin/, .cursor-plugin/, .gitattributes, .github/, .gitignore, README.md, the plugin directories, harness/, schemas/, scripts/, and third_party/. The licence is listed as unknown, and the README does not state one. For a repository that mixes Cursor-authored plugins, individually authored plugins, and third-party integrations, that is a real gap: a directory named third_party/gmail/ implies terms that belong to someone other than the repository owner, and nothing in the repository identifies them.
The repository has no published releases, and the README's introduction and plugin table give no install steps. The README is a table of plugins with one-line descriptions, plus the manifest convention. It does not document rollback, versioning, how a plugin is updated once installed, or how a plugin is removed. If your adoption decision depends on any of those, read the full README, schemas/ and the individual plugin directories.
Finally, the plugin descriptions come from the marketplace, not from the plugin directories themselves. A one-line marketplace blurb is a marketing surface; the directory is the implementation. Where the two disagree, the directory wins.
How this differs from a plugin system with a registry
The obvious comparison is a plugin ecosystem built around a published package: you add a dependency, a version resolver picks a compatible release, and an update is a version bump. Cursor's model here is the opposite. Plugins live as directories in a single repository, discovered by a manifest file, with no registry, no version constraint syntax, and no dependency resolution described in the README's plugin table.
The difference shows up in operations. With a registry, the question "which version of this plugin am I running" has a mechanical answer. Here, the answer is a git revision of this repository. That is simpler to audit and harder to pin selectively: you cannot take the GitHub plugin at one revision and the Salesforce plugin at another without managing the tree yourself.
It also changes who can publish. A registry model lets any author ship a plugin without the maintainer's involvement. A directory-in-one-repository model means every plugin in the list has passed through this repository, which is why the author column is short and why the third_party/ prefix exists as a boundary marker. That is a meaningful constraint on growth, and it is the reason the plugin list reads as curated rather than exhaustive.
Editorial conclusion
Adopt cursor/plugins if you are building or evaluating Cursor plugins rather than installing a product: the repository is a specification plus a set of reference directories, and create-plugin is the entry point for scaffolding your own. Do not adopt it expecting a single installable package or a documented plugin API surface; the README is a plugin table, and the repository has no published releases. Verify two things first: whether a LICENSE file exists at the root (none appears in the top-level entries, and the licence is listed as unknown), and whether the manifest schema in schemas/ matches the .cursor-plugin/plugin.json you intend to write.
Frequently asked questions
What does cursor/plugins contain?
It holds the Cursor plugin specification and the official plugins, with each plugin as a standalone directory at the repository root containing its own .cursor-plugin/plugin.json manifest. The README lists plugins across Utilities, Developer Tools, Productivity, and Integrations categories.
How do I install a plugin from cursor/plugins?
The README's introduction and plugin table do not give install steps. It documents the repository layout and the manifest convention, and points to directories such as third_party/gmail/ and create-plugin/, so installation is handled outside what the README describes.
What is the .cursor-plugin/plugin.json file for?
The README states that each plugin is a standalone directory at the repository root with its own .cursor-plugin/plugin.json manifest. The manifest is what makes a directory a plugin; the top-level schemas/ directory is where the format itself is kept.
Is there a licence for cursor/plugins?
The licence is listed as unknown and no LICENSE file appears among the top-level entries. The README does not state terms for either the Cursor-authored plugins or the third_party/ directories.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/cursor-plugins)Star history chart for your README
[](https://hysenlabs.com/projects/cursor-plugins)Was this useful?