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

# Discovery

> Scan devices for installed AI tools and schedule recurring scans

`unbound discover` scans a device for installed AI coding tools and reports findings to Unbound. This powers the AI Tools inventory and fleet visibility in the dashboard.

Tools detected: Cursor and Cursor CLI, Claude Code, Claude Cowork, Claude Desktop, GitHub Copilot (VS Code, CLI, app and Xcode), Visual Studio, Xcode Coding Intelligence, Gemini CLI, Codex, Devin Desktop, Roo Code, Cline, Kilo Code, OpenCode, Replit, JetBrains IDEs, Junie, Augment Code, Google Antigravity, OpenClaw, Pi Coding Agent, Zed, and more.

## Prerequisites

Python 3 must be available on the device — the installer accepts `python3`, `python`, or `py -3` on Windows. It downloads its files with Git when Git is available; the fallback needs `curl` and `tar` on macOS and Linux, and nothing extra on Windows.

Which key you pass to `--api-key` depends on the scan's scope:

* **Single-user scan** (no `sudo`) — use your own user API key.
* **All-users scan** (with `sudo`) — scans every user's account on the device. With `sudo unbound discover`, the device is attributed to whoever owns the key you pass, so an admin key makes the admin the owner. To attribute each device to its real owner across a fleet, use `sudo unbound onboard`, which resolves the owner from the device's hardware serial.

## Run a scan

```bash theme={null}
# Scan the current user only:
unbound discover --api-key <API_KEY>

# Scan all users on the device (requires root):
sudo unbound discover --api-key <API_KEY>

# Scan against a custom backend:
sudo unbound discover --api-key <API_KEY> --domain https://backend.acme.com
```

On macOS and Linux the command prints `Discovery stops on its own after 200 minutes if it can't finish.` before it starts; a scan that reaches that limit stops, exits non-zero, and shows as a failed run in Unbound.

Discovery supports macOS, Windows and Linux. On any other operating system the scan is skipped, the command prints `AI tool discovery is not supported on this operating system. Skipping the scan — the Unbound CLI works normally.` and still exits `0`. A fleet script that only checks exit codes will read those devices as successes, so confirm coverage in the dashboard's AI Tools inventory rather than from exit codes alone.

## Schedule recurring scans

A device that Unbound is already set up on keeps itself current: opening an agent session triggers a scan, at most once every 24 hours per user account. That is why **Last Sync** keeps moving on machines with no schedule of their own. Scheduling below is for devices you want scanned on a fixed clock whether or not anyone is working — a fleet baseline rather than a requirement.

```bash theme={null}
unbound discover --set-cron --api-key <API_KEY>
```

The scan runs immediately, then once a day at 09:00 local time, on macOS, Windows and Linux. The schedule survives a restart, and a scan will not run twice within eight hours.

If the machine is off at 09:00, the platform decides:

| Platform | The missed run |
| - | - |
| **macOS** | Skipped. The next scan is the following day, while you are logged in |
| **Windows** | Runs once you next sign in — so a machine nobody signs into never scans |
| **Linux** | Runs at the next boot. Where that is not available, setup says so and missed runs are skipped |

The API key the scheduled scan runs with is stored on the device — in the platform's secret store on macOS and Windows, and in a protected file in your home directory on Linux. `unbound discover unschedule` removes the schedule and that credential together.

Check schedule status and log paths:

```bash theme={null}
unbound discover status
```

> [!NOTE]
>
> `discover status` reports the schedule on macOS. On Linux and Windows it exits with an error naming the command to run instead.

Remove the schedule:

```bash theme={null}
unbound discover unschedule
```

***

## One-step user onboarding

`unbound onboard` combines tool setup and discovery into a single command — useful for scripting new user enrollment:

```bash theme={null}
unbound onboard --api-key <USER_KEY>
```

This installs the tool bundle for your scope and then runs a device scan. Without `sudo` the bundle is Cursor, Claude Code, Codex, Copilot and Augment Code; with `sudo` it additionally includes Gemini CLI.

### Onboard flags

| Flag | Purpose |
| - | - |
| `--api-key` | User or admin key — gates which scope `onboard` runs in (see MDM section below) |
| `--domain` | Where the discovery scan reports to. Defaults to the backend you set with `unbound config set-backend-url`, falling back to `https://backend.getunbound.ai` when that is unset. It does **not** change where your installed tools send traffic — a private-gateway tenant sets those separately |
| `--set-cron` | Schedule a recurring daily scan after onboarding finishes. Works in both scopes: without `sudo` the daily job re-runs `onboard`; with `sudo` it schedules a **discovery scan only**, so your MDM platform still owns tool-deployment cadence |
| `--backfill` | Seed historical Claude Code / Codex / Copilot sessions from the device's local transcripts into Unbound analytics. Cursor and Augment are skipped automatically |

***

## MDM device onboarding (admin, requires root)

For fleet-wide enrollment from an MDM system:

```bash theme={null}
sudo unbound onboard --api-key <ADMIN_KEY>
```

Scope is automatic: `unbound onboard` **with `sudo`** configures every user on the device (MDM/org scope), **without `sudo`** just the current user. The device scan it finishes with follows the same scope.

