> For the complete documentation index, see [llms.txt](https://helpdesk.augmentt.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://helpdesk.augmentt.com/modules/discover/agent-deployment.md).

# Agent Deployment

## Discovery Agent Deployment

This guide covers every supported way to deploy the Augmentt Discovery Agent, for both Windows and Mac, plus downloading, uninstalling, and restarting the agent. It replaces what used to be sixteen separate deployment articles — pick the method below that matches your environment.

Every method needs the same two things first:

1. **The installer**, downloaded from your Augmentt dashboard.
2. **Your company's license key** — this ties the device's data to the right tenant. Both live in the same place.

### Table of contents

* [Prerequisites: downloading the agent and finding your license key](#prerequisites-downloading-the-agent-and-finding-your-license-key)
* **Windows deployment**
  * [PowerShell / manual install](#powershell--manual-install)
  * [Batch file installation](#batch-file-installation)
  * [Datto RMM](#datto-rmm)
  * [ConnectWise Automate](#connectwise-automate)
  * [Syncro RMM](#syncro-rmm)
  * [Microsoft Intune (Endpoint Manager)](#microsoft-intune-endpoint-manager)
  * [N-able N-central](#n-able-n-central)
  * [Kaseya VSA](#kaseya-vsa)
  * [NinjaRMM](#ninjarmm)
* **Mac deployment**
  * [Manual install / shell script](#manual-install--shell-script)
  * [Jamf](#jamf)
  * [Addigy](#addigy)
* [Uninstalling the agent](#uninstalling-the-agent)
* [Restarting the Mac agent](#restarting-the-mac-agent)
* [Common deployment issues](#common-deployment-issues)

***

### Prerequisites: downloading the agent and finding your license key

1. Log into your Augmentt dashboard:
   * North America: `https://app.augmentt.com/auth/login`
   * EU: `https://app.eu.augmentt.com/auth/login`
   * APAC: `https://app.apac.augmentt.com/auth/login`
2. Navigate to **Discover > Agent**.
3. Click **Download Agent** and choose the Mac or Windows installer.
4. On the same page, copy the **license key** for the company you're deploying to (each company has its own key).

Direct download URLs by region (Windows):

| Region        | URL                                                                         |
| ------------- | --------------------------------------------------------------------------- |
| North America | `https://downloads.augmentt.com/agent/windows/DiscoveryAgentSetup.us.exe`   |
| EU            | `https://downloads.augmentt.com/agent/windows/DiscoveryAgentSetup.eu.exe`   |
| APAC          | `https://downloads.augmentt.com/agent/windows/DiscoveryAgentSetup.apac.exe` |

Mac (zipped installer):

| Region        | URL                                                                      |
| ------------- | ------------------------------------------------------------------------ |
| North America | `https://downloads.augmentt.com/agent/mac/MacDiscoveryAgentSetup.us.zip` |
| EU            | `https://downloads.augmentt.com/agent/mac/MacDiscoveryAgentSetup.eu.zip` |

{% hint style="warning" %}
An APAC-region Mac download URL wasn't present in the source material for this guide — confirm the correct URL with Augmentt support or the in-app download link before scripting an APAC Mac deployment.
{% endhint %}

{% hint style="warning" %}
A partner reported the Windows installer throwing a code-signing certificate warning after an expired certificate. If end users report certificate warnings during install, check with Augmentt support for the current signed build before rolling out broadly — don't have users click through security warnings as a habit.
{% endhint %}

***

## Windows deployment

### PowerShell / manual install

Two flavors depending on whether the installer is already on the device.

**One-liner (installer already downloaded to the device):**

```
C:\Temp\DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=<licensekey>
```

**Download-and-install in one script:**

```powershell
mkdir "C:\Augmentt"
Invoke-WebRequest '<download URL for your region>' -OutFile "C:\Augmentt\DiscoveryAgentSetup.exe"
sleep 10
& 'C:\Augmentt\DiscoveryAgentSetup.exe' /VERYSILENT /SUPPRESSMSGBOXES /EXTENSIONKEY=<licensekey>
```

Replace `<licensekey>` with the company's license key, and the download URL with the one for your region (above).

{% hint style="warning" %}
A real support case involved a device where the agent installed and ran, but never showed up in the console — the customer wanted to know whether the license key is stored in a config file or a registry entry to help debug. That level of detail wasn't confirmed in the source material for this migration; if you need to debug a "silent success but no console record" case, start with the Windows log folder and `BrowserAgent.exe.Config` described in [Discovery Agent Overview](/modules/discover/agent-overview.md#troubleshooting), and escalate to support if the config file doesn't clarify it.
{% endhint %}

### Batch file installation

Same install command, meant to be dropped into a `.bat` file or an RMM's script/batch step:

```
C:\Temp\DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=<licensekey>
```

Replace `<licensekey>` with the company's license key. This is the building block most of the RMM-specific guides below are wrapped around.

### Datto RMM

Datto RMM deployment uses the Augmentt component from the **ComStore**, and the flow differs slightly depending on whether you're on Datto's old or new UI.

**New UI:**

1. In Datto RMM, go to **Components > ComStore**, search "Augmentt," and click **Add** on the Augmentt Discovery Agent Deployment component.
2. *(Recommended)* Set up a **Site Variable** so you don't have to enter the license key every time:
   * Go to the customer's site > **Settings** > **Variables** > **Add Variable**.
   * Name it `AugmenttKeySITE`, and set its value to the company's Augmentt license key.
   * Scroll down and click **SAVE SITE**.
3. Select the target devices, click **Create Job**, add the Augmentt component. If you set up the site variable, leave the license key field blank; otherwise enter it directly.
4. Click **Create Job** to run the deployment.

**Old UI:**

1. From the ComStore, select **All Components**, find **Augmentt Discover Agent Deployment \[WIN]**, and click **Add to my Component Library**.
2. *(Recommended)* Set up a Site Variable the same way as above (`AugmenttKeySITE`).
3. Select the customer site and target devices, click **Run Quick Job**, add the Augmentt component, leave the key blank (if using the site variable) or enter it, then **Save**.

{% hint style="info" %}
Setting up the `AugmenttKeySITE` site variable once per customer is worth the extra few clicks — several support conversations have started with a partner unable to find where to put the license key on a subsequent deployment. Once the site variable exists, you never re-enter the key for that site again.
{% endhint %}

### ConnectWise Automate

1. From the Automate Control Center, go to **Automation > Scripts**, and click **+ Add** to create a new script.
2. Add a **File Download URL** step pointing at the regional installer URL (see Prerequisites above).
3. Add a **Local File** step to stage it: `%TEMP%\DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES`
4. Add a **Parameter** named `LicenseKey`.
5. Add a **PowerShell Command** step to run the install with the key substituted in:

   ```
   %TEMP%\DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=@LicenseKey@
   ```
6. Run the script against target devices, supplying the company's license key as the `LicenseKey` parameter value at runtime.

### Syncro RMM

Syncro's script also doubles as an uninstaller — if you leave the license key variable blank, it uninstalls instead of installing.

1. In Syncro, go to **Scripts** and click **Add New File** to upload the Augmentt installer.
2. Create a new script (**Scripts > + New Script**) with:
   * **Variable Name:** `AugmenttLicenseKey`
   * **Destination File Name:** `C:\Temp\DiscoveryAgentSetup.exe`
   * A description noting that leaving the license key empty triggers an uninstall instead of an install.
3. Paste the following into the script body:

   ```powershell
   if ( $AugmenttLicenseKey )
   {
   #Install the agent
   Echo "Installing"
   echo $AugmenttLicenseKey
   C:\Temp\DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=$AugmenttLicenseKey
   } else
   {
   #Uninstall the agent
   echo "Uninstalling"
   echo $AugmenttLicenseKey
   & "C:\Program Files (x86)\Augmentt\unins000.exe" /VERYSILENT /SUPPRESSMSGBOXES
   }
   ```
4. Run the script against target devices, supplying the license key at runtime when installing (or leaving it blank to uninstall).

{% hint style="warning" %}
This script hardcodes `C:\Temp\DiscoveryAgentSetup.exe` as the install path — adjust it if you uploaded the installer to a different location.
{% endhint %}

### Microsoft Intune (Endpoint Manager)

Intune deployment uses the **Win32 app** packaging flow, which requires converting the installer to `.intunewin` format first.

**Prerequisites:**

* Intune properly configured for your organization, with devices assigned to licensed users
* Security groups created for targeting the deployment
* The Discovery Agent installer downloaded and your license key on hand
* The installer converted to `.intunewin` format using Microsoft's [Win32 app packaging tool](https://learn.microsoft.com/en-us/mem/intune/apps/apps-win32-prepare)

**Deployment steps:**

1. In Microsoft Endpoint Manager, go to **Apps > Windows (By Platform)**, click **Add**, and choose app type **Windows app (Win32)**.
2. Under **Select app package file**, upload the `.intunewin` file you prepared.
3. Fill in the required app details and click **Next**.
4. Set the install and uninstall commands, substituting your company's license key:
   * **Install:** `DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=<licensekey>`
   * **Uninstall:** `"C:\Program Files (x86)\Augmentt\unins000.exe" /VERYSILENT /SUPPRESSMSGBOXES`
5. Set **Requirements** as desired, then click **Next**.
6. Set the **Detection rule** to "Manually configure detection rule" and add the appropriate detection criteria for the installed agent.
7. Leave **Dependencies** and **Supersedence** blank, then move to **Assignments**.
8. Add the groups and/or users you want to receive the Discovery Agent, and click **Next**.
9. Review your settings and click **Create**.
10. Devices pick up the app on their next Intune sync (or a forced sync).

### N-able N-central

1. Upload the Augmentt Discovery Agent to your Software Repository (**Configuration > Scheduled Tasks > Script/Software repository**) — since Augmentt uses a single agent binary for all customers (the license key is what routes data to the right tenant), you can store this once at the service-organization level. Alternatively, upload it fresh from your computer at deployment time.
2. Under the target customer, go to **Actions > Push Third Party Software**.
3. Select the Augmentt Discovery Agent from the repository (or upload it), select your target devices, and deploy using this command line (with the company's key substituted in):

   ```
   DiscoveryAgentSetup.exe /VERYSILENT /SUPPRESSMSGBOXES /extensionKey=<licensekey>
   ```

{% hint style="info" %}
A partner using plain **N-able RMM** (not N-central) has asked whether separate instructions exist for that product. The command-line install above is the underlying installer syntax and should work from any RMM capable of running an .exe with parameters, but a dedicated N-able RMM walkthrough wasn't available in the source content — treat N-able RMM as "use the generic PowerShell/batch install," and check with support if you need RMM-specific packaging guidance.
{% endhint %}

### Kaseya VSA

Kaseya's flow uses an Agent Procedure (XML), and you have a choice between a managed variable (recommended, for reuse across multiple client groups) or hard-coding the license key per procedure.

**Setup:**

1. Zip the Augmentt `.exe` installer and upload it to your VSA server at `\VSASharedFiles\Augmentt Agent\discoveryagentsetup.zip` (via **Agent Procedures > Schedule/Create > Manage Files**). If you use a different path, update line 8 of the procedure script accordingly.
2. Download the Deploy Augmentt.xml procedure file (provided with the Augmentt agent package) and import it: **Agent Procedures**, select/create your upload folder (e.g. `Shared/Deployments/`), then **Import Folder / Procedure**.

**Section 2 — Managed variable (recommended):**

1. Select the imported procedure and click **Manage Variables**.
2. Under **Select Variable**, leave `<New Variable>` selected.
3. Under **Rename/Create Variable**, enter `augmenttkey`.
4. Under **Set Variable Value**, enter the license key for the specific end client.
5. Choose the Org/Machine group this key applies to (make sure it only contains that client's machines), then click **Apply**.
6. Repeat for each additional Org/Machine group with its own license key.

**Section 3 — Hard-coded key (alternative):**

1. Select the procedure and click **Edit Procedure**.
2. Find the line starting `msiexec.exe` and replace `<augmenttkey>` with the literal license key (no angle brackets).
3. Run the procedure against target devices, or schedule it.

### NinjaRMM

NinjaRMM deployment uses a custom field to hold the license key per organization, plus a PowerShell deployment script.

1. **Create the custom field:** **Administration > Devices > Global Custom Fields > Add new field**:
   * Label/Name: `AugmenttDiscover`
   * Type: Text
   * Grant Read/Write permissions to Automations when saving.
2. **Create the deployment script:** **Administration > Library > Automation > + Add > New Script**. Set Language to PowerShell, OS to Windows, Architecture 64-bit, and paste:

   ```powershell
   [CmdletBinding()]
   param(
       [string]$AugmenttDiscover = $env:AugmenttDiscover
   )

   $AugmenttPath = 'C:\Augmentt'

   if(!$AugmenttDiscover) {
       $AugmenttDiscover = Ninja-Property-Get augmenttdiscover
   }

   if ([String]::IsNullOrWhiteSpace($AugmenttDiscover)) {
       throw 'Missing value for AugmenttDiscover variable.'
   }

   if (!(Test-Path $AugmenttPath)) {
   New-Item -Path $AugmenttPath -Force -ItemType Directory
   }

   Invoke-WebRequest '<download URL for your region>' -OutFile "$AugmenttPath\DiscoveryAgentSetup.exe"

   $cmd = "$AugmenttPath\DiscoveryAgentSetup.exe"
   $args = "/VERYSILENT /SUPPRESSMSGBOXES /extensionKey=$AugmenttDiscover"
   $args = $args.Split(" ")

   Write-Host "Running: $cmd $args"

   & $cmd  $args

   if ($LASTEXITCODE -ne 0) {
       $errormessage = "DiscoveryAgentSetup.exe returned $LASTEXITCODE"
       throw $errormessage
   }

   Start-Sleep -Seconds 60
   Remove-Item -Recurse $AugmenttPath -Force
   ```
3. **Set the license key per org:** go to the tenant's **Organization** page > **Custom Fields** tab, edit **AugmenttDiscover**, and paste in that tenant's license key from **Discover > Agent**. Click **Save Changes**.
4. **Run the deployment:** go to **Devices**, select target devices, **Run > Run Automation > Script**, select the deployment script, run it as **System**.

*(Credit to Robert Picard and Gurney Halleck at Demand ITS, and Mikey O'Toole at Homotechsual, for developing much of this NinjaRMM script.)*

***

## Mac deployment

All Mac deployment paths require granting the agent **Full Disk Access** — without it, the agent cannot read browser history and won't collect data. Plan for this permission as part of every Mac rollout, not as an afterthought.

### Manual install / shell script

**Manual (Terminal) install:**

1. Download the Mac agent from **Discover > Agent** (Configuration tab in some UI versions) — the Mac version downloads as a zip.
2. Copy the company's license key from the same page.
3. Open Terminal and enable admin rights for the install session: `sudo -s` (needed so the agent can push data autonomously, write files to the user's Library, and run `chmod`).
4. Navigate to the downloaded folder in Terminal.
5. Make the installer executable: `chmod +x *.*`
6. Run the installer with the license key: `./install_agent.sh <LICENSE KEY FROM STEP 1>`
7. Confirm **Full Disk Access** has been granted under **System Settings > Privacy & Security**. This step may not prompt automatically — open it manually if needed.
8. Once Full Disk Access is granted, the agent makes its first data push, then every 6 hours after.

**Requirements:** macOS 10.15.7+ (Catalina, Big Sur, Monterey and later); Intel native or Apple Silicon via Rosetta 2; Safari, Chrome, Firefox, or Edge.

**Manual removal:** drag the Augmentt Agent from the Applications folder to the Trash; you'll be prompted for admin permission.

{% hint style="warning" %}
Multiple support cases involve `chmod +x *.*` or the shell install not visibly doing anything, with no clear error message. If this happens: confirm the user running the command has admin rights, try from a different Mac if possible to isolate a device-specific issue, and consider switching to the scripted RMM install below or Jamf, which handle more of this for you. Escalate to support with the exact terminal output if the one-liner truly produces no result.
{% endhint %}

**Scripted install for RMMs without a native Augmentt integration:**

For RMMs that can push and run a shell script but don't have a dedicated Augmentt package, use this script — it downloads, unpacks, and installs the agent in one pass, and leaves a temp folder with detailed logs to help troubleshoot:

```bash
#!/bin/sh

# Constants
APP_NAME="AugmenttDiscoveryAgent.Agent"
INSTALL_DIR="/Applications/$APP_NAME.app"
DOWNLOAD_URL="<download URL for your region>"
TMP_DIR="/tmp"
TMP_ZIP_FILE="$TMP_DIR/$APP_NAME.zip"
AUTH_KEY="dGVsZW1ldHJ5LWtleTpHSz56XTota0g9KzpLbUch"
COMPANY_ID="<licensekey>"
LOG_FILE="/tmp/install_log.txt"
EXTRACTED_DIR="$TMP_DIR/extracted"

# Check if app is already installed
if [ -d "$INSTALL_DIR" ]; then
  echo "App is already installed."
  exit 0
fi

# Create tmp directory if it doesn't exist
mkdir -p "$TMP_DIR" 2>/dev/null

# Download zip file silently
curl --silent -L -o "$TMP_ZIP_FILE" "$DOWNLOAD_URL" || {
  echo "Download failed."
  exit 1
}

# Extract zip file to tmp directory
unzip -qq -o "$TMP_ZIP_FILE" -d "$EXTRACTED_DIR" &
# Wait for extraction to complete
while [ ! -f "$EXTRACTED_DIR/MacDiscoveryAgentSetup/appsettings_tpl.json" ]; do
  sleep 0.5
done

# Update extracted directory path
EXTRACTED_DIR="$EXTRACTED_DIR/MacDiscoveryAgentSetup"

# Install app
cd "$EXTRACTED_DIR"
sed "s/ENVIRONMENT_AUTH_KEY/$AUTH_KEY/g" appsettings_tpl.json > "$TMP_DIR/appsettings.json"
./install_agent.sh "$COMPANY_ID" > "$LOG_FILE" 2>&1
if [ $? -ne 0 ]; then
  echo "Installation failed. Check $LOG_FILE"
  exit 1
fi
echo "Installation completed."
```

Replace `DOWNLOAD_URL` with the region-appropriate zip URL and `COMPANY_ID` with the license key. You'll still need to push a **Full Disk Access (PPPC)** profile through your RMM/MDM separately — see the code requirement string in the Jamf section below, which applies regardless of MDM platform.

### Jamf

*(Credit to Brooke Burdick at Parachute for building this guide and the installation script.)*

1. **Prerequisites:** download the Mac agent from **Discover > Agent** and have your license key ready.
2. **Build the package:** Jamf needs a custom `.pkg` built with Composer.
   * Create `/private/var/tmp/Augmentt` and drag in the contents of the unzipped `MacDiscoveryAgentSetup` folder.
   * Drag that folder into **Composer > Sources**.
   * Click **Build as a PKG**.
3. **Set up the PPPC profile (Part 1):** create a new PPPC configuration profile in Jamf:
   * **Identify by (Bundle ID):** `Augmentt.DiscoveryAgent.Agent`
   * **Signature:**

     ```
     anchor apple generic and identifier "Augmentt.DiscoveryAgent.Agent" and (certificate leaf[field.1.2.840.113635.100.6.1.9] /* exists */ or certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = "KFW4495YQ3")
     ```
   * **Allow:** Documents, Downloads, All Files, SysAdminFiles
   * Upload the `.pkg` built above.
4. **Add the install script (Part 2):** attach this custom script, which installs the package and cleans up any prior install:

   ```bash
   #!/bin/bash
   # Augmentt Discovery Agent installer for macOS through Jamf
   LICENSEKEY="$4"

   ##DO NOT EDIT BELOW THIS LINE##
   PREV_DST=/Library/augmentt
   PREV_ALT_DST=/Library/AugmenttAgent

   if [ "$LICENSEKEY" == "" ]; then
     echo "Please provide 'License_key_id' as parameter, e.g. ./install_agent.sh 01abc-kladfhcd23-mkjds-3455"
     echo "If you want to install agent using MDM policy then execute: ./install_agent.sh 01abc-kladfhcd23-mkjds-3455 mdm"
     exit 0
   fi;

   echo "Installing agent with this license_key: '$LICENSEKEY'"
   sed  "s/LICENSE_KEY_PLACEHOLDER/$LICENSEKEY/g" /private/var/tmp/Augmentt/appsettings_tpl.json > /tmp/appsettings.json
   echo "Checking previous installation..."

   if [ -f /Library/LaunchDaemons/com.augmentt.agent.daemon.plist ]; then
     echo "Daemon exists: /Library/LaunchDaemons/com.augmentt.agent.daemon.plist"
     launchctl unload /Library/LaunchDaemons/com.augmentt.agent.daemon.plist &> /dev/null
     rm -f /Library/LaunchDaemons/com.augmentt.agent.daemon.plist &> /dev/null
     echo "Removing previous installation..."
     if [[ -d "$PREV_DST" || -d "$PREV_ALT_DST" ]]; then
       echo "- Location: $PREV_DST"
       echo "- Location: $PREV_ALT_DST"
       rm -rf /Library/augmentt
       rm -rf /Library/AugmenttAgent
       if [[ $? -ne 0 ]]; then
         echo "Failed to remove agent";
       else
         echo "Removal was successful";
       fi;
     fi;
   fi;

   echo "Installation started..."
   /usr/sbin/installer -verbose -pkg  /private/var/tmp/Augmentt/AugmenttAgent.pkg -target /Applications
   echo "Installation finished."
   ```

   Put your license key into **Parameter 4** of the Jamf policy — that's what populates `$4`/`LICENSEKEY`.
5. Create the Jamf policy to deploy the package first, then run the script immediately after — the script assumes the package has already installed.

### Addigy

1. **Download** the Mac agent from **Discover > Agent**, and copy the target company's license key.
2. **Upload files:** in your Addigy Custom Software item, click **Select File(s) > Upload New**, and upload `AugmenttAgent.pkg` and `appsettings_tpl.json` from the downloaded zip.
3. **Attach the PPPC profile:** create a Manually Added Profile with:
   * **Identify by (Bundle ID):** `Augmentt.DiscoveryAgent.Agent`
   * **Signature:** same signature string as the Jamf section above.
4. **Installation script:**

   ```bash
   #!/bin/bash
   # Augmentt Discovery Agent installer for macOS through Addigy
   LICENSEKEY="<INSERT LICENSE KEY HERE>"

   ##DO NOT EDIT BELOW THIS LINE##
   PREV_DST=/Library/augmentt
   PREV_ALT_DST=/Library/AugmenttAgent
   if [ "$LICENSEKEY" == "" ]; then
     echo "Please provide 'License_key_id' as parameter, e.g. ./install_agent.sh 01abc-kladfhcd23-mkjds-3455"
     echo "If you want to install agent using Addigy MDM policy then execute: ./install_agent.sh 01abc-kladfhcd23-mkjds-3455 mdm"
     exit 0
   fi;

   echo "Installing agent with this license_key: '$LICENSEKEY'"

   sed  "s/LICENSE_KEY_PLACEHOLDER/$LICENSEKEY/g" appsettings_tpl.json > /tmp/appsettings.json
   echo "Checking previous installation..."
   if [ -f /Library/LaunchDaemons/com.augmentt.agent.daemon.plist ]; then
     echo "Daemon exists: /Library/LaunchDaemons/com.augmentt.agent.daemon.plist"
     launchctl unload /Library/LaunchDaemons/com.augmentt.agent.daemon.plist &> /dev/null
     rm -f /Library/LaunchDaemons/com.augmentt.agent.daemon.plist &> /dev/null

     echo "Removing previous installation..."

     if [[ -d "$PREV_DST" || -d "$PREV_ALT_DST" ]]; then
       echo "- Location: $PREV_DST"
       echo "- Location: $PREV_ALT_DST"
       rm -rf /Library/augmentt
       rm -rf /Library/AugmenttAgent
       if [[ $? -ne 0 ]]; then
         echo "Failed to remove agent";
       else
         echo "Removal was successful";
       fi;
     fi;
   fi;

   echo "Installation started..."

   /usr/sbin/installer -verbose -pkg  ./AugmenttAgent.pkg -target /Applications
   echo "Installation finished."

   if [ "$2" == "mdm" ]; then
     echo "Parameter '$2' provided... Installed agent through MDM policy"
   else
     echo "Please, update the 'Security & Privacy' settings by providing 'Full Disk Access' to Augmentt.DiscoveryAgent.Agent"
     open "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles"
   fi;
   ```

   Set the `LICENSEKEY` value directly in the script for the target company.
5. Save the Custom Software item. Optionally attach the **removal script** below for easy remote uninstall.

{% hint style="warning" %}
A real support case reported that after following this Addigy flow (including the PPPC profile), deploying the software only opens the macOS "Full Disk Access" settings pane on the target Mac with no other visible install confirmation, and Augmentt still shows toggled *off* in Full Disk Access. If you see this: verify the PPPC profile's Bundle ID and signature match exactly what's above, confirm the profile is actually scoped to and installed on the target device (not just created in Addigy), and if it persists, get support involved — don't assume the install silently succeeded just because the pane popped up.
{% endhint %}

{% hint style="warning" %}
A separate case reported Mac agents installed via PowerShell + Addigy not showing up at all in the customer's Augmentt portal. If devices don't appear after a reasonable wait (see the 6-hour upload cadence in [Discovery Agent Overview](/modules/discover/agent-overview.md)), check Full Disk Access status and the license key used, then escalate to support with the device list.
{% endhint %}

***

### Uninstalling the agent

#### Windows

**Manual removal:**

1. Click **Start**, type "Add or remove programs," and press Enter.
2. Scroll to **Augmentt Discovery Agent** in the app list.
3. Click it, then **Uninstall**.

**RMM / automated removal:** run this against one device or a batch of devices:

```
"C:\Program Files (x86)\Augmentt\unins000.exe" /VERYSILENT /SUPPRESSMSGBOXES
```

{% hint style="warning" %}
A support case reported the PowerShell/RMM uninstall command failing outright after a demo, blocking removal. If the uninstaller command fails, confirm the path still matches `C:\Program Files (x86)\Augmentt\` on that machine (a non-default install location will break this), and try the manual **Add or remove programs** route as a fallback while escalating to support.
{% endhint %}

#### Mac

**Manual removal:** drag the Augmentt Agent from Applications to the Trash (admin permission required).

**Scripted/remote removal:**

```bash
#!/bin/bash
echo "Cleanup started..."
echo "Unloading daemon: com.augmentt.agent.daemon.plist"
launchctl unload /Library/LaunchDaemons/com.augmentt.agent.daemon.plist &> /dev/null
echo "Unloaded complete"
echo "Removing files"
rm -rf /Library/LaunchDaemons/com.augmentt.agent.daemon.plist
rm -rf /Applications/Augmentt.app
rm -rf /Applications/AugmenttAgent.app
rm -rf /Applications/Augmentt.DiscoveryAgent.Agent.app
echo "Deamon has been successfully removed."
```

### Restarting the Mac agent

Forces the Mac agent to push its collected data to Augmentt immediately, instead of waiting for the next scheduled upload.

1. Download the `RestartAgent.sh` script and move it into the folder where the Augmentt agent files live.
2. Open Terminal and navigate to that folder.
3. Run `sudo -s` and enter your admin password.
4. Make the script executable: `chmod +x .`
5. Run it: `./RestartAgent.sh`

The Mac agent restarts and immediately uploads current data to the Augmentt portal.

{% hint style="info" %}
There's no equivalent documented one-liner for forcing an immediate Windows upload — restart the Augmentt agent Windows service (via Services.msc or your RMM) to get the same effect.
{% endhint %}

### Common deployment issues

A roundup of what actually shows up in support tickets across RMMs and platforms, so you know what to check first:

| Symptom                                                                                                                          | Check first                                                                                                                                                                                                                                                          |
| -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Agent installed, device not visible in the console                                                                               | License key used at install time matches the target company; wait for the 6-hour upload cycle; restart the agent service to force an upload; check outbound firewall rules                                                                                           |
| "X device(s) found with no Discover user license attached" on the Agent page                                                     | This is a licensing/seat issue, not an install failure — you need an available Discover license for that device to be attributed                                                                                                                                     |
| Kaseya VSA procedure fails at a validation step on one specific machine, but the installer runs fine manually on the same device | Isolated, machine-specific failures like this often point to a local state/registry issue on that one device rather than a scripting problem — try a clean re-run of just the installer step manually, and escalate to support with the procedure log if it persists |
| Mac `chmod +x *.*` step does nothing / no error                                                                                  | Confirm the account has admin rights; try Jamf or the scripted RMM install instead of the raw shell steps                                                                                                                                                            |
| Mac agent installs but Full Disk Access shows Augmentt toggled off                                                               | Re-check the PPPC profile's Bundle ID and signature string match exactly; confirm the profile is deployed to the device, not just defined in the MDM                                                                                                                 |
| Uninstall script fails                                                                                                           | Confirm the install path is still the default (`C:\Program Files (x86)\Augmentt\`); fall back to manual Add/Remove Programs                                                                                                                                          |
| Installer shows a certificate warning                                                                                            | Confirm you're using the current signed build; check with support if it's flagging as expired                                                                                                                                                                        |

For anything not covered above, gather the device's agent log, its `BrowserAgent.exe.Config` (Windows) or install log (Mac), the profile/device name, and the employee record it should map to, then open a ticket per [Discovery Agent Overview: what to include in a support ticket](/modules/discover/agent-overview.md#what-to-include-in-a-support-ticket).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://helpdesk.augmentt.com/modules/discover/agent-deployment.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
