One file per platform — Linux, macOS and Windows. On Linux and macOS the AI model is inside
that file. On Windows it is not: the Windows installer format cannot carry a file that
large, so the installer downloads the model while it installs — the same total, in two
pieces instead of one. Once it is installed, on every platform, the part that reads your
documents runs with zero network egress. A larger model is available afterwards as an optional,
signed download or an offline import; nothing requires it. Worth reading first:
what you need to run it, and
the optional larger model. Every download is bound to an
Ed25519-signed manifest — see verifying integrity below.
This release (1.2.0) doesn't publish a macOS (Apple Silicon) build yet — the
builds below are for Linux & Windows. SealedBrief supports macOS (Apple Silicon); this page lists
whatever the signed release manifest currently carries, so the macOS (Apple Silicon)
download appears here by itself as soon as it publishes. Email support@sealedbrief.com if you need it now.
# 1. make it executable
chmod +x SealedBrief-1.2.0-x86_64.AppImage
# 2. run it (Debian 12, Ubuntu 20.04 and similar ship libfuse2):
./SealedBrief-1.2.0-x86_64.AppImage
# No libfuse2 (Ubuntu 22.04+, Fedora, Arch, NixOS)? Run without FUSE —
# universal, no install, no sudo, works on every distro:
./SealedBrief-1.2.0-x86_64.AppImage --appimage-extract-and-run
# ...or, on Debian/Ubuntu only, install FUSE and run it normally:
sudo apt install libfuse2
Not code-signed yet — Windows SmartScreen will warn you before it runs. That is
expected, and the SHA-256 below is the check that actually matters: it proves the
file is byte-for-byte the one we published, which a signature alone does not.
1. Double-click SealedBrief-1.2.0-win64-setup.exe. It is an ordinary Windows installer:
it puts SealedBrief in Programs and Features, in the Start menu
and on your desktop, and asks you almost nothing.
2. This build is not code-signed yet, so Windows SmartScreen will
warn you. Choose "More info" and then "Run anyway" — and use the
SHA-256 above first, which is how you confirm the download is
exactly the file we published. (The dialog varies between
machines; if yours offers no "More info", the file's Properties
panel has an "Unblock" checkbox.)
3. The installer downloads the language models while it runs —
about 6.3 GB, once, and about 9 GB more if you tick the larger
model. Stay connected until it finishes; an interrupted download
resumes rather than starting over.
4. Scanned PDFs coming up empty? The OCR engine ships inside
the installer. If it somehow didn't, install Tesseract OCR
(github.com/UB-Mannheim/tesseract) and SealedBrief picks it up
automatically — or email support@sealedbrief.com.
Other platforms · same signed release
What you need to run it
SealedBrief does the AI work on your own machine, so your machine has to be up to it. These
are the real numbers, including the ones that disqualify a laptop.
Memory
16 GB of RAM is the figure to plan for. SealedBrief checks before it starts: below 12 GB it warns you, and below 6 GB it refuses to launch rather than crash part-way through loading the model.
Disk
About 7 GB free for the install. Roughly 16 GB if you later add the optional larger model described below. On Windows the models are downloaded during installation rather than shipped inside the installer, so plan on about 3 GB free where you install the app and about 7 GB free on the drive holding your Windows user profile — 16 GB there if you tick the larger model in the installer.
Network
Needed once, to download the file — and on Windows, needed again during the installation itself, because that is when the models arrive. After that the document work — indexing, search, OCR and answering — runs with the network unplugged on every platform. For a machine that has no internet at all, see Installing on a machine with no internet, below.
Linux
System
64-bit x86 (x86-64). One portable .AppImage — Debian, Ubuntu, Fedora, Arch, NixOS. No install step and no .deb: the bundled model is larger than the Debian package format allows in a single member.
Graphics
An NVIDIA GPU with about 12 GB of memory or more answers in seconds. Smaller GPUs work. No GPU at all also works, on the processor, at tens of seconds per answer.
Also needs
A desktop keyring (GNOME Keyring or KWallet, i.e. libsecret) to store your vault key, and either libfuse2 or the --appimage-extract-and-run flag shown in the install steps above.
macOS
System
macOS 14 (Sonoma) or newer, on Apple Silicon — M1 through M4. Intel Macs are not supported, and no build for them is planned.
Memory
16 GB of unified memory is the minimum; 24 GB is comfortable. The GPU share of that memory is what runs the model, so unified memory is doing double duty.
Graphics
Apple's own Metal acceleration — there is nothing to install and no separate graphics card involved.
Windows
System
Windows 10 or 11, 64-bit on x86-64. Windows on ARM is not supported. SealedBrief arrives as an ordinary installer: it registers in Programs and Features, adds a Start-menu entry and a desktop shortcut, and uninstalls the same way anything else does. Double-clicking it installs SealedBrief for you alone and raises no administrator prompt, which is what a locked-down work machine usually allows; installing for everyone on the machine is the one path that needs administrator rights.
Graphics
An NVIDIA GPU with about 12 GB of memory or more is the accelerated path. AMD and Intel graphics run through a Vulkan backend we still call experimental — it works in our testing but has not yet been proven on a wide spread of real cards. If neither is usable the app falls back to the processor on its own and keeps working, slowly.
Worth knowing
Windows is the newest of the three builds. It runs the same engine as Linux and macOS, but it has had the least time in front of real users, and we have not yet verified moving a vault from one operating system to another.
What is inside the download
The AI models the app runs on — the language model plus the retrieval and reranking models —
come with it. On Linux and macOS they are inside the file you just downloaded,
which is why it is measured in gigabytes rather than megabytes. On Windows they arrive as a
download during the installation instead: Inno Setup, the Windows installer format, refuses
to build a single setup file above about 4.2 GB, and the language model on its own is
5.0 GB. The bytes you transfer are the same either way.
What does not change is what happens afterwards. Once it is installed, on every platform,
the document work runs fully offline and your documents never leave the machine. You can
pull the network cable out and keep working.
The language model in the box is Qwen3-8B, an open model under the
Apache-2.0 licence. It is not a frontier cloud model and we do not pretend otherwise — it is
a capable local model whose answers you should read against the sources it cites. It is also
the whole product: nothing is held back, nothing is gated behind an upgrade, and the app is
complete on this model alone, permanently.
The optional larger model
There is a bigger model, Qwen3-14B, and we would rather tell you it exists
than have you find out later. It is a separate ~9 GB download — never
inside the file on any platform — and it is genuinely optional, an upgrade and not a
requirement. On Windows the installer offers it as a tick-box, unticked, so you can take it
in the same pass if you want it; everywhere else you add it later from Settings.
Read this before you spend the 9 GB. It needs roughly
13 GB of free video memory to load. Below that, SealedBrief will keep using
the bundled 8B and the larger file will simply sit on your disk unused — and on a machine
with no usable GPU it will never be selected at all. The app works this out from your actual
hardware and tells you, in plain words, before the download starts: how big the file
is, how much disk you have left, and whether this machine would end up using it. It does not
block you, because it is your machine — but it will not let you spend the download without
knowing.
What it buys you is a modest step up in answer quality on a large GPU, not a different class
of model. It is a bigger version of the same open model, not a frontier one; if you are
hoping it closes the gap to a cloud model, it does not.
How the download behaves, if you want it: it is resumable — interrupt it,
close the app, come back tomorrow, and it picks up from the bytes already on disk rather than
starting over. It is verified before it is ever loaded: the file is
SHA-256 checked against a digest inside an Ed25519-signed manifest, and a file that fails is
deleted rather than used. And it is available offline — on an air-gapped
machine, fetch the file on a connected computer, carry it over on a USB drive, and use
Settings → Models → “Import model file…”, which runs the same verification with no network
at all.
The whole air-gapped recipe is one file: open the signed manifest at
downloads.sealedbrief.com/models/v1/manifest.json on any online machine. Each
model entry carries its sha256 and its cdn_path; the file's address
is https://downloads.sealedbrief.com/ followed by that cdn_path.
The app shows the same address and digest under Settings → Models, so you can read it off
either surface and compare.
Ready to buy? Compare the two tiers on the pricing page — Personal $199,
Professional $499, both a 3-year term. A licence unlocks this same install instantly, with no
reinstall and no lost work, and every purchase is backed by a 30-day, no-questions refund — separate
from the free trial above.
Installing on a machine with no internet
On Windows the models arrive during installation, so a machine that will never touch the
internet needs them carried in. The route is supported and it is two steps.
On the installer, skip the download. Run it as
SealedBrief-<version>-win64-setup.exe /SKIPMODELS=1. The application
installs normally and opens; it simply has no model yet, and says so rather than pretending
otherwise.
Then bring the models in. Fetch them once on a connected machine using the
signed manifest described below, copy them to a USB drive, and use
Settings → Models → Import on the offline machine. Every imported file is checked
against the same signed manifest and the same SHA-256 digest the download path uses — an
altered file is rejected there exactly as it would be over the network.
Linux and macOS are unaffected: their downloads still carry the models inside the file, so
an air-gapped install is the ordinary install.
Verifying integrity (optional, recommended)
The release ships an Ed25519-signed manifest covering the binary's SHA-256 hash. The same
public key SealedBrief uses to verify your purchased licence offline is the one that signs
this manifest. So a tampered binary anywhere along the download path (CDN-cache poisoning,
malicious mirror, mid-flight injection) gets caught by the same cryptographic chain that
secures your licence.
The verification script below downloads the manifest and the SealedBrief public key, then
Ed25519-verifies the signature over the canonical manifest bytes. Then compute the binary's
SHA-256 and match it against the manifest entry. If either check fails, the binary is
suspect — don't run it; email support@sealedbrief.com.
One-liner (requires Python 3 + cryptography)
python3 -c '
import base64, json, urllib.request
from cryptography.hazmat.primitives import serialization
# Fetch the manifest + the bundled public key.
manifest_url = "https://downloads.sealedbrief.com/releases/1.2.0/release_manifest.json"
pubkey_url = "https://sealedbrief.com/release_pubkey.pem" # mirror of the in-binary pubkey
manifest = json.loads(urllib.request.urlopen(manifest_url).read())
pubkey = serialization.load_pem_public_key(urllib.request.urlopen(pubkey_url).read())
# Strip the signature + base_url before computing canonical bytes
# (publish.py adds both fields AFTER signing).
sig = base64.urlsafe_b64decode(manifest.pop("signature") + "==")
manifest.pop("base_url", None)
canonical = json.dumps(manifest, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("utf-8")
pubkey.verify(sig, canonical)
ver = manifest["version"]
print(f"Manifest signature verified — version {ver}.")
print("Now: compute the SHA-256 of your download (sha256sum on Linux, shasum -a 256 on macOS) and match it against the manifest entry.")
'
That check verifies the binary is the one we published. To audit the
running app — confirm the document engine has no network egress and that your vault
is encrypted at rest — follow the reproducible procedures on the verify-it-yourself page.