WattOps shows, live, what every GPU, job and team draws and costs, finds the GPUs that are on but idle and what they cost you, and writes the energy and carbon reports your finance, sustainability and grant offices ask for. Measured from the hardware, not guessed.
Every GPU that is switched on or held by a job but doing nothing, live: how many, for how long, and the power and money it burns at your own price per kWh.
“6 GPUs idle now · 1,020 idle GPU-hours this month” How Live works →Energy, cost and CO₂ for each Slurm job, Kubernetes pod and user, so shared clusters can show back or charge back what each group used.
“chem-lab: 1,240 GPU-hours · 496 kWh” See an example →PDF energy and carbon reports per project, with the method, the inputs and a report ID anyone can reproduce: for CSRD, Scope 2, the EU AI Act and grant offices.
“Q3 energy report · ID 7F2A-…” What is in a report →Run joules agent on each GPU server or Slurm node, and the Live page shows what the fleet draws right now, what it costs by the hour, and which GPUs burn power doing nothing. A stock ticker, for electricity.
Each machine reports every 5 seconds. Heartbeats never count against your API calls.
On a shared cluster, everyone pays for the power and nobody knows who used it. joules agent runs on each node and splits each GPU’s and CPU’s measured energy between the jobs on it: Slurm jobs, Kubernetes pods, containers or users.
Group it by account, project or user, see it on the Tracking page, export it, and send each group its share every month. No Prometheus or Grafana stack to run.
Universities and public research: 50% off.
Illustrative numbers, measured the way joules agent does on each node · electricity at $0.12 per kWh · 127 g CO₂ per kWh
Charge each lab its measured share of the cluster’s power, find the idle GPUs, and hand the sustainability office and grant applications a report, without running your own Prometheus and Grafana stack.
50% off for universities and public researchSee the whole fleet live, find the GPUs that are on but idle and what they cost, and give each project its measured energy, cost and carbon.
Start with a 4–6 week pilot on your own clusterKnow what each training run and each model really costs to run, get an alert when a change makes it use more, and report the energy to your customers and your sustainability team.
Free to start, Pro at $19 a monthFinance, sustainability and grant offices, and more and more regulators, ask how much energy your computing used. Pro and Max turn the measurements into a PDF per project or per month, with the method written out. For example, providers of general-purpose AI models must keep technical documentation that includes the model’s known or estimated energy consumption (AI Act, Article 53 and Annex XI). Where the energy is not known, Annex XI allows it to be estimated from the computational resources used. That is exactly what WattOps computes, with the method written out.
Pro reports are PDFs with the inputs, the derivation, the assumptions and a report ID. Anyone can check the ID by running the same inputs again. The same figures support Scope 2 carbon reporting (CSRD, GHG Protocol) and customer sustainability questionnaires.
WattOps is a calculation tool, not legal advice. Check your obligations with your own counsel.
Install joules and start joules agent on each GPU server or Slurm node, by hand, with your config tool, or as a Kubernetes DaemonSet. It reads the power meters about once a second, next to your jobs, not inside them.
sudo joules agent --track fleet
Within seconds the Live page shows every machine’s power and cost, the idle GPUs, and the jobs running now. Finished jobs land on Tracking with their energy, cost and CO₂.
#/live · #/track
Turn idle GPUs off or reschedule them, send each lab its share, get an alert when a job uses far more than usual, and download the monthly report as a PDF.
Slack · Discord · webhook · PDF
joules sends energy readings and the names of the jobs that used them. It never sends your code, prompts, command arguments or files, and nothing at all unless you ask it to.
Read the Privacy Policy and the Data Processing Agreement, or ask us anything.
The paid plans are for fleets. These are for anyone who trains or runs a model, free for good: a calculator, the joules command, an open leaderboard and an energy check for pull requests.
Enter the model size, the amount of data and your hardware, and see the electricity, cost and CO₂ of a training run before you pay for it.
6 × params × tokens → kWh → g CO₂
Put joules in front of anything you run, like time, and get its real energy, cost and CO₂ from the hardware’s power meters.
joules -- python3 -c "sum(range(10**8))"
A GitHub Action measures your benchmark on every pull request and says when a change makes it use more energy than before.
joules ci --budget 10 -- python3 -c "sum(range(10**7))"
Put joules in front of anything you run, like time. It reads the power meters of the GPU and CPU while the command runs and prints the energy, the cost and the CO₂. This is real output from a MacBook Air.
$ joules -- sh -c 'for i in $(seq $(getconf _NPROCESSORS_ONLN)); do python3 -c "x=0 for i in range(100000000): x+=i" & done; wait' joules · 15.45 s · exit 0 Apple SoC (CPU + GPU + ANE) 71.5 J 4.6 W avg total 71.5 J = 19.9 mWh cost <0.0001 · CO₂ 0.00735 g at 370 g/kWh
The least energy physics allows for erasing one bit at room temperature: the Landauer limit, kBT ln 2.
Landauer, 1961 · at 300 KHow far above that limit a 3-billion-parameter model ran, per operation, on a MacBook Air. Measured with joules.
llama3.2 3B · M3 MacBook Air · 0.241 J per tokenThe largest difference between our calculator and the published energy of GPT-3, BLOOM and Llama 3 70B.
Patterson et al. 2021 · Luccioni et al. 2022 · MetaA name that is easy to say and says what it does: operations for the watts your GPUs burn. Your account, keys, runs and the joules command all stay the same.
When a machine sleeps or goes offline, the Live graph now shades the gap and says why, and joules agent --keep-awake keeps a Mac awake while it measures.
Carbon presets for every Google Cloud region’s grid, from N. Virginia to Singapore, plus Canada’s provinces, in the calculator, the API and joules.
joules reads the power meters built into the hardware: NVIDIA and AMD GPU sensors, Intel and AMD CPU energy counters (RAPL) and Apple silicon’s own power reporting. The calculator is within 0.4% of the published energy of GPT-3, BLOOM and Llama 3 70B. What is and is not included is written out on the Method page under “Accuracy and limits”.
No work runs inside your jobs. The agent reads the power counters about once a second, next to your workload, and the command wrapper only watches the command it starts.
Only what you ask for: energy, power, cost and carbon, the machine’s name, and the names and users of the jobs that used the power. Never code, prompts, command arguments, inline scripts or files.
NVIDIA, AMD and Intel GPUs, Intel and AMD CPUs, and Apple silicon Macs. On Windows the GPU is measured and the CPU estimated. The agent knows Slurm jobs, Kubernetes pods, containers and users, and serves Prometheus metrics too.
Yes. The Free plan has the calculator, joules and the leaderboard for good. Pro is $19 a month and can be cancelled any time. For a fleet, Max starts with a 4–6 week pilot on your own cluster.
PHENEX TECHNOLOGIES INC., a British Columbia corporation in Vancouver, Canada. WattOps was called Landauer Gap until October 2026; the Landauer gap, how far computing sits above the least energy physics allows, is still the science inside it. The method comes from the D3 research series, published with a DOI, and every formula is shown on the Method page.
curl -LsSf https://wattops.dev/install.sh | shjoules --track my-project -- python train.pyRunning a fleet? Book a demo and we will set up a pilot with you.
You have been invited to a team on WattOps. Sign in, or create an account, with the email address the invite was sent to.
This is a preview. Sign-in and accounts work on the website.
Open wattops.dev ↗Free account. By continuing you agree to the Terms and Privacy policy.
An estimate from the inputs above, not a measurement. To measure a real run, use joules. How it is worked out →
| Change | Energy | CO₂ | Cost | Saved |
|---|
| Part | Energy | Share | CO₂ |
|---|
Where would you like to run it first? Pick one; you can add the others any time from here.
Every run you measure with joules: the energy, cost and CO₂ of each one, and whether they are going down.
| When | Run | Above usual | Sent to |
|---|
| Finished | Project | Run | Hardware | Time | Energy | CO₂ | Gap |
|---|
Energy is what each machine's own meters report: NVIDIA, AMD and Intel GPUs, Intel and AMD CPUs with memory, or on a Mac the Apple chip (CPU, GPU and Neural Engine). Screens, disks and power-supply losses are not included; --pue adds a building's cooling and losses. Runs marked simulated are not measurements. Accuracy and limits →
Connect a computer once. After that, every run you measure on it shows up on this page by itself.
Waiting for your first run… this page updates by itself.
Add --params and --tokens (billions) so joules can work out the Landauer gap. joules sends the energy, time, cost, CO₂, hardware and a short label: the program and script name, or your --label. Never your arguments, code, outputs or file contents. Each tracked run uses one API call.
Every machine running joules agent, a few seconds behind: what your fleet draws right now, what it costs by the hour, and which GPUs burn power doing nothing.
| Job | Machine | GPUs | Power | Per hour |
|---|
Each machine's power is measured by its own meters every second (--pue adds a building's cooling and losses). The split between jobs is an attribution: GPU energy by the GPU memory each job holds (GPU time on AMD and Intel), CPU and memory energy by CPU time. A GPU counts as idle when no job holds it or it is under 5% busy. Cost and CO₂ use each agent's --price and grid. Accuracy and limits →
Waiting for your first machine… this page updates by itself.
joules loginjoules agent --track fleetThe agent sends each machine's power, its idle GPUs and the jobs running on it (job name, user and power). Never commands, arguments, code or files. Heartbeats do not count against your API calls. In Kubernetes, run it as a DaemonSet with --name $NODE_NAME; on Linux, run it as root (or as a systemd service) so it can read the CPU energy counters. A machine that goes to sleep sends nothing and leaves a gap in the graph; add --keep-awake to keep it awake while the agent runs.
Every estimate you keep, private to your account. Select two to compare.
Runs are saved in this browser. Sign in to keep them in your account and open them on any device.
Some runs are only in this browser.
No saved runs yet. Configure a run in the calculator, then press S or Save run.
| Run | Energy | CO₂ | Cost | Gap |
|---|
| Metric | Change |
|---|
Energy per generated token, measured with joules on real hardware and shared by the people who ran it. Each row is the median of every run for that model and machine; lower is better.
| # | Model and machine | Energy per token shorter is better | Speed | Runs |
|---|
Each figure is what the machine's own meters reported while the model generated tokens: the GPU for NVIDIA, AMD and Intel GPUs, the Apple chip on a Mac. Power at the wall socket is higher. Accuracy and limits →
joules sends only the model name, hardware, energy per token, speed and average power. Nothing from your prompts, outputs, host name or files. Simulated runs are refused. Results from a quiet machine with --subtract-idle 5 are the most comparable.
| Model | Hardware | J / token | tok/s | Shared |
|---|
Every figure comes from a published formula, and every assumption is editable in the calculator.
The standard operation count for dense transformers. Run time is compute ÷ (peak throughput × utilisation).
Accelerators first, then CPUs, memory and networking, then cooling and building losses.
Grid presets are rounded recent annual averages. Use your provider’s figure for formal reporting.
One bit per operation gives the lowest floor, so the gap is an upper bound. Reversible computing aims to avoid erasure altogether.
| Run | Source | Calculator | Published | Difference |
|---|---|---|---|---|
| GPT-3 175B, energy | Patterson et al. 2021 | 1,290 MWh | 1,287 MWh | +0.2% |
| GPT-3 175B, carbon | Patterson et al. 2021 | 553 t | 552 t | +0.2% |
| BLOOM 176B, energy | Luccioni et al. 2022 | 433 MWh | 433 MWh | 0.0% |
| BLOOM 176B, carbon | Luccioni et al. 2022 | 24.7 t | 24.7 t | 0.0% |
| Llama 3 70B, energy | Meta model card | 4,480 MWh | 4,480 MWh | 0.0% |
| Llama 3 70B, carbon | Meta model card | 1,900 t | 1,900 t | 0.0% |
The calculator is also compared, on every change, with a separate implementation of the same formulas written independently in Python, over random inputs.
| Hardware | Where joules reads energy | What it covers |
|---|---|---|
| NVIDIA GPUs | The driver's energy counter (NVML); its power reading on older GPUs | The GPU board |
| AMD GPUs | The amdgpu driver | The GPU, as the driver reports it |
| Intel Arc and Data Center GPUs | The i915 or xe driver | The GPU |
| Intel and AMD CPUs (Linux) | RAPL energy counters | CPU package, and memory where the CPU reports it |
| Mac with Apple silicon | powermetrics, Apple's own figure | The Apple chip: CPU, GPU and Neural Engine |
| Intel Mac | powermetrics | The CPU package, with its graphics and memory |
| No energy counters (Windows CPUs, cloud VMs) | None: estimated from CPU time, and labelled ESTIMATED | Not a measurement; good for comparing runs |
--pue.--subtract-idle, what the machine draws at rest is measured first and taken off, so a run counts only the energy it caused.Run the same model from your code, CI and dashboards. Create and revoke keys in Settings → API keys.
| Endpoint | Plan | What it does |
|---|---|---|
| POST/api/v1/estimate | Free, Pro | Inputs in, energy, CO₂, cost, Landauer gap and ranked savings out. Same model as this page. |
| POST/api/v1/estimate | Pro | With {"inputs": {…}, "save": true, "name": "…"} the run is also saved to your account. |
| POST/api/v1/report | Pro | Branded PDF report with a verifiable report ID. Same body as estimate. |
| POST/api/v1/report | Pro | With {"kind": "project", "project": "…", "days": 30}: a measured energy report over every tracked run in that project and period. Add "team": true for your team's runs. |
| POST/api/v1/track | Free, Pro | Add a measured run. This is what joules --track sends; a team key puts it in your team. The reply lists any energy alerts it set off. |
| GET/api/v1/runs | Pro | Your saved runs, newest first. ?limit=1…200 |
| GET/api/v1/measurements | Free, Pro | The leaderboard: median joules per token for each model and machine. ?model=llama filters, ?mine=1 lists yours. |
| POST/api/v1/measurements | Free, Pro | Add a measurement. This is what joules bench --share sends. DELETE ?id= removes one of yours. |
| GET/api/health | Public | Service status and model version. |
Errors are JSON: {"error": {"code", "message", "fields"}}. 401 bad key · 400 bad inputs (each field named) · 403 Pro feature · 429 limit reached, with Retry-After. Every response carries X-RateLimit-Limit and X-RateLimit-Remaining.
Manage your profile, sign-in, team, plan, developer tools and API keys, preferences, alerts and data.
How you appear in WattOps.
— The ways you sign in, your email address and your password.
Signed in on a computer you no longer use? Sign out everywhere, including here. API keys keep working; revoke them under API keys.
Share projects, Tracking, alerts and energy reports with up to 10 people.
| Member | Role | Joined |
|---|
| Sent | Expires |
|---|
Your plan, what it includes, and this month's API calls.
| Free | Pro · $19 a month | Max · $8 per GPU a month | |
|---|---|---|---|
| API calls a month | 100 | 20,000 | 1,000,000 |
| API calls a minute | 10 | 120 | 1,200 |
| API keys | 2 | 10 | 50 |
| Calculator, Tracking, leaderboard, joules, CI actions | ✓ | ✓ | ✓ |
| Branded PDF reports | — | ✓ | ✓ |
| Save and list runs from the API | — | ✓ | ✓ |
| Measured energy reports for a project (PDF) | — | ✓ | ✓ |
| Energy alerts, in the app and to Slack, Discord or a webhook | — | ✓ | ✓ |
| Team workspace, up to 10 people | — | ✓ | ✓ |
| Live: every machine's power, idle GPUs and running jobs, every 5 seconds | — | — | ✓ |
Max is $8 per GPU a month billed yearly ($10 billed monthly), with a $500 a month minimum and 50% off for universities and public research. It is invoiced under a written order form, and a 4–6 week pilot costs $2,000, credited to your first year: talk to us. Pro is billed monthly by Stripe and you can cancel any time from Manage billing. See the Terms and refund policy.
Everything for putting joules on machines and using WattOps from code, in one place.
Install joules on a Mac, Linux or Windows computer, a GPU server, a Slurm or Kubernetes cluster, step by step.
Open setup →Create a key for each machine, CI job or script, see when it was last used, and revoke it.
Manage keys →The estimate, tracking, measurement and report endpoints, with examples in curl, Python and Node.
Read the docs →Measure a command on every pull request, comment the change in energy and fail the check over budget.
Add the workflow →Measure joules per token of a local model and share it to the open leaderboard.
Run a benchmark →joules agent serves /metrics for Prometheus and /jobs as JSON on port 9877, next to your existing dashboards.
The same command updates an existing install. joules --version shows yours; joules doctor checks which power meters this machine has.
Keys let joules, CI and your code use your account. Treat them like passwords. How to use them →
| Name | Key | Created | Last used |
|---|
Runs tracked with a team key appear on the team's Tracking page. Its calls count against the team owner's plan.
| Name | Key | Made by | Created | Last used |
|---|
Saved to your account, so every device you sign in on uses them.
Choose when to hear that a run used much more energy than usual. Alerts that fire show on the Tracking page.
| For | Project | Threshold | Webhook |
|---|
What your account holds, and a copy of all of it.
One JSON file with everything above, plus your plan, preferences, team and alerts. API keys are listed by name and prefix only; the keys themselves are never stored.
Permanently remove your account and everything in it.