# Marketplace
Source: https://dorkos.ai/docs/marketplace

Browse and install pre-built agents, plugins, and skill packs from the DorkOS community.





# Marketplace [#marketplace]

<ProductShot id="marketplace" alt="The DorkOS Marketplace page showing a grid of installable packages with names, descriptions, and install buttons" />

The DorkOS Marketplace is a curated catalog of pre-built agents, plugins, skill packs, and adapters. Install one with a single command and it runs locally, on your machine, under the same permission model as the rest of DorkOS.

## What is the marketplace? [#what-is-the-marketplace]

The marketplace is the public face of the [`dorkos-community`](https://github.com/dorkos-community) GitHub organization. The community maintains a registry of vetted packages. A few examples:

* Agents that review your PRs
* Plugins that surface Linear issues in your sidebar
* Skill packs for security auditing or release automation
* Adapters that connect messaging services like Discord

Browse the full catalog at [dorkos.ai/marketplace](https://dorkos.ai/marketplace) without installing anything.

Every entry in the registry is a real GitHub repository. You can read the source before you install it, fork it, or submit improvements upstream. Nothing is hosted, executed, or transformed by a third party: DorkOS fetches the package directly from its repo and validates its manifest (a small file describing what the package needs and what permissions it wants) against the same schemas as your local extensions.

## Installing a package [#installing-a-package]

You can install a package from the command line or from inside DorkOS.

<Tabs items="['CLI', 'Marketplace (in DorkOS)']">
  <Tab value="CLI">
    <Steps>
      <Step>
        ### Find a package [#find-a-package]

        Browse [dorkos.ai/marketplace](https://dorkos.ai/marketplace) to find a package name. There's no search command in the CLI yet, so the web catalog is the fastest way to look.
      </Step>

      <Step>
        ### Install it [#install-it]

        ```bash
        dorkos install code-review-suite
        ```

        DorkOS fetches the package, verifies its manifest, shows you the requested permissions, and asks for confirmation before writing any files.
      </Step>

      <Step>
        ### Manage it [#manage-it]

        ```bash
        dorkos update code-review-suite     # check for an update
        dorkos update --apply               # apply every available update
        dorkos uninstall code-review-suite
        ```

        There's no CLI command that lists everything you've installed. For that, open the **Installed** panel in DorkOS (see the other tab).
      </Step>
    </Steps>
  </Tab>

  <Tab value="Marketplace (in DorkOS)">
    <Steps>
      <Step>
        ### Open Marketplace [#open-marketplace]

        Click the **Marketplace** entry in the dashboard sidebar, or navigate directly to [http://localhost:4242/marketplace](http://localhost:4242/marketplace).
      </Step>

      <Step>
        ### Browse and search [#browse-and-search]

        The featured rail at the top highlights curated agents. Below it, the package grid lists every package in the registry. Filter by type (`agent`, `plugin`, `skill-pack`, `adapter`) or category, or search by name and tag. The browse page's URL reflects whatever search and filters you have set, so you can copy it and share the exact view with a teammate.
      </Step>

      <Step>
        ### Review and install [#review-and-install]

        Click a package to open the detail sheet. You'll see the requested permissions, the external hosts the package needs to reach (for example, a Discord adapter reaching Discord's API), and an install button. Review the permission preview and confirm. DorkOS handles the rest, and if anything goes wrong partway through, it puts things back exactly as they were.

        By default a package installs **globally**, for every agent. To scope it to one agent, pick **Specific agent** in the install dialog and choose the agent. The preview updates to show exactly what that install will do. An agent-scoped plugin's commands, skills, and hooks become available in that agent's sessions from its next message.
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Callout type="info">
  Most people stop here. Read on if you want to manage installs across multiple agents, add a
  private source, or publish your own package.
</Callout>

## Browsing in DorkOS [#browsing-in-dorkos]

Marketplace is the in-product browse experience. It mirrors the public catalog but adds the install machinery, so you can go from "interesting package" to "running on my machine" without leaving the app.

<ProductShot id="marketplace-detail" alt="The marketplace package detail sheet for a package, showing its permission preview (files it will create, a scheduled task it bundles) and an Install button" />

The browse surface has three sections:

* **Featured rail**: a curated row of agents the maintainers have highlighted. Rotates monthly, so it's not the same three agents forever.
* **Package grid**: every package in every registered marketplace, ranked by featured weight and install count.
* **Detail sheet**: opens when you click a package. Shows the permission preview, install instructions, and related packages.

The install confirmation dialog always shows you exactly what the package wants to do (which files it will write, which network hosts it needs to reach, which permissions it will request) before any state changes. You can deny at any point and DorkOS leaves your installation untouched.

## Managing installed packages [#managing-installed-packages]

A package can be installed in more than one place: globally, and separately on individual agents. When you open the detail sheet for a package you've installed, the **Installed** panel lists every installation, one row per scope:

<ProductShot id="marketplace-installed" alt="The Installed packages panel showing one package installed both globally and for a specific agent, the agent row marked Overrides global" />

* **All agents (global)**: installed globally, active everywhere.
* **A specific agent**, shown by name: installed only for that agent's sessions. If the same package is also installed globally, the agent row is marked **Overrides global**, meaning that for that agent, the agent's copy takes precedence.

Each row manages its own installation independently:

* **Reinstall** re-runs the install for exactly that scope. The confirmation dialog opens already pointed at the same agent (or global), so you never reinstall into the wrong place.
* **Uninstall** removes just that installation. It asks for a quick confirm first, and the confirmation message names the scope ("Uninstalled flow from Release Bot") so it's clear which copy went away. Uninstalling one agent's copy never touches the global install or any other agent's.

To add the package to another scope (for example, you have it globally and want a pinned copy on one agent), use &#x2A;*Install…** at the bottom of the panel to open the dialog and pick the new target.

<Callout type="info">
  Extensions are enabled globally, not per agent. If a package ships extensions, installing it to a
  single agent still affects every agent, and uninstalling it from one agent disables those
  extensions everywhere. Skills and commands, by contrast, do respect scope: an agent-scoped
  install's skills and commands only run for that agent. DorkOS warns you in the install dialog
  whenever the global-extensions caveat applies.
</Callout>

## Marketplace sources [#marketplace-sources]

The default registry is [`dorkos-community`](https://github.com/dorkos-community/marketplace), but you can add your own. Personal marketplaces are useful for sharing internal packages across a team without publishing them to the public registry.

```bash
# Add a marketplace source
dorkos marketplace add https://github.com/my-team/marketplace --name my-team

# List configured sources
dorkos marketplace list

# Remove a source
dorkos marketplace remove my-team
```

You can also manage sources in DorkOS at [http://localhost:4242/marketplace/sources](http://localhost:4242/marketplace/sources). Sources are merged into a single browse surface: packages from your team's marketplace appear alongside community packages, with the source clearly labeled on each card.

<Callout type="info">
  A marketplace source is just a GitHub repo with a `marketplace.json` at its root. The schema is
  documented in the [dorkos-community CONTRIBUTING
  guide](https://github.com/dorkos-community/marketplace/blob/main/CONTRIBUTING.md).
</Callout>

## Telemetry consent [#telemetry-consent]

DorkOS can report anonymous install events to dorkos.ai to power the public install counts and ranking on the marketplace browse page. This is **opt-in**: telemetry is disabled by default, and DorkOS will never report anything until you explicitly enable it in settings.

When telemetry is on, each successful install sends a single event containing:

* The package name and marketplace source
* The package type (`agent`, `plugin`, `skill-pack`, `adapter`)
* The outcome (`success`, `failure`, `cancelled`) and duration
* A random per-install UUID, not tied to you or your machine
* The DorkOS version, for compatibility analytics

No IP addresses, no user identifiers, no package contents, no file paths. The full privacy contract, including what we store, who can access it, and how to opt out, is documented at [dorkos.ai/marketplace/privacy](https://dorkos.ai/marketplace/privacy).

To enable telemetry:

```bash
dorkos telemetry enable --channel install
```

Or toggle the **Help improve the marketplace** switch in the Marketplace settings panel.

## Submitting a package [#submitting-a-package]

The marketplace is community-driven. If you've built something useful (an agent that automates a workflow, a plugin that integrates a new service, a skill pack that codifies your team's conventions), you can submit it to the registry via a PR. See [Publishing a package](/docs/marketplace/publishing) for the full walkthrough. The short version:

<Steps>
  <Step>
    ### Build your package [#build-your-package]

    Scaffold a new package with the CLI:

    ```bash
    dorkos package init my-package --type agent
    ```

    Develop locally, then validate before submitting:

    ```bash
    dorkos package validate
    ```
  </Step>

  <Step>
    ### Push to GitHub [#push-to-github]

    Push your package to a public GitHub repo. The repo must include a `README.md`, a `LICENSE` (MIT or Apache-2.0), and a `.dork/manifest.json` that passes validation.
  </Step>

  <Step>
    ### Open a PR [#open-a-pr]

    Open a PR against [`dorkos-community/marketplace`](https://github.com/dorkos-community/marketplace) adding your package to `marketplace.json`. The full submission checklist and PR template are in the [CONTRIBUTING guide](https://github.com/dorkos-community/marketplace/blob/main/CONTRIBUTING.md). A maintainer will review within 7 days.
  </Step>
</Steps>

GitHub Actions automatically runs `dorkos marketplace validate` against your submission. PRs that fail validation cannot be merged, so make sure `dorkos package validate` passes locally before opening the PR.

## Next Steps [#next-steps]

<Cards>
  <Card title="Publishing a package" href="/docs/marketplace/publishing">
    The full walkthrough for building and submitting your own package.
  </Card>

  <Card title="CLI Usage" href="/docs/guides/cli-usage">
    All `dorkos` commands, flags, and subcommands.
  </Card>

  <Card title="Tool Approval" href="/docs/guides/tool-approval">
    How DorkOS handles permission requests from installed packages.
  </Card>

  <Card title="Building Relay Adapters" href="/docs/integrations/building-relay-adapters">
    Build a custom adapter and ship it to the marketplace.
  </Card>
</Cards>