---
title: Plans and entitlements
description: How ClawMetry decides what this install can do — the seven tiers, the five capacity axes, feature and runtime tables, resolution order, grace mode and expiry.
keywords: clawmetry pricing, clawmetry plans, open core, clawmetry entitlement, clawmetry pro features, clawmetry free tier
eyebrow: Operations
---

# Plans and entitlements

ClawMetry is open core. The dashboard, the store, the CLI and the whole
observation path are free and always will be. What a paid plan adds is
**breadth** — more runtimes, more nodes, more channels, longer retention — and
the governance and analysis features built on top.

This page is the reference for what is in which tier and how the answer is
computed. To ask the question about *your* install, use the
[entitlement commands](/docs/cli/entitlement-commands/).

## The tiers

| Tier id | Label | Source |
|---|---|---|
| `oss` | OSS | No license, no cloud account. The default. |
| `cloud_free` | Free | A cloud account with no paid plan. |
| `trial` | Trial | A time-boxed grant with paid-tier reach. |
| `cloud_starter` | Starter | Paid, hosted. |
| `cloud_pro` | Pro | Paid, hosted. |
| `pro` | Self-hosted Pro | Paid, your own ingest. |
| `enterprise` | Enterprise | Paid, with the compliance surface. |

They are ranked in exactly that order. `tier_rank()` is what every "is this
enough?" and "what is the next tier?" question resolves against; **Trial ranks
between Free and Starter**, which is why a trial reaches paid runtimes but not
every Pro feature.

## The five axes

An entitlement is not one number. Five independent axes are checked
separately, and a plan can be sufficient on four and short on the fifth.

| Axis | Question |
|---|---|
| Features | Is this feature in the tier's set? |
| Runtimes | Is this runtime id in the tier's set? |
| Channels | How many chat channels may run concurrently? |
| Nodes | How many machines may register? |
| Retention | How far back may the store keep data? |

### Capacity

| Tier | Nodes | Channels | Retention |
|---|---|---|---|
| OSS | 1 | 3 | 7 days |
| Free | 1 | 3 | 7 days |
| Trial | unlimited | unlimited | 30 days |
| Starter | unlimited | unlimited | 30 days |
| Pro (cloud) | unlimited | unlimited | 90 days |
| Self-hosted Pro | unlimited | unlimited | 90 days |
| Enterprise | unlimited | unlimited | unlimited |

Channels and nodes are **capacity-scoped**, not catalogue-scoped: every one of
the chat adapters is free code, and what a tier bounds is how many you run at
once. That is why `clawmetry channels --why` takes a *count* rather than an
adapter name.

`CLAWMETRY_RETENTION_DAYS` can shorten the window but never lengthen it past
the tier cap. `clawmetry retention --json` shows both the cap and the effective
value.

### Runtimes

{{FREE_RUNTIME_COUNT}} of the {{RUNTIME_COUNT}} supported runtimes are free at
every tier:

| Runtime | Why free |
|---|---|
| OpenClaw | The reference runtime ClawMetry grew up around. |
| Goose | Free adapter. |
| NemoClaw | Free adapter. |

The other {{PAID_RUNTIME_COUNT}} — Claude Code, Codex, Cursor, Copilot, Gemini
CLI, Aider, Cline, OpenHands, Devin and the rest — unlock at **Trial and
above**. There is no partial runtime ladder: every paid tier gets the whole
set. See [Runtime support](/docs/runtimes/overview/) for what each one exposes.

### Features

Free at every tier, including OSS with no account:

| Feature | |
|---|---|
| Overview | Sessions |
| Transcripts | Usage |
| Brain | Flow |
| Tracing | Health |
| Logs | Crons |
| Channels | NeMo Governance |

Added at **Starter**:

| Feature | What it is |
|---|---|
| Cloud sync | Encrypted snapshots to the hosted dashboard. |
| Multi-runtime | More than one runtime ingesting on a node. |
| Multi-node fleet | The fleet view across machines. |
| All channels | The concurrent-channel cap lifts. |
| Approval queue | The human-in-the-loop queue behind pre-tool gates. |
| Budget limits | Enforced spend ceilings. |
| Per-runtime health timeline | Health broken out per runtime rather than aggregate. |

Added at **Pro**:

| Feature | What it is |
|---|---|
| Anomaly detection | Statistical outliers in token and cost series. |
| Cost optimizer | Model-routing and waste recommendations. |
| Per-run waste flags | Which specific run burned money for nothing. |
| Per-run compare | Two runs side by side. |
| Error triage | Grouped failures with likely cause. |
| Eval suite | Scored evaluation runs. |
| Self-Evolve | Agent-driven improvement loops. |
| Asset registry | Tracked models, prompts and skills. |
| Tool policy | Per-tool permission rules. |
| Custom alerts | Alert rules beyond the built-ins. |
| Alert webhooks | Alerts delivered to your endpoint. |
| Custom webhooks | Arbitrary event webhooks. |
| Custom runtime ingest | Push a runtime we do not ship an adapter for. |
| OTel export | Ship ClawMetry's data out over OpenTelemetry. |

