Proof per CVE, approvals and receipts · for ops teams and MSPs

Secure patch management for your Linux servers. See what's really patched, per CVE — then run patches, restarts and reboots only with a person's approval. Every change proven and receipted.

HostCrust is a hosted tool for ops teams and MSPs that run Linux servers: it shows, per CVE, what's really patched, and by default makes patches, restarts and reboots wait for an approver.

Install a small agent with one command. It only makes outbound connections and runs only what that server's own allowlist permits; shell stays off. By default, patches, restarts and reboots wait for an approver. Then Patch Proof re-checks the CVEs the patch targeted, from the inventory the agent sends back, and every change lands in a receipt you can verify offline.

3 servers free · then $5 per server per month · no contract

Free tool See which CVEs are really open on your Linux server

/etc/hostcrust/agent.conf On your server
[agent]
url = https://app.hostcrust.com
# read: diagnostics and inventory; patch: package upgrades;
# service: systemctl restart; reboot: scheduled reboot.
allow = read, patch, service, reboot
# shell.run runs any command as root. Off unless you set this to true.
allow_shell = false
The default allowlist, as the installer writes it. Leave a class out and the agent refuses every action in it, even when our app asks.

The problem

Why “is this server patched?” is so hard to answer

Three honest gaps make patch status hard to trust. HostCrust is built around all three.

  • Version numbers lie

    A check that compares version numbers flags fixes your distribution already backported — the string didn't change, so it reads as still open — and misses a patched kernel nobody rebooted into, where the fix is on disk but the vulnerable code is still running.

  • “Updated” isn't proof

    A successful apt run tells you a command finished, not which CVEs it actually closed, or whether a service still needs a restart to pick up the fix.

  • No clear record

    When a change does happen — a patch, a restart, a reboot — there's often no record of who asked, who approved it, and what the result was.

HostCrust answers all three: proof of what's fixed per CVE, a person's approval before a change runs, and a receipt for every change.

Overview

What is HostCrust?

HostCrust is a hosted service for guarded operations on Linux servers, built for ops and DevOps teams and for the MSPs and agencies that run servers for clients. A small agent on each server makes only outbound HTTPS connections and runs only the kinds of action that server's own local allowlist permits; shell is off by default. The dashboard shows live status and, through Patch Proof, which CVEs are really open on each server, which are fixed by a distro backport, and which are patched on disk but not running until a reboot. By default, patches, service restarts and reboots wait for an approver, and every action is written to a hash-chained receipt you can export and check offline with hc-verify, our open-source verifier. HostCrust supports Ubuntu 20.04 and newer, Debian 11 and newer, and AlmaLinux and Rocky Linux 8 and newer. It is free for up to 3 servers, then $5 per server per month; during early access everything is free.

Why HostCrust

Built so you don't have to take our word for it

Plenty of tools can run a command on a server. HostCrust is built around everything else: a check that it worked, from what the agent on the server reports, the limits each server sets for itself, and a record you can hand an auditor to check.

  • Proof, not “updated”

    “Packages updated” isn't proof. HostCrust says “CVE-2024-6387: fixed in 1:9.6p1-3ubuntu13.3, installed and running.” Every CVE is checked against your distro's own fixed build, backports included, and against the kernel that's actually running.

  • Zero trust, even in us

    A local allowlist on each server decides what the agent will ever do, and shell is off by default. Even a breached HostCrust can't run what your server didn't allow.

  • Receipts anyone can verify

    Every change gets a hash-chained receipt: request, policy, approval, run, verification. Export it and check it offline with hc-verify, our open-source verifier. Edit an entry and the check fails; with a daily anchor it also catches a rebuilt or shortened log.

  • Affordable and honest

    $5 per server per month, the first 3 free, no sales call. And a rule we hold ourselves to: we never market a feature that isn't built.

How it works

One loop for every change

Request, policy, approval, run, verify, receipt. Every time, whoever asked.

  1. 1 Request

    Someone on your team asks for a change: a patch, a restart, a reboot or a diagnostic.

  2. 2 Policy

    Your org's policy decides. By default, diagnostics run straight away and patches, restarts and reboots wait for approval.

  3. 3 Approval

    An approver signs off on the exact action: server, action and parameters, bound by a hash. Change anything and it needs a new approval.

  4. 4 Run

    The agent checks the server's local allowlist, then runs the action as a fixed argument list. No shell unless you turned it on.

  5. 5 Verify

    After a patch, Patch Proof re-checks the CVEs it targeted from the inventory the agent sends back. A restarted service must report active, and a rebooted server a new boot ID. These results are reported by the agent on the server.

  6. 6 Receipt

    Who asked, the policy, who approved (when approval was needed), what ran and what the agent reported back: hash-chained, exportable, checkable offline.

