Enterprise · self-hosted · public beta

ShakerScan Enterprise, self-hosted.

The open-source scanner your security team already trusts, behind your identity provider, on your own servers.

Single sign-on through your OpenID Connect provider, passkeys and recovery codes, enforced roles, audit and an offline licence in front of the public engine. No data leaves your network. Public beta, pilots open.

Pilots run on a time-boxed evaluation licence with the maintainers on the call; there is no self-service purchase.

Platforms and sign-in

What it runs on, and who can sign in.

Platforms

One Linux host with Docker Engine and Compose 2.20+, x86_64 (linux/amd64 images).

  • Ubuntu 24.04 LTS

    Recommended. Validated with the one-command installer, including reboot and backup.

    Supported
  • Ubuntu 26.04

    Validated in continuous operation.

    Supported
  • AWS ECS (Fargate)

    Reference deployment available for evaluation.

    In development
  • Amazon EKS / Kubernetes

    Reference manifests available for evaluation.

    In development

Identity providers and sign-in

Roles come from provider groups or per-person admission.

  • Okta

    Group-to-role mapping and console test sign-in, with a setup guide.

    Supported
  • Keycloak

    Including deployments behind a private certificate authority.

    Supported
  • Microsoft Entra ID

    Standard OpenID Connect flow with group claims.

    Supported
  • Other OpenID Connect providers

    S256 PKCE, RS256 or ES256 ID tokens, client_secret_basic or _post.

    Supported
  • Google Workspace

    Sign-in with per-person admission; group-to-role mapping in development.

    In development
  • Local accounts

    Password, passkeys, authenticator app, recovery codes, invitations.

    Supported
  • SCIM provisioning

    Access is revoked by disabling the person in the console.

    Not available

For anything in development, ask about timing in the pilot conversation.

Identity and access

Your identity provider decides who gets in. Roles decide what they can do.

The gateway sits in front of the engine and authenticates and authorizes every request, so nobody reaches a scanner, a finding or a credential without signing in through your policy.

Single sign-on with your identity provider

OpenID Connect with PKCE, supported with Okta, Keycloak, Microsoft Entra ID and other providers with S256 PKCE and RS256 or ES256 ID tokens. Configure it in the console and run a test sign-in at the provider before saving; changes apply without a restart and are audited. Two-step verification for these accounts is your provider’s policy.

Passkeys, two-step verification, recovery codes

Local accounts sign in with a passkey (fingerprint, face or PIN; phishing-resistant and a second factor on its own) or a password plus authenticator-app codes. Ten single-use recovery codes replace a lost passkey or phone. The policy is yours: off, required for local administrators, or required for every local account.

Groups to roles

People are admitted by exact subject or by mapping your identity-provider groups to a role on first sign-in. Nobody gets in by default.

Three enforced roles

Viewer reads results; operator runs scans, retests and Hunt; administrator manages people, tokens, settings and updates. Every request is checked against reviewed per-role allowlists, and unknown routes are refused.

Sessions you control

Server-side sessions with short absolute and idle lifetimes set in the console. Changing a role, password or factor ends that person’s sessions, and an administrator can sign anyone out everywhere.

Service tokens for automation

Scoped viewer or operator tokens for CI and agents, shown once, stored hashed, valid for at most 90 days and revocable. They cannot open the console.

People lifecycle

One-time invitation links (valid three days) where people choose their own password; disable and re-enable; one-time reset codes issued by an administrator; a break-glass local administrator next to single sign-on, and server-side recovery commands for the operator.

Audit trail

Sign-ins, administration, settings changes and every engine request (method and path, never bodies or secrets), with who and when. Filter in the console, export as NDJSON.

Measured, not promised

Numbers from recorded runs on real hosts.

September 2026, Ubuntu 24.04. Every figure comes from a recorded run, not an estimate.

~4 min

one command, clean Ubuntu 24.04 host

From published, signed artifacts to a running stack with the first administrator, a daily backup and the engine updater installed. Re-running it resumes an interrupted install.