Added at **Enterprise**:

| Feature | What it is |
|---|---|
| SSO | Single sign-on. |
| RBAC | Role-based access control. |
| Audit logs | Who did what in ClawMetry itself. |
| SIEM export | Feed a security information and event management system. |
| EU AI Act Evidence Pack | The compliance artefact. |
| Custom data residency | Where the data physically lives. |
| Air-gapped license | Activation with no outbound network. |

:::note Feature ids are stable
The strings in these tables — `anomaly_detection`, `per_run_compare`,
`siem_export` — are the ids the API and CLI use. `clawmetry features --why
anomaly_detection` and
`GET /api/entitlement/lock-reason?feature=anomaly_detection` take exactly these.
:::

## How the tier is resolved

Three sources, checked in order. The **first one that answers wins**:

1. **A local license file** — `~/.clawmetry/license.key`. This is what
   self-hosted Pro, Enterprise and air-gapped installs use.
2. **The cloud plan cache** — `~/.clawmetry/cloud_plan.json`, written by the
   daemon from the heartbeat. This is how a hosted plan reaches the dashboard
   process, which does its own entitlement resolution and never talks to the
   billing system directly.
3. **OSS free** — the fallback, and also what any failure resolves to. A broken
   license file or an unreachable cloud never escalates privileges and never
   crashes the app; it degrades to free.

The result is cached for **60 seconds**. That is why a plan change can take up
to a minute to show in the UI, and why `clawmetry diagnose` prints the cache
age.

```bash
clawmetry diagnose        # which source answered, cache age, enforcement state
```

The diagnostic reports the license path and whether a file is there, the cloud
plan path and size, the enforcement env var, the cache age and TTL, whether the
next call will hit the cache, and the retention override — enough to tell "no
license" apart from "license present but not being read".

## Grace mode

**Grace is on by default.** While `grace` is true, every check answers
*allowed* regardless of the resolved tier: `allows_feature`, `allows_runtime`
and `allows_node_count` all short-circuit to true.

```bash
clawmetry tier --json | jq '{tier, grace, enforced}'
```

This is deliberate — the paywall is announced before it bites, and a node that
is quietly ingesting a paid runtime today under grace should not stop dead on
an upgrade. It is also the answer to "why is this runtime marked locked in the
UI but still showing sessions?"

| Variable | Effect |
|---|---|
| `CLAWMETRY_ENFORCE` | `1`/`true`/`yes`/`on` turns enforcement on for this node. |
| `CLAWMETRY_ENFORCE_AT` | The announced enforce-at moment — ISO date, ISO datetime, or epoch seconds. Used to preview what a future date will lock. |

`CLAWMETRY_ENFORCE_AT` is what the `*_at` variants of every entitlement query
resolve against, so you can ask "what will be locked when enforcement starts?"
before it does.

## Expiry

A trial or a term license carries an `expiry`. After it passes:

- Paid **features** stop being allowed. Free features are unaffected.
- Paid **runtimes** stop being allowed. The free runtimes keep ingesting.
- The **node limit** collapses to 1.

Nothing is deleted and the daemon keeps running. An expired install is a free
install, not a broken one. A user who lets a trial lapse can also opt into
**free-only mode**, which the dashboard surfaces as an explicit banner rather
than a silently narrower product.

## Where the answer is enforced

The entitlement is one verdict read from many places, never re-derived:

| Surface | How |
|---|---|
| Dashboard | `GET /api/entitlement` — the tier, the sets, `grace`, and the lock reasons the UI renders next to disabled controls. |
| CLI | `clawmetry tier` / `runtimes` / `features` / `channels` / `nodes` / `retention` / `bundle`. |
| Daemon ingest | A paid runtime's adapter is only loaded when the entitlement allows it. |
| Guard enforcement | One of the [three locks](/docs/guard/policies/) on autonomous action, and it **fails closed** — an unresolvable entitlement means no signal is sent. |

That last row is the one asymmetry worth knowing: everywhere else a failure
degrades to free and keeps working, but a control path that could signal a real
process refuses rather than guesses.

## Choosing a tier

```bash
clawmetry bundle \
  --runtimes claude_code,cursor,codex \
  --features anomaly_detection,cost_optimizer \
  --channels 6 --retention-days 90 --nodes 4
```

This answers the actual purchasing question — the cheapest tier that covers
everything you named, across all five axes at once — instead of making you read
five tables and take the maximum yourself.

→ [Entitlement commands](/docs/cli/entitlement-commands/) · [Upgrades](/docs/ops/upgrades/) · [Runtime support](/docs/runtimes/overview/)