> ## Documentation Index
> Fetch the complete documentation index at: https://docs.augmentcode.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Plugins and Marketplaces

> Manage and install plugins from marketplaces to extend Auggie's capabilities

## About Plugins

Auggie supports a plugin system that allows you to extend its functionality with custom commands, subagents, rules, hooks, skills, and MCP server integrations. Plugins are distributed through **marketplaces** - Git repositories that contain collections of plugins.

## Interactive Plugin Browser

The easiest way to manage plugins is through the interactive plugin browser in Auggie's TUI (Terminal User Interface).

### Opening the Plugin Browser

In interactive mode, use the `/plugins` slash command to open the plugin browser:

```sh theme={null}
# Start Auggie in interactive mode
auggie

# Then type:
/plugins
```

### Plugin Browser Features

The plugin browser provides two main tabs:

**Marketplaces Tab**

* View all installed plugin marketplaces
* Add new marketplaces from GitHub repositories
* Update marketplaces to get the latest plugins
* Remove marketplaces you no longer need
* Browse plugins within each marketplace
* Toggle automatic marketplace updates (enabled by default)

**Enabled Plugins Tab**

* View all currently enabled plugins
* See plugin details including commands, agents, rules, hooks, and MCP servers

## Automatic Marketplace Updates

By default, Auggie automatically updates all installed marketplaces in the background when you start the CLI in interactive mode. This ensures you always have access to the latest plugins without manually running update commands.

### How It Works

* **Automatic**: Updates run in the background when Auggie starts in TUI mode
* **Silent**: Failed updates are logged but never shown to the user
* **Fast**: 15-second global timeout ensures startup isn't delayed
* **Notifications**: You'll be notified when marketplaces are successfully updated
* **Cleanup**: Stale plugin entries are automatically removed after updates

### Controlling Auto-Updates

You can enable or disable automatic updates through the plugin browser:

1. Open the plugin browser with `/plugins`
2. Navigate to the **Marketplaces** tab
3. Look for the "Automatic updates" toggle
4. Toggle it on or off based on your preference

The setting is saved to your Augment settings file and defaults to **enabled**.

<Note>
  If your organization manages your settings file, the auto-update toggle may be locked and show a `(locked)` indicator.
</Note>

### Manual Updates

If you prefer to update marketplaces manually or have auto-updates disabled, you can still update at any time:

```sh theme={null}
# Update all marketplaces
auggie plugin marketplace update

# Update a specific marketplace
auggie plugin marketplace update marketplace-name
```

## Recommended Marketplaces

Projects can recommend specific marketplaces to team members by adding them to the project's `.augment/settings.json` file. When you open a workspace that recommends marketplaces you haven't installed, Auggie will prompt you to install them.

### For Project Maintainers

To recommend marketplaces for your project, add the `recommendedMarketplaces` key to your project's `.augment/settings.json`:

```json theme={null}
{
  "recommendedMarketplaces": [
    "yourorg/team-plugins",
    "yourorg/security-tools"
  ]
}
```

Each entry should be in the format `owner/repo` matching the GitHub repository path.

### For Users

When you open a workspace with recommended marketplaces:

1. After workspace indexing completes, you'll see a prompt listing the recommended marketplaces
2. Choose **Install** to clone all recommended marketplaces at once
3. Choose **Skip** to dismiss the prompt for this workspace

If you skip the prompt, those specific marketplaces are saved to `.augment/settings.local.json` as dismissed. You won't be prompted again for those particular marketplaces, but if new recommended marketplaces are added to the project later, you'll still be prompted for those. You can still manually install dismissed marketplaces at any time using the plugin browser or CLI commands.

<Note>
  After installing recommended marketplaces, any plugins listed in the project's `enabledPlugins` setting (in `.augment/settings.json`) will automatically be enabled. The `enabledPlugins` setting is a record mapping plugin IDs to `true`/`false`, e.g. `{"enabledPlugins": {"my-plugin@my-marketplace": true}}`.
</Note>

## Plugin Settings Reference

The following settings control plugin marketplace behavior. These can be placed in the appropriate settings file depending on their scope.

### autoUpdateMarketplaces

Controls whether installed marketplaces are automatically updated in the background when Auggie starts in interactive mode.

* **Type**: `boolean`
* **Default**: `true`
* **File**: `~/.augment/settings.json` (user-level)
* **Configurable via**: Plugin browser (`/plugins` → Marketplaces tab → "Automatic updates" toggle)

When enabled, Auggie runs `git pull` on all installed marketplace repositories at startup to ensure you have the latest plugins.

### recommendedMarketplaces

Specifies marketplaces that should be recommended to users when they open this workspace.

* **Type**: `array` of strings (format: `"owner/repo"`)
* **Default**: `[]`
* **File**: `<workspace>/.augment/settings.json` (project-level only — values in user or local settings are ignored)