7 checks

one verification command

Gateway signature, SBOM attestation and the build attestations of all five engine images, before anything is deployed. The installer runs it for you.

140 s

engine update from the console

From the administrator’s click to the new engine verified (2.3.6 to 2.3.9): backup, install, render, pull, restart, verify, with scans, evidence, identities and the licence intact.

How it runs

Two things on one Linux server of yours.

You install two things on one Linux server: the open-source ShakerScan engine (public images, pinned by digest) and the Enterprise gateway (a private, signed image). The gateway handles login through your OpenID Connect provider, viewer, operator and administrator roles, an audit trail, and a signed licence that never phones home. Scans run on your host against your applications; findings and evidence stay there.

Outward, the host talks to your targets and your identity provider, and, at install and update time, to the image registries, GitHub and Sigstore; Let’s Encrypt too, unless you bring a certificate.

What you get

Deployment and operations, labeled by maturity.

Public beta means published, signed, exercised on real hosts, and offered to pilots. Preview means it works and is included, with gaps stated.

Public beta

One command on one Linux host

The installer checks the host, verifies the signed images, installs the public engine pinned by digest with the private gateway in front of it, and starts everything with Docker Compose. The gateway passes each request through reviewed per-role allowlists; unknown routes are refused.

Public beta

Offline licence with concurrent-scan slots

A signed, installation-bound licence file checked offline. It sets how many scans run at once; the gateway reserves a slot per scan and refuses beyond it. Expiry stops new scans only. Renewal works from a usage summary you export yourself.

Public beta

Agents and the command line

A one-time connect link from the console, then pipx install shakerscan (or brew install andriyze/shakerscan/shakerscan) and shakerscan agent claude, codex or opencode: your coding agent works against your instance over MCP, under your identity and in the audit log.

Public beta

Engine updates from the console

An administrator picks a newer published engine release this gateway has reviewed; the host updater backs up, installs, restarts and verifies, and, if a step fails, puts the previous engine back, restoring its database from the pre-update backup when needed. Gateway upgrades are by new digest, with the previous rendering kept.

Public beta

Backup, restore, day-two operations

An encrypted daily backup of the engine database, evidence, identities and deployment files; restore onto the same or another host. Start at boot, log rotation, your own certificate or Let’s Encrypt, a corporate proxy for the certificate authority and the identity provider.

Preview

Hunt, the AI-assisted investigation workspace

On for operators by default. Operators drive it in the browser, through their agent over MCP or from the CLI; viewers read. Your own model credentials are needed only for the engine’s autonomous features, and the autonomous Hunt does not work yet in this beta.

What the beta does not include

Said plainly, so you can plan.

  • One organization per installation, with no project or team isolation: evidence is visible within a role, not per project.
  • No high availability: a single gateway process on one host. No SCIM, so people removed at the provider are also disabled in the console, and no provider-initiated sign-out.
  • Ubuntu 24.04 and 26.04 on x86_64 only; other distributions and ARM hosts are not supported yet.
  • No scheduling, continuous monitoring or attack-surface management. Connected devices, fleet administration, AI Gate and Model Intake are not exposed through the gateway.
  • No air-gapped installation: installing and updating need Docker Hub, ghcr.io and GitHub.
  • Kubernetes (EKS) and ECS Fargate are in development, with reference layouts for evaluation. Production deployments run on one Linux host with Docker.
  • No Jira, Slack, webhook or SIEM integrations; the audit log is exported as a file. The autonomous Hunt does not work yet.
  • No SLA, no certifications and no third-party penetration test of the gateway yet. Pilots run on a time-boxed evaluation licence.
Requirements