Watch how it works 1 minute · music, no narration

Everything is on screen, so you can follow it muted; there's a calm background music track but no speech. The app screens in it are illustrations with example data.
Read the video as text
  1. Title. How HostCrust works. See what's really patched. Approve changes before they run.
  2. The problem. It's hard to tell what's really patched. “Packages updated” isn't proof. And changes happen without a clear record.
  3. Patch Proof, on every server. See what's really patched. Open CVEs, from the server's own package and kernel inventory. Checked against the kernel that's actually running. Checked again after each patch.
  4. One loop for every change. Approve changes before they run: request, policy, approval, run, verify, receipt. Someone on your team asks for a change. By default, patches, restarts and reboots wait for an approver. An approver signs off on the exact action. The agent checks the server's allowlist, then runs it. Patch Proof re-checks the CVEs the patch targeted. Every change lands in a receipt. Results are as reported by the agent on the server.
  5. On your server. A local allowlist on each server decides which kinds of action the agent will ever run. Shell is off by default. The agent only makes outbound HTTPS connections. It opens no ports, and you never share SSH keys with us.
  6. Receipts. A receipt for every change. Every action is written to a hash-chained, append-only log. Export it and check it offline with hc-verify, our open-source verifier: github.com/HostCrust/hc-verify.
  7. End. Free for up to 3 servers. Sign up at hostcrust.com.

Connect a server in one command

curl -fsSL https://app.hostcrust.com/agent/install.sh | sudo HOSTCRUST_ENROLL_TOKEN=… sh

Get the token from Add server in the app. Read install.sh first if you like: it pins the agent's SHA-256 hash, and the agent is a single Python file.

How it's different

Not a scanner, not a cron job, not a bot

HostCrust sits where those three leave a gap — honest about what each does well.

  • Instead of a version-string check

    Check the build that's running

    HostCrust reads what's actually installed and running, counts the fixes your distribution backported, and proves it per CVE — not a guess from version numbers.

  • Instead of patching by hand or cron

    Every change leaves a trail

    No more ad-hoc changes with no record. Every patch, restart and reboot is approved, verified against the CVEs it targeted, and written to a receipt.

  • Instead of fire-and-forget automation

    Changes wait for a person, by default

    A patch, restart or reboot waits for an approver by default, and the server's own allowlist has the last word on what the agent can ever do — so a mistake, or a breach, can't run wild.

Who it's for

Built for the people who keep Linux servers running

If you're responsible for Linux servers staying patched — and being able to show it — HostCrust is built for you.

  • Ops & DevOps teams

    Keep a fleet patched without guessing. See what's really open per server, approve changes as a team, and keep a change record you didn't have to assemble by hand.

  • MSPs & agencies

    Manage many clients' Linux servers from one place. Every patch, restart and reboot is approved and receipted, so you can show each client exactly what you did and when.

  • Platform & security teams

    Prove patch status to auditors with per-CVE evidence, and gate risky changes behind approval — so a patch, restart or reboot on production waits for a person by default.

Features

What works today

Everything here works now, and all of it is free during early access.

  • Connect in one command

    A small agent that only makes outbound HTTPS connections: no inbound ports, no SSH keys shared with us. Ubuntu 20.04+, Debian 11+, AlmaLinux and Rocky Linux 8+.

  • Live status

    Uptime, load, memory, disk, failed services and “reboot needed” for every server, on one screen.

  • Patch status with proof

    Refreshed daily and after each patch: what's really open, what's fixed by a backport, and what's patched on disk but not running until a reboot.

  • Guarded actions

    By default, diagnostics run straight away, and patches, service restarts and reboots wait for approval; your policy can change that. Shell stays off unless you turn it on, on the server itself.

  • Read-only diagnostics

    Status, top processes, and a service's journal and status, run from the dashboard. Diagnostics change nothing on the server.

  • Patch Proof reports

    Download a report for any server: one HTML file listing every CVE, with a link to your distro's advisory.

  • Receipts

    A hash-chained, append-only record of every action: who, what, policy, approval, before and after, verification. Export it as JSON or a printable record.

  • Team and roles

    Owner, admin, approver, member and viewer. Two-factor sign-in (TOTP) is required for everyone, before they see a single server.

