Licensing & editions

How Algenta licensing works for self-hosted and air-gapped use — what a license grants, how to install and verify it offline, the editions, and the open-core terms.

This page explains how Algenta licensing works for self-hosted and air-gapped deployments: what a license grants, how you install and verify it locally with no network calls, how product editions map to features, and the open-core terms.

Community Use needs no license. A self-hosted download runs under the open-core Community License without any license file. You only install a license for commercial use or to unlock a paid edition.

The license model

An Algenta license is a signed JSON Web Token. It is installed at:

~/.algenta/runtime/license.jwt

The runtime verifies it locally on every startup with no network call. Licenses are RS256 (asymmetric): Algenta signs your license with a private key, and each of your runtime machines verifies it with the matching public key you are given. A public key can verify a token; it cannot create one.

A license carries: plan, device limit, permitted modules, expiry, product entitlements, capacity caps, deployment class, and the commercial-use grant.

The license is a device entitlement, not your data plane. It carries signed claims only — it never reads customer data, schema data, or runtime payloads. Verification is fully offline; nothing about your repositories or simulations leaves the machine.

Capacity caps (per device)

The headline runtime cap is concurrent workers per device — how many jobs one machine runs in parallel — by tier:

Tier	Workers per device
Community (free)	1
Pro	5
Team	20
Enterprise	Unlimited (negotiated)

The runtime worker broker enforces this locally (offline, no network call). Seats and nodes are pooled caps the control plane reconciles.

Air-gapped / never-phone-home operation is an Enterprise entitlement. Self-serve tiers renew online. Enterprise air-gapped licenses verify fully offline and do not require a network path.

Durable across redeploys

The runtime reads the token from the file first. If no file is present, it falls back, in order, to these environment sources — so a hosted or air-gapped engine keeps a valid license across redeploys without a persistent volume (the JWT lives in a platform secret):

Source	Type
~/.algenta/runtime/license.jwt	file (highest precedence)
ALGENTA_LICENSE_JWT / ALGENTA_LOCAL_LICENSE	inline JWT in an env var
ALGENTA_LICENSE_JWT_FILE / ALGENTA_LOCAL_LICENSE_FILE	path to a JWT file

Verification is identical regardless of source: RS256, fully offline.

Install a license

Algenta issues you a signed license file (license.jwt) and the matching public key for verification. Install both on each runtime machine:

mkdir -p ~/.algenta/runtime
cp license.jwt ~/.algenta/runtime/license.jwt

# Inline key, or use the *_FILE form for a path on disk.
export ALGENTA_LOCAL_LICENSE_PUBLIC_KEY="$(cat algenta-license.pub)"
# or:
export ALGENTA_LOCAL_LICENSE_PUBLIC_KEY_FILE=/etc/algenta/algenta-license.pub

The runtime also accepts ALGENTA_LICENSE_PUBLIC_KEY / ALGENTA_LICENSE_PUBLIC_KEY_FILE as aliases. Multiple keys are supported (deduplicated) so you can rotate keys without downtime.

For an air-gapped machine, copy the same two files in by hand — no network is required at any step. See Run air-gapped.

Verify it locally

scripts/license_status.py loads the installed token through the exact path the runtime uses, so it verifies precisely what the engine would see. No secrets, no network, no mutation.

A satisfied gate prints OK and exits 0. The check is available as human-readable text or machine-readable JSON:

Text

python3 scripts/license_status.py

OK  license valid=True version=2 source=offline-local plan=enterprise
      deployment_class=server commercial_use=True
      product algenta: tier=selfhost features=apply,fix,local_runtime,repo_graph,simulate,triage
      caps: seats=25 nodes=3 workers=12
      expiry: expires_at=... key_expires_at=... expired=False in_grace=False hard_expired=False

JSON

python3 scripts/license_status.py --json

{
  "valid": true,
  "source": "offline-local",
  "plan": "enterprise",
  "deployment_class": "server",
  "gate_satisfied": true,
  "products": { "algenta": { "tier": "selfhost", "features": ["apply", "fix", "local_runtime", "repo_graph", "simulate", "triage"] } }
}

Exit codes: 0 = the license is valid, 1 = not valid (missing, wrong key, or expired past grace).

Expected result: OK and exit 0. If it fails, the output names the cause — no installed license, the wrong public key, or expired past grace. The bottom hint line is the next action; if your license has expired, request a renewed one.

When a license lapses

Your engine runs on your hardware — nothing reaches in to switch it off. When a paid license expires and is not renewed, the engine downgrades to Community (free-forever) rather than stopping: it keeps running at Community limits (1 device, 1 worker, 1 seat, non-commercial), and paid capacity, updates, and support resume when the license renews.

• Connected deployments re-check the subscription on renewal, with a grace window for brief disconnects. A cancelled or downgraded plan settles at Community after renewal fails.

• Enterprise air-gapped deployments verify the installed signature locally. When its signed term lapses, the previously valid deployment also settles at Community; install a renewed license to restore Enterprise capacity.

Editions and features

Algenta licenses grant product-scoped features, and the local engine maps each granted feature to the concrete tools it unlocks:

available_tools = installed ∩ product_allowlist ∩ license_feature_tools

Edition	Product key	Status	Feature buckets
Algenta	algenta	Shipped	local_runtime, repo_graph, triage, simulate, fix, apply

The repository-intelligence feature buckets map to tools as follows:

Feature	Tools unlocked
base (always)	get_me, get_limits, get_usage, get_repository_intelligence_capabilities
repo_graph	query_repository_graph, create_repository_snapshot, get_repository_snapshot
triage	triage_repository, create_repository_decision_plan
simulate	simulate_repository, simulate_repository_patch, simulate, plan_decision, recommend, log_decision, list_decisions, get_decision, record_outcome
fix	run_repository_fix, run_repository_pipeline, create_agent_run, get_agent_run, get_agent_run_events, cancel_agent_run
apply	apply_repository

A license granting the full Algenta feature set yields the complete licensed edition. A narrower grant exposes only the corresponding tools.

The product selector (X-Algenta-Product / ALGENTA_PRODUCT) is a routing hint, not authorization. Visibility is the intersection of the product allowlist, the verified key's entitlements, organization policy, and the license's feature grants. An unknown or unentitled product resolves to the empty set — never the full registry.

Open-core terms (ACL 1.0)

Self-hosting is governed by the Algenta Community License (ACL) 1.0, in LICENSE at the repo root. In plain terms:

• Community Use is free — non-commercial use, personal projects, research, education, open-source work, and internal business operations at organizations with fewer than 50 employees AND under $5,000,000 USD annual gross revenue.

• Commercial Self-Hosting — deploying Algenta inside a product or service offered to external customers, or use by organizations above those thresholds — requires a paid commercial license.

• The framework, integrations, portal, and SDKs are source-available; the bundled compiled runtime ships under a separate binary license and may be redistributed for Community Use only.

The signed license described on this page is the per-machine, offline mechanism that backs the commercial terms.

Related pages

Self-hostingUsage & limitsAuthentication & API keysTroubleshooting