What the host needs.

  • Ubuntu 24.04 LTS (recommended; validated with the one-command installer, including reboot and backup) or Ubuntu 26.04 (validated in continuous operation). x86_64 only: the images are linux/amd64.
  • Docker Engine 24+ with the Compose plugin 2.20+, and cosign and the GitHub CLI (gh) for the signature and attestation checks. You keep root.
  • 4 vCPU and 16 GB of memory at minimum; 8 vCPU and 32 GB for several concurrent scans. 40 GB of disk, 100 GB or more recommended.
  • A DNS name for the host, inbound 443 (and 80 for Let’s Encrypt), or bring your own certificate.
  • Outbound: Docker Hub and ghcr.io for images, GitHub and Sigstore for the release catalog and signature checks, your identity provider, Let’s Encrypt unless you bring a certificate, and your targets. A proxy is supported for the certificate authority and the identity provider.
  • Private-network targets are refused by default and allowed by a per-deployment opt-in, recorded on every scan.
Install on a Linux host
Security and data

Built for a security team’s review.

  • No telemetry, no licence check-in, no vendor access. The gateway’s only request of its own is a read-only fetch of the public engine release catalog from GitHub when an administrator checks for engine updates.
  • Every mutation requires the browser origin and a CSRF token; identity headers never cross into the engine; evidence is served under a sandbox policy.
  • Workers cannot reach the API, the Docker socket is not mounted, only the TLS front publishes ports, every container has resource limits.
  • Gateway releases are built from a tagged commit, start-tested, blocked on fixed high and critical vulnerabilities, signed with Sigstore keyless signing and shipped with an SPDX SBOM attestation.
Pilot in 30 days

Thirty days on your host, with the maintainers.

Week 1

Questionnaire, licence and pull access; install on your host with us on a call.

Weeks 2–3

Your operators scan your applications; we review findings and fix what blocks you.

Week 4

Backup, upgrade and restore drill on your side; decision. The pilot fee is credited to the annual subscription.

The email opens with the questions a pilot starts from: your company and role, your identity provider, where the host would run, how many applications you scan and whether any are internal-only, and the concurrent scans you expect. We reply within one business day with the full questionnaire and a proposed pilot plan.

Questions
Is the engine open source?
Yes, AGPL-3.0, public images on Docker Hub and source on GitHub; Enterprise runs those images unchanged. The Enterprise gateway is proprietary and delivered as a signed private image; the operator scripts and guides ship inside it, and its source is available to paying customers on request.
Does it call home?
No. The licence is a signed file checked offline, and nothing about your installation is reported. Usage for renewal is a checksummed summary you export and send yourself. The only outbound requests are the image pulls, the public release catalog and installer on GitHub when you install or update, your identity provider and your targets.
Which identity providers and hosts are supported?
Single sign-on is supported with Okta, Keycloak, Microsoft Entra ID and other OpenID Connect providers; the console’s test sign-in confirms your provider’s configuration before you save. Hosts: Ubuntu 24.04 LTS and Ubuntu 26.04 on x86_64. If you need another distribution, say so in the pilot conversation.
Can we scan internal applications?
Yes. Private-network targets are enabled per deployment by the operator, and the admission is recorded on every scan.
Can we connect Claude Code or Codex?
Yes. An administrator creates a one-time connect link in the console; on the laptop, the shakerscan client connects to your instance and shakerscan agent claude, codex or opencode starts the agent with the instance over MCP. Every action runs under that person’s token and appears in the audit log.
What about air-gapped hosts?
Not in this beta. Installing and updating fetch images from Docker Hub and ghcr.io and the release catalog from GitHub. If you need an offline install, say so in the pilot conversation.
How are upgrades done?
Engine updates are requested from the console and applied by a host updater that rolls back automatically on failure; only published releases this gateway has reviewed can be requested. Gateway upgrades are in place from a new digest, with the previous rendering kept for rollback.
Is there a hosted option?
Hosted pilots are available on request.
Open source stays the core

Enterprise is additive.

Enterprise runs the public engine images unchanged. Identity, administration, licensing and support sit in front of them; nothing is removed from the open-source release. In this beta the gateway exposes a reviewed part of the engine, listed above.

See what the open-source release includes