Roadmap

What's live, and what's next

Everything under "Available now" works today, on every plan. We're building the rest, and we don't put a date on anything or market a feature until it's built.

Available now

  • Connect in one command
  • Live status
  • Patch Proof
  • Guarded actions
  • Read-only diagnostics
  • Patch Proof reports
  • Receipts
  • Team and roles (2FA)

All on every plan. See what each does.

Rolling out · early access, no dates

  • AI agents over MCP (Claude Code, Codex, Cursor)

    AI agents connect over MCP. They can propose changes; people approve them.

  • The agent's code on GitHub

    The agent that runs on your servers goes public, so you can read it on GitHub.

  • Paid plans

    $5 per server per month for each server beyond the first 3. Until they open, everything is free.

Later · not dated, not included today

  • Snapshots and rollback
  • Backups and restore tests
  • SSO and SCIM
  • Slack approvals
  • Client approvers for agencies
  • Windows servers

Pricing

Free for 3 servers. $5 a server after that.

The same features on both plans — nothing is paywalled; plans differ only by the number of servers. No contract, no minimum, no sales call.

During early access everything is free; paid plans open later.

Free

$0 per month

Up to 3 servers

  • Every feature — Patch Proof, guarded actions, receipts, team roles (see all)
  • Not a trial
Start free

Grow

$5 per server per month

For each server beyond the first 3

  • Everything in Free — the same features, just more servers
  • No contract, cancel any time
Start free, add servers later
What a month costs once paid plans open
ServersPer month
3$0
10$35
25$110
100$485

$5 × (servers − 3). Prices in USD.

Free and open source

Free tools. Use them with or without us.

Small, readable and Apache-2.0. Each one answers one question, from your own terminal.

Live · Apache-2.0

Patch Proof: which CVEs are really open on this server?

A check that reads only upstream version numbers, or a service's version banner, flags fixes your distro already backported, and misses patched kernels nobody rebooted into. Patch Proof checks every installed package against your distro's own security data.

  • What's really open, and the version that fixes it
  • What's fixed by a backport, so you can close scanner findings with proof
  • What's patched on disk but not running until a reboot
pipx install git+https://github.com/HostCrust/patch-proof

Read-only · no root · nothing installed on the server · Ubuntu, Debian, AlmaLinux, Rocky Linux

A real result: one Ubuntu 24.04 server, 14 Nov 2026
Still on its release kernel (6.8.0-31)
9,261 open with a fix available · 9,257 of them in the kernel
After apt full-upgrade and a reboot (6.8.0-149)
4 open, all needing Ubuntu Pro

Afterwards, 10,034 CVEs show as fixed by backport. The kernel version still reads 6.8.0, so a scanner that only compares version strings would keep reporting them as open.

  • Live · Apache-2.0

    unattended-upgrades-check

    Is auto-patching actually working? 12 read-only checks over SSH for unattended-upgrades and dnf-automatic: last run, allowed origins, held packages, pending reboot, running vs installed kernel, Livepatch and OS end of life. PASS, WARN or FAIL, with the fix.

    pipx install git+https://github.com/HostCrust/unattended-upgrades-check
  • Live · Apache-2.0

    hc-verify

    Check a HostCrust receipt export offline. It recomputes every hash and reports the first broken link or missing record. Pure Python, no network, so you can verify a change without trusting our app.

  • Pre-release · Apache-2.0

    ssh-mcp-guard

    SSH for your AI coding agent (Claude Code, Codex, Cursor), with the rules on the server. An allowlist the AI can't talk its way around, because it lives on the server it protects, not in the AI's client.

Security and trust

Questions your security team will ask

Straight answers, including the gaps. No badges, logos or testimonials here.

Your servers

Today

What can the agent do on our servers?

A local allowlist on each server decides which kinds of action the agent will ever run. Shell is off by default. HostCrust can't change that file, and the agent refuses anything it doesn't allow, even when our app asks.

Today

Do we open ports or share SSH keys?

The agent only makes outbound HTTPS connections. It opens no ports, and you never share SSH keys with us.

Today

What if HostCrust itself is breached?

