ClawMetry reads your agent session files, and bills four runtimes free

Four runtimes are free, and twenty-eight are read by a closed-source companion

The headline claim is that one dashboard covers every runtime you run. The entitlement table underneath it is the honest version of the same claim.

Free in the open source app: OpenClaw, NVIDIA NemoClaw, Goose and Qwen Code. These four are read with no account, no key and no network call. The other twenty-eight, Claude Code, Codex, Cursor and the rest, are read by a closed-source companion called clawmetry-pro, which arrives with a seven-day trial or a plan. The exact split is documented separately in docs/ENTITLEMENTS.md rather than in the README itself.

So the marketing line and the install line describe different products. Read the entitlements document before you plan a fleet migration around it.

Reading session files is the whole architecture, and that is the constraint

ClawMetry does not ask you to change your agents. It reads the session files and logs your agents already write, so there is no SDK, no code change and no instrumentation in your application, and it changes nothing about how the runtimes execute. Installation is one line:

pip install clawmetry && clawmetry

It finds the runtimes already installed on the machine and opens at http://localhost:8900.

The design has a single virtue and a single limit. The virtue is that it works on agents you did not write and cannot modify. The limit is that it can only see what those agents choose to write down, and the documentation says so before you judge the output.

The consequence shows up in cost data, where some runtimes publish none at all, and in context utilisation, where the numbers are derived rather than measured. A tool that reads logs can be complete or empty depending on the runtime underneath it.

Two things leave the machine by default, and neither carries session content

No session data leaves your machine unless you explicitly run clawmetry connect. Two requests do go out by default, both described as opt-out and both carrying no session content: an anonymous install ping and a PyPI version check.

The unusual part is the method of verification. Every outbound destination is inventoried in docs/EGRESS.md, and that inventory is said to be rebuilt from a wire capture rather than from reading the source and noting the comments. For a tool whose pitch is that it only reads local files, having the network behaviour measured rather than asserted is the detail that makes the claim checkable.

It also means the inventory can go stale the moment a dependency adds its own telemetry, which is an argument for treating that file as something to re-read rather than something you read once.

Context windows are sized per vendor, and that choice changes the verdict

Context blowout gets its own section because a utilisation percentage is only as honest as its denominator. ClawMetry sizes the window per provider from a table you can read and propose changes to, in clawmetry/context_windows.py, covering Anthropic, OpenAI, Google, xAI, DeepSeek, Kimi, Qwen, Mistral, Llama and GLM.

The examples given are the argument for doing it this way. A 300K turn on GPT-5, scored against Anthropic's 200K window, reads as over one hundred percent and blown when it is really at 75% of GPT-5's 400K. The same single ruler in the other direction hides a genuinely overflowed 130K DeepSeek turn as a comfortable 65%.

Each window also carries its provenance as one of a small set of markers, model_table, explicit_marker or observed_floor, which is what lets a reader tell a declared number from one inferred from behaviour.

DuckDB and zstandard are the two dependencies that explain the design

The runtime dependency list is short and each entry carries a comment explaining why it exists. Flask is the web layer. DuckDB is the local event store. zstandard decodes OpenClaw 2026.9.x zstd transcript events and is declared only below Python 3.14, since the standard library takes over from there.

The DuckDB choice is the load-bearing one. A local analytical store is what makes it possible to query a whole fleet's history without a server, and it is why the claims about incremental aggregation and batch backfill are credible rather than aspirational.

The truststore entry covers Python 3.10 and above and is for corporate TLS interception CAs, with certifi as the fallback for older interpreters and any interpreter with no CA store of its own. The certifi floor is chosen deliberately, at the release that dropped the distrusted GLOBALTRUST root tracked as CVE-2024-39689.

The version number and the runtime count are both parsed at build time

setup.py does not declare its own metadata values, it reads them. The version comes from a regular expression over __version__ in dashboard.py, commented as the single source of truth. The runtime count in the PyPI summary is derived by parsing the FREE_RUNTIMES and PAID_RUNTIMES frozensets out of clawmetry/entitlements.py, and it does so by reading the source rather than importing the package, because setup.py runs before the package is installed. An assertion then fails the build if the count does not parse to more than one.

The comment on that block explains the motive, and it is a good one. The summary is derived so it cannot go stale when a runtime lands, because it previously said 12 while the catalogue said 20, until 2026-08-15.

The same file also keeps dashboard.py as a top-level module so python -m dashboard and existing import paths keep working, and excludes the repository's own test suite from the distribution.

The container pins its base image by digest and a test guards the pin

The Dockerfile is built FROM python:3.14-slim with a digest appended. The comment explains the reasoning in full: a tag is mutable, so an identical docker build could pull different bytes tomorrow, and the tag is kept in the reference only so the line stays readable. Dependabot advances the digest, because without that a digest pin would freeze the image at whatever vulnerabilities existed today.

Dependencies are installed from a hash-pinned file at .github/requirements/docker-runtime.txt with pip install --require-hashes, separate from requirements.txt, which is the manifest of record. A test named tests/test_docker_runtime_pin.py fails if the two drift apart.

That is more care than most projects put into a container, and it is the right care for a tool whose value is that it runs locally and reads your files.

Five install scripts, four PRD documents, and one landing deployment

The tree is a working repository rather than a tidy one. At the top level there are install-clawmetry.sh, install-clawmetry.ps1, install.sh, install.ps1 and install.cmd, so every platform has its own path, alongside four documents named PRD.md, PRD-tracing.md, PRD-pr-trace.md and PRD-sync-status.md, plus AUDIT.md, UX_AUDIT.md, BUILD_STATUS.md, UPCOMING.md, TASK.md and TASK_P0.md.

There is also a package.json named openclaw-dashboard-repo at version 0.0.1, private, whose only two scripts both run the same file, bash scripts/deploy-landing.sh. That is the landing site deployment, not the product, and it is the only JavaScript in a Python project.

Underneath sit clawmetry/, routes/, helpers/, frontend/, desktop/, integrations/, docs/, benchmarks/ and blog/, and the examples directory holds bring-your-own-agent, custom-ui and otel.

Editorial conclusion

Adopt the free tier of ClawMetry if you run OpenClaw, NVIDIA NemoClaw, Goose or Qwen Code, because those four are covered by the pip install with no account and no key, and the read-only, no-SDK design costs you nothing to evaluate. Skip it if your fleet is Claude Code, Codex or Cursor, since those are read by the closed-source clawmetry-pro companion rather than the open source app, and do not confuse the two when you evaluate what the dashboard can show. Before you rely on it, read docs/compatibility.md for which runtimes expose cost at all, and docs/APPROVALS.md for which approval controls are real rather than observational, because watching a tool call and being able to block it are different claims. Also confirm what your runtimes can actually expose, since the context window numbers are sized per vendor rather than measured with one ruler.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. vivekchand/clawmetry on GitHub