Installing InnerWarden
Every way to install the free InnerWarden Community guardrail on Linux, macOS, and Windows, and how to verify each download with checksums, signatures, and npm provenance.
For: anyone choosing how to install the free Community guardrail, from "give me the fastest command" to "show me the keys and let me verify every byte".
The Community edition is a single per-user binary, innerwarden: pure Rust, no daemon, no kernel module. It runs entirely as your user, needs no root, and keeps its config under ~/.config/innerwarden. The one caveat is where a given package manager puts a global binary: npm install -g writes to npm's prefix, which is root-owned on a distro-packaged Node (see below). Every method below ends at the same signed binary. Pick the one you trust.
Shortcut names differ by method: the curl | sh installer also links iw and iw-guard to it in ~/.local/bin, npm adds iw, and the .deb/.rpm install /usr/bin/innerwarden alone, because iw is the Linux wireless tool's name and a system package must not shadow it. innerwarden works everywhere; use that in scripts.
In a hurry? On macOS and Linux,
curl -fsSL https://www.innerwarden.com/free | sh; on Windows,irm https://www.innerwarden.com/free.ps1 | iex. It picks the signed binary for your machine and installs it without root: the shell installer checks its sha256 and its Ed25519 signature and installs to~/.local/bin; the Windows one checks its sha256 and installs to%LOCALAPPDATA%\Programs\InnerWarden. Everything else on this page is another route to the same signed binary: npm if you already live in npm, a native package if you want your system to track it, or from source if you want to build it yourself.
What the free tier does not stop. It screens an agent's shell commands and MCP calls, and, from 1.5.5, Claude Code's file-writing tools for privileged files only. It does not screen what the agent reads through its file tools or the other files it writes, it cannot stop a same-user agent that reaches your files by a route the hook does not see, and it does not control network egress or processes that detach from the screened call. The full list, and the paid layer that covers each, is in What the free tier does not stop.
Or have your agent install it
If you already have a coding agent open, it can do all of this. Point it at the public innerwarden-skill repository and tell it:
install InnerWarden and verify it is actually screening my commands
It works out which machine it is on, installs the right way for it, wires your
agent, and refuses to report success until scripts/verify-install.sh exits 0.
That script does not check that files exist: it sends real commands through the
guard and reads the verdicts, because "installed" and "protecting you" are
different claims.
Every command on this page still works, and nothing here is skipped by taking that route. It is the same install, done by something that types faster.
The install methods
1. npm (all platforms, if you already use npm)
Same command on Linux, macOS, and Windows. Downloads a prebuilt binary, no compiler, no postinstall script. It is the only method here that carries npm provenance, so reach for it if that is what you want to verify against.
On Linux, expect this to need sudo. InnerWarden itself never needs root, but npm install -g needs write access to npm's global prefix, and on a distro-packaged Node (for example apt install npm on Ubuntu) that prefix is /usr/local/lib/node_modules, owned by root. Without sudo the command fails with EACCES before InnerWarden is reached. To keep everything in your user directory instead, point npm at a prefix you own first (npm config set prefix ~/.npm-global, then add ~/.npm-global/bin to your PATH), or use npx innerwarden, or use the shell installer, which needs no root on any platform.
npm install -g innerwarden
# or run it once without installing:
npx innerwarden --help
Under the hood, innerwarden is a tiny launcher that pulls in the one prebuilt package matching your OS and CPU (@innerwarden/cli-linux-x64, @innerwarden/cli-darwin-arm64, @innerwarden/cli-win32-x64, and so on). There is no install-time download and no postinstall step, so npm install --ignore-scripts works and the only artifact is the registry tarball. How to verify: see npm provenance below.
2. Debian / Ubuntu (.deb)
Download the package for your architecture and install it with apt. This is a native package: your system records it, and apt remove innerwarden uninstalls it.
# amd64 (Intel/AMD)
curl -fsSLO https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden_amd64.deb
sudo apt install ./innerwarden_amd64.deb
# arm64
curl -fsSLO https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden_arm64.deb
sudo apt install ./innerwarden_arm64.deb
Note the leading
./soaptinstalls the local file rather than looking for a repository. These names always carry the current release; to pin an exact one, the same tag also holdsinnerwarden_<version>_amd64.deb. How to verify: see checksums below.
3. Fedora / RHEL / Rocky / openSUSE (.rpm)
# x86_64
sudo dnf install https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden.x86_64.rpm
# aarch64
sudo dnf install https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden.aarch64.rpm
(Use zypper install on openSUSE, or rpm -i directly.) How to verify: see checksums.
4. Shell installer (macOS / Linux)
The one-liner that selects the right signed binary for your machine, checks its SHA-256, and verifies its Ed25519 signature before installing.
curl -fsSL https://www.innerwarden.com/free | sh
Prefer not to pipe into a shell? Read it first, then run it:
curl -fsSL https://www.innerwarden.com/free -o install-innerwarden.sh
less install-innerwarden.sh # read it
sh install-innerwarden.sh
Overrides: IW_GUARD_DIR (install dir, default ~/.local/bin), IW_GUARD_TAG (the release to pull from; defaults to iw-guard, the rolling release; set it to a numbered Community release, guard-v<version>, to pin that exact cut), IW_GUARD_NO_HOOK=1 (skip wiring the agent hook).
5. Windows
PowerShell one-liner:
irm https://www.innerwarden.com/free.ps1 | iex
Or with Scoop, which resolves the current signed binary from its published manifest:
scoop install https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden.json
6. Other binary installers (ubi, eget, mise)
These read the GitHub release directly, so there is nothing to trust beyond the signed binary itself.
# ubi (Universal Binary Installer)
ubi --project InnerWarden/innerwarden-releases --tag iw-guard --exe innerwarden --in ~/.local/bin
# eget
eget InnerWarden/innerwarden-releases --tag iw-guard --asset innerwarden --to ~/.local/bin
# mise (version manager, ubi backend)
mise use -g "ubi:InnerWarden/innerwarden-releases[exe=innerwarden,tag=iw-guard]"
7. From source (Rust)
cargo install --git https://github.com/InnerWarden/inner-warden innerwarden
This compiles from source, so it is the slowest path and the one with prerequisites: a Rust toolchain (rustup) and a C linker, which a minimal Linux image does not ship. On a stock Ubuntu or Debian, sudo apt-get install -y build-essential; on Fedora or RHEL, sudo dnf install -y gcc. Without a linker the build stops at linker `cc` not found while compiling the first proc-macro crate. Every other method on this page is a prebuilt binary and needs none of this. cargo install innerwarden and cargo binstall innerwarden (which fetches the prebuilt binary) are coming once the crate is published to crates.io.
Verifying your download
Every method ends at the same signed artifact, but each gives you a different way to prove you got the real one.
npm provenance
Each npm package ships a signed provenance attestation that links it to this source repository and the exact CI build that produced it. npm verifies the registry signature automatically on install. To inspect or verify it yourself:
# in a project that depends on innerwarden
npm audit signatures
The provenance is also shown on the package page at npmjs.com/package/innerwarden. This is the strongest chain: registry signature plus a build attestation, no key handling on your side.
Checksums (.deb, .rpm, and binaries)
Every release asset publishes a .sha256 next to it. For the Linux packages the file is in standard format, so you can check it directly:
curl -fsSLO https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden_amd64.deb
curl -fsSLO https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard/innerwarden_amd64.deb.sha256
sha256sum -c innerwarden_amd64.deb.sha256 # macOS: shasum -a 256 -c
# -> innerwarden_amd64.deb: OK
The two installer scripts, iw-guard-install.sh (what https://www.innerwarden.com/free serves) and install.ps1, ship the same .sha256 and Ed25519 .sig as the binaries, made over the published bytes. The key pinned inside an installer cannot vouch for that installer, so these let you check the script before you hand it to a shell. The .sha256 of a Community binary or installer is a bare hash rather than the sha256sum format, so give the tool a line to check (the paid host stack's .sha256 files are in sha256sum format, see the next section):
base=https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard
asset=iw-guard-install.sh
curl -fsSLO "$base/$asset"
curl -fsSLO "$base/$asset.sha256"
curl -fsSLO "$base/$asset.sig"
curl -fsSLO "$base/innerwarden-release.pub"
echo "$(cat "$asset.sha256") $asset" | sha256sum -c # macOS: shasum -a 256 -c
# -> iw-guard-install.sh: OK
# The signature is checked the same way as a binary's (next section).
openssl dgst -sha256 -binary "$asset" > digest.bin
base64 -d < "$asset.sig" > sig.bin # macOS: base64 -D
openssl pkeyutl -verify -pubin -inkey innerwarden-release.pub -rawin -in digest.bin -sigfile sig.bin
# -> Signature Verified Successfully
sh "$asset"
For install.ps1, use the same two checks with asset=install.ps1.
The paid host installer
From 0.16.75 the paid host stack's install.sh ships a .sha256 and an Ed25519 .sig next to it on its release, signed by the release pipeline. They are assets of that release in the public releases repository, not files on this site: https://www.innerwarden.com/install redirects to the install.sh of one release, and the checksum and signature are in that same release. Earlier releases ship neither, so look for install.sh.sig on the release page before you rely on this. Unlike the Community installers above, the .sha256 here is already in sha256sum format (the hash, two spaces, the file name), so sha256sum -c takes it as shipped. The signature is the same scheme as a binary's: base64 of an Ed25519 signature over the raw SHA-256 digest of the file. It needs OpenSSL 3.
The public key is published on this site, a different host from the GitHub release that carries the installer, so tampering with the release alone cannot also swap the key:
https://www.innerwarden.com/keys/innerwarden-release-signing.pub.pem- SHA-256 fingerprint of the raw 32-byte key:
0bd3a6aaf29dbfe8d3d23983a5bcc0560dd80ec64212b065ca9cd18ba732c494
It is the same key the Community release publishes as innerwarden-release.pub, and the key install.sh itself pins.
# The release that /install serves is the tag in its redirect target:
base=$(curl -sI https://www.innerwarden.com/install | tr -d '\r' | sed -n 's#^[Ll]ocation: \(.*\)/install\.sh$#\1#p')
echo "$base"
# -> https://github.com/InnerWarden/innerwarden-releases/releases/download/vX.Y.Z (the tag of the release /install serves)
# If the tag is older than v0.16.75 there is no install.sh.sha256 or install.sh.sig to fetch.
# To check a different release, set base=https://github.com/InnerWarden/innerwarden-releases/releases/download/vX.Y.Z
curl -fsSLO "$base/install.sh"
curl -fsSLO "$base/install.sh.sha256"
curl -fsSLO "$base/install.sh.sig"
curl -fsSLO https://www.innerwarden.com/keys/innerwarden-release-signing.pub.pem
# The key is the one in the fingerprint above:
openssl pkey -pubin -in innerwarden-release-signing.pub.pem -outform DER | tail -c 32 | sha256sum # macOS: shasum -a 256
sha256sum -c install.sh.sha256 # macOS: shasum -a 256 -c
# -> install.sh: OK
openssl dgst -sha256 -binary install.sh > digest.bin
base64 -d < install.sh.sig > sig.bin # macOS: base64 -D
openssl pkeyutl -verify -pubin -inkey innerwarden-release-signing.pub.pem -rawin -in digest.bin -sigfile sig.bin
# -> Signature Verified Successfully
On macOS the system openssl is LibreSSL and cannot verify Ed25519; use OpenSSL 3 by its full path (brew install openssl@3). The same checks for any host-stack binary, what the installer verifies for you and what a signature does not prove are on Supply Chain Security. Run the installer only after both checks pass, and run the file you checked (sudo bash install.sh --license=/path/to/license.txt) rather than piping /install again, which would fetch it a second time. The key pinned inside install.sh vouches for the binaries it downloads, never for the script itself, which is why these two checks exist.
Ed25519 signatures (most paranoid)
Every release binary also ships an Ed25519 .sig, and the release publishes its public key as innerwarden-release.pub. The signature is Ed25519 over the SHA-256 digest of the binary, so a tampered mirror or a swapped asset is rejected, not just a corrupted download.
base=https://github.com/InnerWarden/innerwarden-releases/releases/download/iw-guard
asset=innerwarden-linux-x86_64 # pick your os/arch
curl -fsSLO "$base/$asset"
curl -fsSLO "$base/$asset.sig"
curl -fsSLO "$base/innerwarden-release.pub"
# Needs OpenSSL >= 1.1.1. On macOS install it (brew install openssl@3) since the
# system LibreSSL cannot verify Ed25519; use its full path if `openssl` is LibreSSL.
openssl dgst -sha256 -binary "$asset" > digest.bin
base64 -d < "$asset.sig" > sig.bin # macOS: base64 -D
openssl pkeyutl -verify -pubin -inkey innerwarden-release.pub -rawin -in digest.bin -sigfile sig.bin
# -> Signature Verified Successfully
install -m 0755 "$asset" ~/.local/bin/innerwarden
The curl | sh installer does exactly this automatically, against a public key pinned inside the installer itself, so it rejects a swapped binary even from a compromised release host. For the strongest guarantee, compare innerwarden-release.pub against the copy of the key published on this site, whose SHA-256 fingerprint (0bd3a6aaf29dbfe8d3d23983a5bcc0560dd80ec64212b065ca9cd18ba732c494, of the raw 32-byte key) is on Supply Chain Security, so no single host controls both the binary and the key.
After installing
innerwarden setup # guided onboarding: how you get alerts, monitor mode
innerwarden dashboard # the local security record and detected agents
innerwarden --version
InnerWarden starts in monitor mode: nothing is blocked until you choose enforcement. Beyond the download, the installer sends one anonymous install ping (version, OS and architecture; see Privacy); set INNERWARDEN_NO_TELEMETRY=1 before running it to skip that ping. To remove it: innerwarden uninstall, then delete ~/.config/innerwarden for all state.