If HostCrust itself were breached, an attacker could at most queue the catalog actions your servers allow, with validated parameters. Running arbitrary commands needs shell, which stays off unless you turn it on locally.

Rolling out

Can an AI agent change production on its own?

Not today: there's no AI agent access to HostCrust yet. Access over MCP is rolling out during early access, and when it arrives, an AI agent can only propose a change. A person approves it.

Your data

Today

Can receipts be quietly changed?

Every action is written to a hash-chained, append-only log: who asked, the policy, who approved, what ran and how it was verified, as reported by the agent on the server. Our app's database role can't edit or delete it. Export it and check it offline with hc-verify, our open-source verifier.

Today

How are accounts and credentials protected?

Two-factor sign-in (TOTP) is required for every user. Passwords are hashed with argon2id, and every server gets its own random agent token, stored only as a hash and revocable.

Today

Can another customer see our data?

Every query on customer data is scoped to your organization, and automated tests try to reach another organization's data through every route.

Today

Where is our data stored?

Your HostCrust data is stored on our own server in Los Angeles, in the US. Every night, an encrypted backup of that data is copied to a separate server we operate in Canada.

What we don't have yet

Coming next

What about snapshots, rollback and backups?

Not in v1. Snapshots, rollback and backups are coming next. We won't claim them until they're built.

Key terms

Key terms, in plain language

What is Patch Proof?

Patch Proof is HostCrust's per-CVE patch check for Linux servers. It takes the server's own inventory (the OS release, the running kernel and the installed packages) and compares each package with the security data its distribution publishes, instead of comparing upstream version numbers. Every CVE lands in a class: a patch is available but not installed, a fix is on disk but not running until a reboot, the distro has no fix yet, or the CVE is already fixed, often by a backport. Only the first two need action. On one Ubuntu 24.04 server on November 14, 2026, Patch Proof reported 9,261 CVEs open with a fix available, 9,257 of them in the kernel. After apt full-upgrade and a reboot it reported 4, all needing Ubuntu Pro. Patch Proof is also a free, open-source command-line tool (Apache-2.0) and a browser check at hostcrust.com/proof.

What is a guarded action?

A guarded action is a change to a server that doesn't run until your rules allow it. In HostCrust, your organization's policy decides what happens to each request: by default, read-only diagnostics run straight away, and patches, service restarts and reboots wait for an approver. The approver signs off on the exact action (the server, the action and its parameters), and the approval is bound to a hash of them, so changing anything means asking again. Before it runs anything, the agent checks the server's own local allowlist, then runs the action as a fixed argument list, with no shell unless you turned shell on for that server. Afterwards the result is checked: Patch Proof re-checks the CVEs a patch targeted, a restarted service must report active, and a rebooted server must report a new boot ID. Those results are reported by the agent on the server, and the whole sequence lands in a receipt.

What is a hash-chained receipt?

A hash-chained receipt is a record of a change in which every entry includes a hash of the entry before it, so editing, removing or reordering an entry breaks the chain. HostCrust keeps one for everything it does. Every action is written to a hash-chained, append-only log: who asked, the policy, who approved, what ran and how it was verified, as reported by the agent on the server. Our app's database role can't edit or delete it. Export it and check it offline with hc-verify, our open-source verifier. The export is JSON or a printable record, and the check runs on your own machine. Edit an entry and the check fails; with a daily anchor it also catches a rebuilt or shortened log. A receipt answers what people ask after a change: who asked for it, who approved it, what exactly ran, and what the server reported afterwards.

What is the HostCrust agent, and what is the local allowlist?

The HostCrust agent is a single Python file that runs on each Linux server and is built so that you don't have to trust HostCrust. The agent only makes outbound HTTPS connections. It opens no ports, and you never share SSH keys with us. A local allowlist on each server decides which kinds of action the agent will ever run. Shell is off by default. HostCrust can't change that file, and the agent refuses anything it doesn't allow, even when our app asks. The file is /etc/hostcrust/agent.conf, and the installer writes it with four classes allowed: read, patch, service and reboot. Leave a class out and the agent refuses every action in it. If HostCrust itself were breached, an attacker could at most queue the catalog actions your servers allow, with validated parameters. Running arbitrary commands needs shell, which stays off unless you turn it on locally.

What is a backported fix?