> [!NOTE]
>
> See [MDM Integrations](https://docs.getunbound.ai/mdm-integrations/overview.md) for deployment guides and MDM-specific configuration.

***

## What a scan collects

| Collected | Detail |
| - | - |
| The device | A stable device identifier, the account names a tool was found under, and whether the scan ran inside a container |
| Each tool | Name, version, where it is installed, the subscription tier the developer is signed in with, and the plugins they have added |
| Projects | The path of each project where a tool's configuration was found |
| MCP servers | The server's name and address, the tools it exposes, and — for a server that runs a script kept on the machine — that script's contents and a checksum, so a custom connector can be reviewed like any other |
| Rules and skills | The full text of each instruction, rules and `SKILL.md` file, up to 50 KB per file. A longer file is captured up to that point and marked truncated |
| Permissions | The allow, deny and ask rules, the permission mode, whether a sandbox is on, and which settings file each value came from |

**Never sent.** Environment variable values and request headers from MCP server configuration never leave the device. A server's address, by contrast, is reported exactly as configured — so keep its credentials in `env` or `headers`, not inside the URL.

**What gets read.** Only each tool's own configuration, rules and skill files — `CLAUDE.md`, `.cursorrules`, `SKILL.md` and their equivalents. The rest of a project is never opened. The one exception is the MCP row above: a server configured to run a script on the machine has that script reported in full. Treat a script an agent launches as reviewable, not private.

Each run also reports diagnostics about itself — how long it took, how many tools it found, the operating system and Python version.

**Stays local.** Nothing the scan keeps in `~/.unbound/` on the device is uploaded. A report that cannot be delivered is held there and sent by the next scan; if it is still undelivered after 24 hours it is dropped, so a device offline for longer than that leaves a gap in the inventory rather than a late entry.

***

## Supported AI coding tools

> [!NOTE]
>
> Coverage continues to evolve alongside the AI tooling ecosystem. Specific feature behavior may vary by tool version and deployment configuration.

| Tool | Platform | Agents | MCP Servers | Rules | Skills |
| - | - | :-: | :-: | :-: | :-: |
| **Cursor** | Windows, macOS, Linux | | | | |
| **Cursor CLI** | Windows, macOS, Linux | | | | — |
| **Claude Code CLI** | Windows, macOS, Linux | | | | |
| **Claude Cowork** | Windows, macOS, Linux | | — | — | |
| **Claude Desktop** | Windows, macOS | | | — | — |
| **GitHub Copilot** | Windows, macOS, Linux | | | | |
| **GitHub Copilot CLI** | Windows, macOS, Linux | | | | |
| **GitHub Copilot app** | Windows | | — | — | — |
| **GitHub Copilot for Xcode** | macOS | | — | — | — |
| **Visual Studio** *(and the GitHub Copilot it bundles)* | Windows | | | | — |
| **Xcode Coding Intelligence** | macOS | | — | — | — |
| **Augment Code** | Windows, macOS, Linux | | | | |
| **Gemini CLI** | Windows, macOS, Linux | | | | |
| **Codex** | Windows, macOS, Linux | | | | |
| **JetBrains IDEs** *(IntelliJ IDEA, PyCharm, WebStorm, PhpStorm, GoLand, Rider, CLion, RubyMine, DataGrip, RustRover, and others)* | Windows, macOS, Linux | | | | — |
| **Junie** *(JetBrains)* | Windows, macOS, Linux | | | | |
| **Roo Code** | Windows, macOS, Linux | | | | |
| **Cline** | Windows, macOS, Linux | | | | |
| **Kilo Code** | Windows, macOS, Linux | | | | |
| **OpenCode** | Windows, macOS, Linux | | | | |
| **OpenClaw** | Windows, macOS, Linux | | — | — | — |
| **Pi Coding Agent** | macOS, Linux | | — | | — |
| **Zed** | macOS, Linux | | — | | — |
| **Replit** | Windows, macOS, Linux | | — | — | |
| **Devin Desktop** | Windows, macOS, Linux | | | | |
| **Google Antigravity** | Windows, macOS, Linux | | | | — |

> [!NOTE]
>
> **Xcode Coding Intelligence** is reported only once the coding assistant has been configured. An Xcode install on its own is not counted as an AI tool.

**Agents** — Detect installations of the AI coding tool.

**MCP Servers** — Surface every MCP server each tool is configured to reach, together with the tools that server actually exposes, so you can see an agent's real reach rather than just a server name. Credentials and environment values are stripped on the device and never reported.

A server whose tool list cannot be obtained is still inventoried, with the list left empty. The reason is shown against it, and the ones worth chasing are the authentication failures — the agent cannot use that server either.

> [!NOTE]
>
> A scan from your MDM does not list the tools of servers that run locally on a developer's machine — those are inventoried with an empty list. A developer's own scan lists them in full, so expect the two to differ.

**Rules** — Capture the custom instruction and rules files each tool loads (e.g. `.cursorrules`, `CLAUDE.md`, `GEMINI.md`, `.windsurfrules`).

**Skills** — The `SKILL.md` instruction bundles an agent adds to its toolkit and uses when relevant. Their contents are captured, not just their names, so you can review what a skill actually tells the agent to do. For the tools that support them, this also covers the custom slash commands and subagent definitions a developer has installed.

**Permissions** — For Claude Code, Cursor, Cursor CLI, GitHub Copilot, GitHub Copilot CLI, GitHub Copilot for Xcode (macOS) and Augment Code, Discovery also reports the allow, deny and ask rules each developer has in place — what the agent may run, edit or reach without stopping to ask.

**Plugins** — For Claude Code and Cursor, Discovery inventories the plugins each developer has installed, where each came from, and whether it is on the tool's own blocklist. Skills that arrive bundled inside a plugin are reported with that origin attached.

> [card] [MDM Integrations](https://docs.getunbound.ai/mdm-integrations/overview.md)
>
> Connect your MDM provider and deploy AI tools at scale

> [card] [Analytics](https://docs.getunbound.ai/analytics.md)
>
> View discovered tools and fleet activity in the dashboard


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.