How to Deploy SentinelOne Across Windows, macOS & Linux with JumpCloud
JumpCloud's own SentinelOne template only installs on Debian-based Linux, which is where most mixed-fleet rollouts stall. This guide gives working Commands for all three platforms — including a Linux script that detects dpkg or rpm, handles the --nodigest quirk on older agents, and verifies the agent actually registered rather than just installed.
On this page
You deploy the SentinelOne agent from JumpCloud using a Command per operating system. Each Command downloads the installer from a URL your devices can reach, installs it silently, and registers the agent with your site token. Windows and macOS are straightforward. Linux is where most rollouts stall, because JumpCloud's own template only handles Debian packages — if you have RHEL, CentOS or Amazon Linux hosts, you need a script that branches on package manager, which this guide gives you.
Run everything on a pilot group first. Then check the SentinelOne console, not just the JumpCloud exit code, because a Command can report success while the agent sits unregistered.
If you are replacing an existing antivirus product, remove it first. We cover that separately in uninstalling Kaspersky AV and installing SentinelOne via JumpCloud. This guide assumes a clean endpoint.
What do you need before you start?
JumpCloud agent installed and active – The device must appear in Devices with a green status. A Command cannot reach a device the agent does not manage.
JumpCloud agent 2.38.0 or higher – Required if you attach installer files to Commands. Older agents cannot pull attachments over 1 MB.
A SentinelOne site token or group token – Found in the SentinelOne Management Console under Sentinels, in the Packages area. The same token can serve all three operating systems, or you can use a separate group token per platform if you want the agents to land in different groups.
Installer packages hosted where devices can reach them – Download the Windows, macOS and Linux packages from the SentinelOne console, then host them on a URL your endpoints can reach over HTTPS. Alternatively, attach them to the Command itself. JumpCloud allows files up to 150 MB each, but will not accept unsigned
.msior.pkgfiles.Admin rights in both consoles – You need Command creation rights in JumpCloud and package download rights in SentinelOne.
Outbound HTTPS on port 443 – From every endpoint to your SentinelOne console. The agent cannot register without it.
The correct architecture package – SentinelOne ships separate x86_64 and ARM builds, and they are not interchangeable. Check before you host a single file for a mixed fleet.
One prerequisite catches people out on Linux: the endpoint must not reboot between installation and activation. Let the install, association and registration finish before any scheduled restart.
How do JumpCloud Commands work for agent installs?
A Command in JumpCloud is a script targeted at an operating system and a set of devices. The settings that matter for this task:
Type – Choose the target operating system: Linux, Windows or Mac. This determines which devices the Command can run against.
Run As – Select the user account the Command runs under. Installing an endpoint agent needs root or system privileges. JumpCloud's own troubleshooting guidance is that if a Command does not run, verify you have root permissions.
Timeout After – A value in seconds, after which the agent terminates the Command. The JumpCloud Commands default is 120 seconds. A download plus an install rarely finishes in 120 seconds, and the Command fails if it does not. Raise this to 600 seconds as a starting point.
Launch Event – Set to Run Manually for a pilot. Once the script is proven, Run on Every Login or a scheduled event works for catching new devices.
Time to Live – Separate from the run timeout. New Commands default to 3 days, which is how long JumpCloud will keep trying to deliver to an offline device. Extend it if you have laptops that are away for a week.
Files – Optionally attach the installer to the Command instead of hosting it. Files stay in a Pending state until you save the Command.
After each run, open the Results tab. An exit code of 0 means the Command ran successfully. When a Command runs several things in sequence, only the last exit code is reported — which is why every script below checks its own work rather than trusting the exit code alone.
JumpCloud publishes Command templates for all three platforms under Command from Template: Windows - Install Sentinel One Agent, Mac - Install Sentinel One Agent and Linux - Install Sentinel One Agent. The templates are a reasonable starting point. The Linux one works for Debian-based distributions only, which is the gap this guide closes.
How do you deploy the SentinelOne agent on Windows with JumpCloud?
Download the Windows installer from the SentinelOne console. Note whether you have the
.exeor the.msibuild — the token is passed differently for each.Host the installer at an HTTPS URL your endpoints can reach, or attach it to the Command.
In JumpCloud, go to Devices, then Commands, and click + Command.
Set Type to Windows.
Set Run As to an account with system privileges.
Set Timeout After to 600.
Paste a script of this shape, replacing the token and URL:
powershell
$siteToken = "YOUR_SITE_TOKEN"
$installerURL = "https://your.host/SentinelInstaller_windows_64bit.exe"
$installer = "$env:TEMP\SentinelInstaller.exe"
Invoke-WebRequest -Uri $installerURL -OutFile $installer -UseBasicParsing
Start-Process -FilePath $installer -ArgumentList "-t $siteToken -q" -Wait
$svc = Get-Service -Name "SentinelAgent" -ErrorAction SilentlyContinue
if ($svc) {
Write-Output "SentinelAgent service state: $($svc.Status)"
} else {
Write-Output "SentinelAgent service not found"
exit 1
}Assign the Command to your pilot device group, save, then click Run Now.
On .exe versus .msi. The .exe installer takes -t <token> -q, which is what JumpCloud's own template uses. The .msi build is installed through msiexec with the token as a property instead:
msiexec /i "SentinelInstaller_windows_64bit.msi" /qn SITE_TOKEN="YOUR_SITE_TOKEN" /l*v "C:\Windows\Temp\s1install.log"The property name is SITE_TOKEN in uppercase. Installer flags have changed between agent versions, so confirm the syntax against the release notes for the exact build you downloaded rather than assuming. Keep the /l*v log path — it is the first thing you will want if a device fails.
Useful MSI exit codes: 0 is success, 3010 is success with a reboot required, and 1603 is a fatal error that usually means a conflicting product or a permissions problem.
How do you verify the Windows agent installed?
Run this as a separate JumpCloud Command with Run As set to a system account:
powershell
Get-Service -Name "SentinelAgent" | Select-Object Name, Status, StartType
fltmc filters | Select-String "Sentinel"The service should be Running. The second line confirms the SentinelOne filter driver is loaded, which matters because the service can start while the driver that does the actual protecting has not. Then confirm the device appears in the SentinelOne console.
If you manage Windows through Intune instead, we have a separate guide for deploying the SentinelOne Windows agent as a Win32 app.
How do you deploy the SentinelOne agent on macOS with JumpCloud?
macOS needs one step before any installer runs. The agent uses a system extension and needs Full Disk Access, and on recent macOS versions the user cannot grant those reliably — an MDM profile has to.
In JumpCloud, go to Device Management, then Policy Management, and click +.
Open the Mac tab and find SentinelOne Agent Permissions Policy. Click configure, then assign it to your macOS device group.
Let the policy apply before you install anything. Installing first and approving later leaves agents in a half-working state that is harder to diagnose than a clean failure. On macOS 15 Sequoia the toggle for the SentinelOne extension is disabled for end users, so the profile is the only route.
Download the macOS
.pkgfrom the SentinelOne console and host it at a reachable HTTPS URL.Create a new Command with Type set to Mac, Run As set to root, and Timeout After set to 600.
Paste a script of this shape:
bash
#!/bin/bash
SENTINEL_TOKEN="YOUR_SITE_TOKEN"
DOWNLOAD_URL="https://your.host/SentinelOne.pkg"
PKG="/tmp/SentinelOne.pkg"
printf '%s' "$SENTINEL_TOKEN" > /tmp/com.sentinelone.registration-token
chown root /tmp/com.sentinelone.registration-token
curl -fsSL -o "$PKG" "$DOWNLOAD_URL" || { echo "download failed"; exit 1; }
/usr/sbin/installer -pkg "$PKG" -target / || { echo "install failed"; exit 1; }
sleep 30
/usr/local/bin/sentinelctl statusAssign to the pilot group, save, and run.
The token is supplied through a file named com.sentinelone.registration-token placed in the same directory as the package, owned by root. Some deployment tools instead register the token after installation with sentinelctl. Both approaches appear in vendor documentation, and the token-file method is the one that works unattended, so that is what the script above uses. If your package has the token embedded already, drop those two lines.
Our generic DMG installer pattern for JumpCloud covers the same download-and-install shape for .dmg packages, if you need it for other software.
How do you verify the macOS agent installed?
Create a Command with Run As set to root and the body:
bash
/usr/local/bin/sentinelctl statusCheck the Results tab for Protection: enabled. The output also reports Infected and Network Quarantine states.
If the agent installed but protection is not enabled, the permissions policy has not applied. Check System Settings, then General, then Login Items & Extensions, then Network Extensions, and confirm SentinelOne Extensions is enabled. For Full Disk Access the processes that need it are sentineld, sentineld_helper and sentineld_shell, which live in /Library/Sentinel/sentinel-agent.bundle/Contents/MacOS/. Granting these by hand on one machine is a diagnostic, not a deployment method — fix the profile instead.
For Intune-managed Macs, see deploying the SentinelOne macOS agent with Intune.
How do you deploy the SentinelOne agent on Linux with JumpCloud?
This is the part no other guide covers properly. JumpCloud's Linux template runs apt install and nothing else, so it fails on anything that is not Debian-based. Linux fleets are usually mixed, so the script needs to detect the package manager and branch.
Check the Linux requirements first
Architecture – x86_64 or ARM 64-bit only. The ARM and x86 packages are not interchangeable, so a mixed fleet needs two packages and a check in the script.
CPU – SSE4.2 support is required on x86. Older virtualised hosts sometimes lack it.
Disk – At least 2 GB free in
/opt/sentinelone, with 3 GB recommended. This trips up minimal server builds with a small root volume.Memory – Around 800 MB of RAM available for the agent, on top of whatever the host already uses.
Kernel – Kernels older than 3.10 lack container support. Systems with Kernel Lockdown set to Confidentiality are not supported.
SELinux – Works in both permissive and enforcing modes, so you do not need to relax it.
No reboot mid-install – The host must stay up until installation, association and activation have all completed.
Know the two package formats
Debian and Ubuntu – Use the
.debpackage withdpkg -i, orapt install ./package.deb -yif you want apt to resolve dependencies.RHEL, CentOS, Rocky, Alma, Oracle Linux and Amazon Linux – Use the
.rpmpackage withrpm -i. For agent versions 23.2 and earlier you must add--nodigest, or the install fails with "Package SentinelAgent_linux_version does not verify: no digest". Newer agents do not need it.
One Debian-specific gotcha: if you run dpkg directly, /var/lib/dpkg must have exec permissions. On hardened hosts where /var is mounted noexec, the install fails for a reason that has nothing to do with SentinelOne.
Build the Linux Command
Download both the
.deband.rpmpackages from the SentinelOne console, for the architectures you run.Host them at HTTPS URLs your endpoints can reach.
Create a new Command in JumpCloud with Type set to Linux.
Set Run As to root. The install and the
sentinelctlcalls all need it.Set Timeout After to 900. Linux hosts on slower links need the headroom, and a timeout mid-install is messier than a slow success.
Set Launch Event to Run Manually for the pilot.
Paste this script, replacing the token and the two URLs:
bash
#!/bin/bash
set -u
SENTINEL_TOKEN="YOUR_SITE_TOKEN"
DEB_URL="https://your.host/SentinelAgent_linux_x86_64.deb"
RPM_URL="https://your.host/SentinelAgent_linux_x86_64.rpm"
SENTINELCTL="/opt/sentinelone/bin/sentinelctl"
# Skip hosts that already have the agent
if [ -f "$SENTINELCTL" ]; then
echo "SentinelOne already installed; checking status"
"$SENTINELCTL" control status
exit 0
fi
# Detect package manager
if command -v dpkg >/dev/null 2>&1; then
PKG_TYPE="deb"
URL="$DEB_URL"
elif command -v rpm >/dev/null 2>&1; then
PKG_TYPE="rpm"
URL="$RPM_URL"
else
echo "No dpkg or rpm found; unsupported distribution"
exit 1
fi
PKG="/tmp/sentinelone.${PKG_TYPE}"
echo "Downloading ${PKG_TYPE} package"
curl -fsSL -o "$PKG" "$URL" || { echo "Download failed"; exit 1; }
echo "Installing"
if [ "$PKG_TYPE" = "deb" ]; then
apt install -y "$PKG" || dpkg -i "$PKG" || { echo "deb install failed"; exit 1; }
else
rpm -i "$PKG" || rpm -i --nodigest "$PKG" || { echo "rpm install failed"; exit 1; }
fi
# Register and start
if [ ! -f "$SENTINELCTL" ]; then
echo "sentinelctl not found after install"
exit 1
fi
"$SENTINELCTL" management token set "$SENTINEL_TOKEN" || { echo "token set failed"; exit 1; }
"$SENTINELCTL" control start || { echo "agent start failed"; exit 1; }
sleep 30
"$SENTINELCTL" control status
"$SENTINELCTL" management status
"$SENTINELCTL" versionAssign to one test host per distribution family. Not one host — one per family. A script that works on Ubuntu tells you nothing about Amazon Linux.
Save and run, then read the Results tab.
The script checks for an existing install and exits cleanly if it finds one, which makes it safe to re-run and safe to attach to a login event later. The rpm -i fallback to --nodigest means the same script handles older and newer agent versions without you tracking which host has which.
How do you verify the Linux agent registered?
The three sentinelctl calls at the end of the script are your verification, and each answers a different question:
control status– Is the agent process running on this host?management status– Has it reached your console? Look forConnectivityshowingOn. This is the one that matters, because an agent can run locally and never register.version– Which build is installed, which you need when comparing behaviour across a mixed fleet.
Run them by hand on a host as root if you want to check outside a Command:
bash
sudo /opt/sentinelone/bin/sentinelctl control status
sudo /opt/sentinelone/bin/sentinelctl management status
sudo /opt/sentinelone/bin/sentinelctl versionOn systemd. SentinelOne manages its own services, and sentinelctl control start and control status are the supported way to drive them. We could not verify a documented systemd unit name for the Linux agent in SentinelOne's current public documentation, so rather than publish a guess, use this to see what the package actually registered on your host:
bash
systemctl list-units --all | grep -i sentinelOnce you know the unit name on your distribution, systemctl is-enabled <unit> tells you whether the agent survives a reboot. Treat sentinelctl as the authority and systemd as a cross-check, not the other way round.
Finally, open the SentinelOne console and confirm the host appears with the expected group and an active status. A JumpCloud exit code of 0 only proves the script ran.
What goes wrong, and how do you fix it?
The Command times out – The default 120 seconds is not enough to download and install an endpoint agent. Raise Timeout After to 600 for Windows and macOS, and 900 for Linux.
Exit code 0 but no device in the console – The install worked and registration did not. On Linux, run
management statusand look atConnectivity. On any platform, check outbound HTTPS to the console from that host.The Command does not run at all – Verify Run As has root or system privileges, and that the JumpCloud agent shows the device as active.
Linux install fails on a hardened host – Check whether
/varis mountednoexec, which breaksdpkg. Check free space in/opt/sentinelone.rpmreports "does not verify: no digest" – An agent version 23.2 or earlier needs--nodigest. The script above already falls back to it.macOS agent installs but protection stays disabled – The SentinelOne Agent Permissions Policy has not applied. Fix the profile rather than granting permissions by hand.
Wrong architecture package – An x86 package on an ARM host fails in ways that look like a corrupt download. Confirm with
uname -mbefore blaming the file.High CPU on developer machines after rollout – A known pattern on build-heavy endpoints, and an exclusion problem rather than an install problem. See fixing SentinelOne high CPU usage on developer machines.
You need to remove an agent and have lost the passphrase – Covered in uninstalling SentinelOne when the passphrase is missing.
A last piece of advice that is not technical. Deploy in waves by device group, smallest first, and leave a day between waves. Agent rollouts fail in ways that only appear under real workload, and a fleet-wide push on a Friday is how a security improvement becomes an outage. Teams running this across a few hundred mixed endpoints usually fold it into a wider unified endpoint management programme, because the deployment is one afternoon and the exclusions, upgrade cadence and console hygiene are the ongoing work.
FAQs
1) Does JumpCloud support SentinelOne on Linux out of the box?
Partly. JumpCloud publishes a Linux - Install Sentinel One Agent template, but its script only runs apt install, so it works on Debian-based distributions. For RHEL, CentOS, Oracle or Amazon Linux you need a script that branches between dpkg and rpm, like the one in this guide.
2) Can I use one site token for all three operating systems?
Yes. A single site token works across Windows, macOS and Linux. Use separate group tokens instead if you want each platform to land in its own group in the console, which makes policy and exclusion management considerably easier later.
3) Why does the agent install but never appear in the SentinelOne console?
Installation and registration are separate steps. The usual causes are a missing or mistyped token, no outbound HTTPS on port 443 to the console, or a reboot that interrupted activation. On Linux, sentinelctl management status tells you directly — Connectivity: On means registered.
4) Should we deploy with JumpCloud or Intune?
Use whichever already manages the device, and do not split one platform across both. JumpCloud is the better choice for mixed fleets, since it handles Linux alongside Windows and macOS. Intune is the natural fit for Windows-heavy, Entra-joined estates — see our Intune Win32 guide. If you are deciding across a mixed environment, that trade-off is part of a broader unified endpoint management decision rather than a per-tool one.
Rolling this out across a mixed fleet?
NetNXT deploys and manages SentinelOne and JumpCloud for enterprises across India. Talk to our team — 30 minutes, no demo.
Need help securing your environment?
Talk to a NetNXT security expertStay ahead of the next vulnerability
New KB guides, threat advisories and hardening playbooks from NetNXT's security team — straight to your inbox.
NetNXT will handle your data pursuant to its Privacy Policy.
Like this guide? Join our team.
NetNXT builds security for how modern enterprises actually run.
View open roles