A backported fix is a security patch that a Linux distribution applies to the version of a package it already ships, instead of moving to the new upstream release. The version number barely changes, so a check that reads only the upstream version number, or a service's version banner, reports the CVE as still open. Patch Proof compares against the distribution's own fixed build. In our test, Trivy, Grype and OSV-Scanner did the same for installed packages and did not report backported CVEs as open. Why scanners disagree on CVE counts.

What does "patched but not running" mean?

A kernel update is installed on disk but the server is still running the older, affected kernel until it reboots. Package managers report the update as done; the running system is still exposed. How to check your running kernel version.

FAQ

Common questions

What is HostCrust?

HostCrust is a hosted tool for teams that run Linux servers. It shows, per CVE, what's really patched on each server, by default makes patches, restarts and reboots wait for an approver, and keeps a hash-chained receipt of every change that you can check offline. It's free for up to 3 servers. More in the overview.

Is HostCrust a patch management tool?

Partly. HostCrust installs package upgrades and schedules reboots, each after approval by default, and shows per CVE what is fixed and running afterwards. It does one narrow job on Linux only: it doesn't patch Windows or macOS, and there's no self-hosted edition. For broader tools, see our comparison of Linux patch management software, where HostCrust is listed and marked as ours.

Why is a server still exposed after apt upgrade?

Most often because the fixed kernel is installed but the server hasn't rebooted into it. On one Ubuntu 24.04 server on November 14, 2026, 9,257 of the 9,261 CVEs Patch Proof reported open with a fix available were in the kernel it was still running; after apt full-upgrade and a reboot, 4 were left. See how to check your kernel version and apt upgrade vs full-upgrade.

How do I check a HostCrust receipt offline?

Export the receipts from the app as JSON, then run hc-verify, our open-source verifier, on your own machine. Edit an entry and the check fails.

Can AI agents like Claude Code use HostCrust?

Not today: there's no AI agent access to HostCrust yet. Access over MCP is rolling out during early access, and when it arrives, an AI agent can only propose a change. A person approves it.

Do we have to use AI agents?

No. Your team can do everything from the dashboard.

Which servers does it support?

Linux: Ubuntu 20.04 and newer, Debian 11 and newer, and AlmaLinux and Rocky Linux 8 and newer, on any cloud or your own hardware, as long as the server can make outbound HTTPS connections. The agent needs Python 3.6 or newer. Windows is coming next; it isn't supported yet.

What exactly can the agent run?

A fixed catalog: diagnostics (status, top processes, a service's journal and status), the Patch Proof inventory, package upgrades, service restarts and scheduled reboots. Commands run as argument lists, never as a shell string built from your input.

There is a shell action, but it's off unless you set allow_shell = true in /etc/hostcrust/agent.conf on that server. Our app can't turn it on for you.

During early access, the dashboard runs read-only diagnostics, plus patches, service restarts and reboots, which wait for an approver by default.

Why not Teleport or StrongDM?

Keep them if you use them. They control access: who, or which agent, gets into which server. HostCrust is about the change itself: an approval for the exact action, a per-CVE check after the patch from what the agent reports, and a receipt you can hand an auditor. Plenty of teams will want both.

We already use Ansible or unattended-upgrades.

Keep them. HostCrust doesn't replace your config management. It proves per CVE what's really patched, and records who changed what.

Not sure unattended-upgrades is doing its job? Run our free unattended-upgrades-check first, or read how to prove unattended-upgrades is working.

What does it cost?

Nothing during early access: everything is free. When paid plans open, the first 3 servers stay free and each server beyond them is $5 a month, with no contract.

Where is our data, and what do you collect?

On our own server in Los Angeles, in the US: your account and team, server status, Patch Proof inventories (package and OS data, no hostnames or user names), receipts and the output of actions you run. Every night, an encrypted backup of that data is copied to a separate server we operate in Canada. The privacy notice has the details.

Snapshots, backups, SSO?

Not yet. They're coming next, along with Slack approvals and Windows. We list them so you know where we're headed; we won't call them included until they're built.

What does this page track?

Without cookies, it counts visits, whether pricing was seen, and clicks on Start free, the free tools, the survey and the talk form. No name, email or IP address is attached to those counts, and they stay on our own server. If your browser sends Global Privacy Control, you aren't counted at all. See the privacy notice.

Connect your first 3 servers free

Install the agent, set the allowlist, and see what's really open on every server.

  • 3 servers free, every feature, not a trial
  • $5 per server per month after that
  • No contract, no minimum, no sales call
Start free

Questions first? Talk to a human