Example in your project's `.augment/settings.json`:

```json theme={null}
{
  "recommendedMarketplaces": [
    "yourorg/team-plugins",
    "yourorg/security-tools"
  ]
}
```

### dismissedMarketplaces

Tracks which recommended marketplaces the user has chosen to skip. This setting is automatically managed by Auggie.

* **Type**: `array` of strings (format: `"owner/repo"`)
* **Default**: `[]`
* **File**: `<workspace>/.augment/settings.local.json` (local project-level, gitignored)
* **Managed by**: Auggie (automatically updated when user skips recommended marketplaces)

You typically don't need to manually edit this setting.

### enabledPlugins

Controls which plugins are enabled. This setting is a record mapping plugin IDs to boolean values.

* **Type**: `Record<string, boolean>`
* **Default**: `{}`
* **File**: Any settings file (user, project, or local — values are deep-merged across all tiers)

Example:

```json theme={null}
{
  "enabledPlugins": {
    "my-plugin@my-marketplace": true,
    "another-plugin@my-marketplace": false
  }
}
```

## CLI Commands

```sh theme={null}
# Marketplace management
auggie plugin marketplace add owner/repo
auggie plugin marketplace list
auggie plugin marketplace update [marketplace-name]
auggie plugin marketplace remove marketplace-name

# Plugin management
auggie plugin list
auggie plugin install plugin-name@marketplace-name
auggie plugin install plugin-name@marketplace-name --disable
auggie plugin install plugin-name@marketplace-name --project
auggie plugin install plugin-name@marketplace-name --local
```

## The .augment-plugin Folder

The `.augment-plugin` folder is the core configuration directory for Auggie plugins and marketplaces. This folder contains manifest files that define the plugin or marketplace metadata and structure.

