What Is the Cursor Customize Page (Cursor 3.9)?

The Customize page is a unified management interface in Cursor 3.9 — released June 22, 2026 — that centralizes every extension and configuration point into a single UI accessed from the Agents Window sidebar. Before 3.9, managing rules meant digging through .cursor/rules folders, setting up MCP servers required editing raw mcp.json and remembering the exact transport syntax, skills lived in a separate settings panel, and hooks had no visible management surface at all. The Customize page collapses all of that into seven chip-style tabs: Plugins, MCPs, Skills, Subagents, Rules, Commands, and Hooks. As of June 2026, Cursor reports 7.5 million monthly active developers, and the Customize page is its most significant quality-of-life improvement for those users. The core takeaway: one tab replaces six disparate workflows, and what previously required a terminal and a documentation search now takes a few clicks.

How to Open and Navigate the Customize Page

Open the Customize page by clicking the gear icon in the Agents Window — the same panel where you interact with Cursor’s AI agent. The page opens as a full-width sub-panel with a row of chip-style category tabs across the top. Each tab reveals a scrollable list of installed items for that category, plus buttons to add, configure, or remove entries. A search bar at the top filters across all categories, and the header displays the active scope (more on that below). The layout is deliberately flat: no nested menus, no modal chains. Click a tab, see what’s installed, click + to add something new. The design mirrors what team platform administrators have been asking for since Cursor introduced custom MCPs in 2024.

Scope Levels: User vs Team vs Workspace

The Customize page supports three scope levels. User applies to your personal configuration across all projects — your preferred MCP servers, your personal skills, your rules. Team shares configuration across everyone in your Cursor organization, letting a platform team install plugins and MCPs once for all members. Workspace scopes to a single project, useful when different repos need different rule sets or MCP connections. A scope selector sits in the header bar so you can switch between views without losing your place. The same plugin or MCP can exist at all three scopes simultaneously; Cursor merges them at runtime with workspace overriding team overriding user.

The Seven Component Tabs (Plugins, MCPs, Skills, Subagents, Rules, Commands, Hooks)

Each tab manages a distinct type of Cursor extension. Plugins are bundles that combine multiple component types — a plugin can ship skills, MCP servers, subagents, rules, commands, AND hooks in a single installable unit. MCPs lists all connected MCP servers with protocol type, transport, status indicator, and auth state. Skills shows installed custom skills (reusable prompt templates). Subagents manages agent definitions you create for specialized tasks. Rules lists all active .cursor/rules with a preview toggle. Commands shows custom slash commands. Hooks lists lifecycle hooks (pre-save, post-agent, etc.). This flat organization means you never need to hunt across five settings screens to find what you installed last week.

Managing Plugins from the Customize Page

A plugin is a portable, versioned bundle that packages multiple Cursor components — skills, MCP servers, rules, commands, hooks, and subagents — into a single installable unit with a plugin.json manifest. Before Cursor 3.9, setting up a development environment meant manually copying rule files, pasting MCP configs, and training each teammate on the same setup steps individually. A Stripe plugin, for example, bundles the Stripe MCP server, a skill for writing payment-intent code, and a rule that flags hardcoded API keys — all installed with one click. The Plugins tab shows each installed plugin with its name, version, source scope, and a live status indicator for bundled MCP servers. From this view you can uninstall, update, or disable individual components without removing the entire plugin. This is a fundamental shift from the pre-3.9 world where each component had to be installed and maintained separately.

Installing Plugins from the Marketplace

Click the “Browse Marketplace” button at the top of the Plugins tab to open the marketplace view. The marketplace shows featured plugins, recently updated plugins, and a search bar. Launch partners include Linear, Figma, Stripe, AWS, Cloudflare, Vercel, Databricks, Snowflake, Amplitude, and Hex — each offering plugins that bundle relevant MCP servers, skills, and rules for their platform. Click “Install” on any plugin, confirm the scope, and Cursor downloads and activates it immediately. The installed plugin appears in your Plugins tab with all its sub-components populated across their respective tabs. The marketplace supports version pinning so teams don’t get surprised by breaking changes on auto-update.

Creating a Custom Plugin with plugin.json

Create a custom plugin by dropping a .cursor-plugin/plugin.json manifest into your repo. The manifest requires only a name field; all component paths are optional with auto-discovery. A minimal example:

{
  "name": "my-rules",
  "description": "Team coding standards",
  "rules": [".cursor/rules"],
  "mcpServers": {
    "my-api": {
      "type": "streamable-http",
      "url": "https://api.example.com/mcp"
    }
  }
}

Place corresponding files in skills/, rules/, commands/, and hooks/ directories under .cursor-plugin/, and Cursor discovers them automatically. The plugin.json format mirrors how Claude Desktop configs specify MCP servers, so you can often port configurations between tools with minimal changes.

Plugin Canvases — Hex and Atlassian Examples

Plugin canvases go beyond static configuration into interactive shared dashboards. The first two canvases launch with 3.9: Hex Canvas embeds a live data exploration pane inside Cursor, letting your agent query databases and visualize results without leaving the editor; Atlassian Canvas provides a real-time Jira and Confluence surface where the agent can create tickets, update sprint status, and fetch documentation context inline. Canvases are themselves plugins, installed from the marketplace and managed in the Plugins tab. They represent a new category of Cursor extension — not just a config bundle but a persistent workspace element your agent can interact with.

Adding and Managing MCP Servers Without JSON

The MCPs tab eliminates the last major reason to touch a JSON config file by providing a form-based GUI for every MCP management operation. Before 3.9, adding an MCP server required editing .cursor/mcp.json with exact transport syntax — one wrong comma or bracket and the server silently failed, forcing a restart to test each change. A common scenario: adding the @modelcontextprotocol/server-filesystem package involved looking up the correct command string, pasting it into JSON, restarting Cursor, and checking the logs if it didn’t work. The MCPs tab replaces that entire cycle with a dialog where you paste the command or URL, click a test button, and see live status. Every connected server appears in a list with its protocol, transport type (stdio, streamable-http, or SSE-deprecated), connection status, and authentication state. You can add, edit, remove, or toggle servers on and off — all without opening a single file.

Using the GUI to Add an MCP Server

Click the + button in the MCPs tab and a dialog opens. For stdio (local subprocess), paste the command and arguments — for example, npx -y @modelcontextprotocol/server-filesystem. For streamable-http (remote), enter the URL and any headers. The form validates syntax immediately and shows a test button that runs a tools/list call to confirm the server is reachable. Once saved, the server activates in seconds with no restart required. The GUI also surfaces error logs inline: if a server fails to start, you see the stderr output right in the tab, saving the old cycle of checking terminal output or log files.

Adding Custom Internal MCP Servers

Internal API servers and proprietary tooling use the same interface as public MCP servers. Enter the URL, add authentication headers (API keys, bearer tokens), and save. The Customize page stores credentials securely. For teams, publish the custom MCP server definition as part of a plugin or add it directly to the team scope so every member gets it automatically. The workflow for internal tooling: build your MCP server, publish it to a GitLab or Azure DevOps repo, import that repo as a team marketplace source, and add a custom MCP pointing at your internal URL. Distribute via Required mode (see below) and every team member gets access with zero manual configuration.

Enabling Auto-Run and Permission Policies

Each MCP server in the tab has a toggle for auto-run behavior and a permission policy selector. Auto-run lets the agent invoke MCP tools without asking for confirmation — useful for low-risk operations like file reads or search queries. For destructive operations (database writes, file deletion), set the permission policy to “ask” or “deny.” These settings mirror the auto-run and permission controls Cursor introduced for regular tools, now applied per MCP server. You can also set a permission timeout: if the agent requests access, the permission grant expires after a configurable interval.

Using the Team Leaderboard for Discovery

The team leaderboard is a ranked, real-time view in the Customize page that shows every plugin, skill, and MCP server by adoption across your organization, replacing ad-hoc Slack questions and shared Google Docs. Instead of messaging “hey, does anyone have the AWS MCP setup working?”, you glance at the leaderboard and see it’s installed by 47 of 82 team members with a 4.2-star rating. The leaderboard displays installation count, last-updated timestamp, and Required or Optional status for each item. As of June 2026, Cursor teams using the leaderboard report 3x faster onboarding for new engineers because discovery happens in the tool rather than through documentation. The leaderboard updates in near-real-time as teammates add or remove items, so the ranking always reflects actual organizational usage patterns.

How the Leaderboard Ranks Plugins, Skills, and MCPs

Ranking is based on a composite score: installation count (weighted highest), recent activity (installs in the last 7 days get a boost), and team ratings (thumbs up/down). Filters let you view by category, scope, or recency. The leaderboard also surfaces “trending” items — plugins or MCPs that saw a sudden spike in adoption in the last 48 hours. For platform teams, this is a discovery and governance tool in one: see what’s actually useful to your engineers, then promote popular items to Required status.

One-Click Install from the Leaderboard

Every row in the leaderboard has an Install button. Click it, confirm the scope, and the plugin or MCP is installed. One-click install from the leaderboard drops the friction to near zero — no searching the marketplace, no reading documentation, no copy-pasting config snippets. Combined with the leaderboard’s social proof (47 teammates already use this), it drives adoption through visibility and convenience rather than mandates.

Setting Up a Team Marketplace

A team marketplace is an organization-scoped plugin catalog in the Customize page that indexes plugins from your version control repositories and makes them available to every team member through a familiar Browse Marketplace view. Unlike the public marketplace — which features plugins from Linear, Figma, Stripe, AWS, and other launch partners — the team marketplace surfaces only the plugins your organization publishes: internal API MCP servers, proprietary rule sets for your codebase, custom skills tailored to your stack, and hooks that enforce deployment policies. Before 3.9, distributing an internal MCP server meant sharing a code snippet and hoping teammates configured it correctly. With the team marketplace, you add one or more repository connections — GitHub, GitLab, Bitbucket, or Azure DevOps — and Cursor indexes every .cursor-plugin/plugin.json it finds. Setting it up requires a Cursor Teams or Enterprise plan, and the configuration takes under five minutes.

Importing Plugin Repos from GitHub, GitLab, BitBucket, or Azure DevOps