<Note>
  `.claude-plugin` is also supported for backwards compatibility with Claude Code plugins. See the [Compatibility with .claude-plugin](#compatibility-with-claude-plugin) section for more details.
</Note>

### Marketplace Manifest (marketplace.json)

The `marketplace.json` file defines your marketplace and lists all available plugins for discovery:

```json theme={null}
{
  "name": "my-marketplace",
  "description": "A collection of useful Auggie plugins",
  "version": "1.0.0",
  "plugins": [
    {
      "name": "hello-commands",
      "description": "Example slash commands",
      "version": "1.0.0",
      "source": "./plugins/hello-commands",
      "category": "productivity",
      "tags": ["commands", "example"]
    },
    {
      "name": "code-guard",
      "description": "Security-focused hooks",
      "version": "1.0.0",
      "source": "./plugins/code-guard",
      "category": "security",
      "tags": ["hooks", "security"]
    }
  ]
}
```

## Plugin Components

Plugins can provide multiple types of components:

### Custom Commands

Slash commands are Markdown files in the `commands/` directory. The filename becomes the command name (e.g., `hello.md` creates `/plugin-name:hello`):

```markdown theme={null}
---
description: Greet the user
---

Say hello to the user in a friendly way. Ask them how their day is going.
```

### Subagents

Specialized agents in the `agents/` directory that Auggie can invoke for specific tasks:

```markdown theme={null}
---
description: A refactoring specialist
color: yellow
---

# Refactor Agent

You are an expert at code refactoring. When invoked, analyze the code
and suggest improvements for readability, maintainability, and performance.
```

### Rules

Guidelines in the `rules/` directory that instruct the agent on coding standards:

```markdown theme={null}
# Coding Standards

- Use descriptive variable names
- Add comments for complex logic
- Follow the project's existing patterns
```

### Hooks

Event handlers that respond to Auggie events. Configure in `hooks/hooks.json`:

```json theme={null}
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${AUGMENT_PLUGIN_ROOT}/hooks/format.sh $FILE"
          }
        ]
      }
    ]
  }
}
```

### MCP Servers

Model Context Protocol integrations defined in `.mcp.json` or within `plugin.json`:

```json theme={null}
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}
```

### Skills

Agent Skills in the `skills/` directory that extend Auggie's capabilities:

```
skills/
└── pdf-processor/
    ├── SKILL.md
    └── scripts/
        └── process.py
```

## Compatibility with .claude-plugin

Auggie's plugin system is designed to be **backwards compatible with Claude Code's `.claude-plugin` format**. This means:

1. **Directory Recognition**: Auggie recognizes both `.augment-plugin` and `.claude-plugin` directories
2. **Manifest Format**: The `plugin.json` schema is compatible between both systems
3. **Component Structure**: Commands, agents, hooks, MCP servers, and skills use the same directory layout
4. **Easy Migration**: Existing Claude Code plugins work with Auggie with minimal or no changes

### Using Claude Code Plugins

If you have an existing Claude Code plugin with a `.claude-plugin` folder, Auggie can use it directly:

```sh theme={null}
# Install from a marketplace containing Claude Code plugins
auggie plugin marketplace add anthropics/skills

# Enable a specific plugin
auggie plugin install document-skills@anthropic-agent-skills
```

### Creating Compatible Plugins

To create plugins that work with both Auggie and Claude Code:

1. Use `.augment-plugin` as the primary configuration folder (Auggie will also check for `.claude-plugin`)
2. Follow the same manifest schema for `plugin.json`
3. Use the same directory structure for commands, agents, hooks, etc.

## Creating a Marketplace

A marketplace is a GitHub repository that hosts one or more plugins. Anyone can create and share their own marketplace.

### Marketplace Structure

```
my-marketplace/
├── .augment-plugin/
│   └── marketplace.json
├── plugins/
│   ├── hello-commands/
│   │   ├── .augment-plugin/
│   │   │   └── plugin.json
│   │   └── commands/
│   │       └── hello.md
│   ├── code-guard/
│   │   ├── .augment-plugin/
│   │   │   └── plugin.json
│   │   └── hooks/
│   │       ├── hooks.json
│   │       └── check.py
│   └── full-example/
│       ├── .augment-plugin/
│       │   └── plugin.json
│       ├── commands/
│       ├── agents/
│       ├── rules/
│       ├── hooks/
│       └── .mcp.json
└── README.md
```

## Hosting a Marketplace on GitHub

To share your marketplace publicly, host it on GitHub:

### Step 1: Create the Repository

1. Create a new public GitHub repository
2. Add your marketplace structure with `.augment-plugin/marketplace.json`
3. Add your plugins in the `plugins/` directory

### Step 2: Add Plugin Manifests

Each plugin needs its own `.augment-plugin/plugin.json`:

```json theme={null}
{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  },
  "keywords": ["productivity", "tools"]
}
```

### Step 3: Add a README

Create a README.md to help users discover and understand your plugins:

```markdown theme={null}
# My Plugin Marketplace

A collection of plugins for Auggie.

## Installation

\`\`\`sh
auggie plugin marketplace add yourusername/your-repo
\`\`\`

## Available Plugins

- **hello-commands**: Simple greeting commands
- **code-guard**: Security validation hooks
```

### Step 4: Publish and Share

1. Push your code to GitHub
2. Share the repository path with users
3. Users can add your marketplace with:

```sh theme={null}
auggie plugin marketplace add yourusername/your-repo
```

### Example: Complete Marketplace Repository

See [justinxu421/auggie-plugin](https://github.com/justinxu421/auggie-plugin) for a complete example marketplace with:

* Multiple plugins demonstrating different capabilities
* Commands, hooks, agents, rules, and MCP server configurations
* Proper manifest files and documentation

To try this example:

```sh theme={null}
# Add the example marketplace
auggie plugin marketplace add justinxu421/auggie-plugin

# Install the full example plugin
auggie plugin install full-example@auggie-plugin-marketplace

# View what's included
/plugins
```

## Environment Variables

Plugins can use these environment variables in their configurations:

| Variable                 | Description                                                     |
| :----------------------- | :-------------------------------------------------------------- |
| `${AUGMENT_PLUGIN_ROOT}` | Path to the plugin's root directory                             |
| `${AUGGIE_PLUGIN_ROOT}`  | Alias for `AUGMENT_PLUGIN_ROOT`                                 |
| `${CLAUDE_PLUGIN_ROOT}`  | Alias for `AUGMENT_PLUGIN_ROOT` (for Claude Code compatibility) |

These variables are supported in:

* **Hook commands** (`hooks/hooks.json`)

Example usage in `hooks/hooks.json`:

```json theme={null}
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${AUGMENT_PLUGIN_ROOT}/hooks/format.sh $FILE"
          }
        ]
      }
    ]
  }
}
```

## Best Practices

### For Plugin Authors

1. **Use semantic versioning** for your plugin versions
2. **Add descriptive metadata** in your manifest files
3. **Include a README** with installation and usage instructions
4. **Test locally** before publishing using `--plugin-dir`:
   ```sh theme={null}
   auggie --plugin-dir ./my-plugin
   ```

### For Marketplace Maintainers

1. **Organize plugins by category** in your marketplace
2. **Use tags** to help users discover plugins
3. **Keep the marketplace updated** by pulling the latest changes
4. **Document each plugin** with clear descriptions

## See Also

* [Custom Commands](/cli/custom-commands) - Create reusable command templates
* [Subagents](/cli/subagents) - Create specialized agents
* [Hooks](/cli/hooks) - Automate actions with event hooks
* [Integrations](/cli/integrations) - Connect external tools and services
* [Interactive Mode](/cli/interactive) - Learn about Auggie's TUI features