Before 3.9, Cursor’s marketplace integration worked with GitHub repositories only. The Customize page adds GitLab, Bitbucket, and Azure DevOps support — a direct upgrade path for enterprise teams locked out of GitHub-only ecosystems. Navigate to the team marketplace settings, authenticate with your provider, and select the repos that contain .cursor-plugin/plugin.json files. Cursor scans each repo on import, indexes all plugins found, and presents them in the Browse Marketplace view with a “Team” badge. Each repo can host multiple plugins as long as each has its own .cursor-plugin/ directory.

Auto-Refresh for Latest Versions

Once a repo is connected, Cursor polls it for changes. Push an update to your plugin’s plugin.json or component files, and within minutes the team marketplace reflects the new version. Team members are notified of available updates through a badge on the Plugins tab. They can update with a single click. Auto-refresh means no manual re-import, no CI step to redeploy a plugin catalog — just push to the repo and the team picks up the changes on their next sync.

Required vs Optional Plugin Distribution

Every plugin in the team marketplace can be marked as Required or Optional. Required plugins auto-install for every team member and cannot be removed individually — the user sees them as read-only entries in their Customize page. Use Required for security rules, compliance standards, and mandatory MCP connections (like a SSO gateway or centralized logging server). Optional plugins appear in the marketplace and leaderboard but require explicit installation. Platform teams should reserve Required for non-negotiable tooling: if an MCP server handles authentication or a rule enforces code review policy, mark it Required.

Migrating from Legacy mcp.json to the Customize Page

The Customize page does NOT auto-migrate entries from existing mcp.json files — this is by design to avoid silently breaking workflows that depend on specific transport configurations. If you have a .cursor/mcp.json with MCP server definitions from a previous Cursor version, those servers continue to work as before; they simply won’t appear in the Customize page UI until you re-add them through the MCPs tab. The migration path is straightforward: open the MCPs tab, click + for each server in your mcp.json, paste the command or URL and any arguments, and save. The GUI’s built-in test button confirms the server is reachable before you finish. A tip for teams using the @modelcontextprotocol/server-filesystem server: its stdio command is npx -y @modelcontextprotocol/server-filesystem /path/to/project — the path argument must match exactly. Once added, the old mcp.json becomes redundant and you can delete it.

Best Practices for Cursor Customization at Scale

Standardize on plugins, not individual components. If your team needs a consistent set of rules, MCPs, and skills, bundle them into one plugin and mark it Required. That way a single marketplace entry replaces three separate instructions in your onboarding docs. Use workspace scope for project-specific config. Database schemas differ per repo; don’t apply SELECT-only rules globally. Audit with the team leaderboard. A weekly glance at the leaderboard tells you which plugins are actually delivering value and which are collecting dust. Version your plugins. Push breaking changes to a new plugin name or use version-pinned marketplace entries so old agents don’t break when you update a server protocol. Keep Required to a minimum. Every Required plugin is a constraint; only mandate what directly affects security or compliance.

FAQ

This section answers the most common questions developers ask when adopting the Cursor 3.9 Customize page, based on patterns observed across engineering teams running Cursor at scale. The questions below cover scope management (user vs team vs workspace), interoperability with other AI coding tools like Claude Code and VS Code Copilot, migration strategies for teams transitioning from pre-3.9 configurations, the behavior of plugin deletion and component isolation, and per-repo MCP setups. As teams adopt the Customize page at scale — Cursor’s 7.5 million monthly active developers as of June 2026 — these patterns emerge repeatedly in platform engineering discussions. Platform teams managing 50+ developers report that the three most common questions are migration paths, scope behavior, and whether existing rule files survive the upgrade. Most questions center on whether the new UI replaces existing files, how to handle the transition without breaking current workflows, and what happens when team members install or uninstall marketplace plugins.

Does the Customize page replace .cursor/rules files?

No. The Rules tab in the Customize page manages which rule sets are active, but the rule files themselves still live in your project’s .cursor/rules directory or inside a plugin’s rules folder. The tab provides visibility and toggling; it doesn’t store rule content.

Can I use MCP servers from the Customize page with Claude Code?

MCP server definitions are portable. A plugin.json that declares MCP servers uses the same shape as Claude Desktop’s claude_desktop_config.json, so you can copy the MCP definition between tools with minimal edits. However, Cursor’s Customize page is a UI for Cursor — Claude Code doesn’t read it.

What happens if I delete a plugin I created from the marketplace?

Deleting a marketplace plugin removes all its sub-components — MCPs, skills, rules, commands, and hooks — from your Cursor configuration. If you want to keep specific components, clone them to your user or workspace scope first, then delete the plugin.

How do I migrate my team from pre-3.9 configs to the Customize page?

Create a plugin that bundles your existing rules, MCP servers, and skills. Publish it to your team marketplace as Required. Every team member who syncs gets the full configuration automatically. Then ask members to clean up their old mcp.json files at their convenience.

Does the Customize page support per-repo MCP configurations?

Yes. Use workspace scope to set MCP servers that activate only when that workspace is open. This is ideal for per-repo database connections or project-specific APIs.