How this works

What compares

Two results share a rank only if all of these keys agree:

category · tier · lane · profile version · runtime · runtime version · GPU count · parallelism

LocalMax computes a hash of the profile file. The hash goes into each manifest. If someone edits a profile after release, the hash changes. Old and new results then stop sharing a leaderboard. A released profile does not change. A change makes a new version.

Three tiers

LocalMax supports 12 GB cards and 192 GB workstations. That is 16 times the capacity and 6 times the memory bandwidth.

One small model across that range measures memory bandwidth and little else. The second card in a dual workstation stays idle. A DGX Spark ranks below an RTX 3060.

So a tier is the VRAM that its run must fill: 12 GB, 24 GB, 64 GB. Each tier has its own model.

The Frontier model is a 32B. At FP8 it is about 35 GB. It fits a DGX Spark and a dual RTX PRO 6000 workstation. A 70B model would exclude the Spark from the tier that exists to describe it.

Three lanes

Hardware support for a precision is not the same on all cards.

• FP8 needs Ada or newer. This is the default lane.
• INT4 needs Ampere or newer. This lane has the widest hardware support. An RTX 3090 can appear only here.
• NVFP4 needs Blackwell.

LocalMax ranks each lane on its own. A single table across lanes would compare different work, and would reward the loosest precision.

What LocalMax measures

Decode and prefill are separate numbers. Decode follows memory bandwidth. Prefill follows compute. Time to first token mixes prefill with scheduling, so it hides the difference between a fast RTX 5090 and a large DGX Spark.

LocalMax ranks an LLM profile on decode throughput. Two gates apply: time to first token at p95, and inter-token latency at p95. A system that cannot answer at interactive speed is published, but it is not ranked.

LocalMax ranks a vision profile on images for each minute. An answer-accuracy gate applies first. A fast but incorrect system does not get a rank.

LocalMax ranks a diffusion profile on seconds for each denoising step. That value does not change if the resolution or the step count changes. Images for each minute comes from it, and is the number that a reader sees.

Diffusion is compute-bound. The LLM profiles are bandwidth-bound. This is deliberate. Without it, three categories give one memory-bandwidth chart three times.

Power has a type

A discrete card reports board power. A GB10 reports power at the SoC module, where the CPU, the GPU and the memory share one rail. These are different quantities.

Each result carries a power domain: gpu_board, soc_module orunavailable. LocalMax does not rank energy across domains. It shows the wattage of a unified-memory system, but it gives that system no efficiency value.

Verification states

Verified

The container digest is a signed release. The profile hash agrees. All required evidence is present. Telemetry covers at least 99% of the run. LocalMax computed each derived value again from the raw records, and the values agree. Ranked.

Community

The manifest and the signature are valid, but the evidence is incomplete or the image is not an official release. All raw values are published. Not ranked.

Flagged

A value is outside the expected range for that hardware. Held for review. LocalMax changes nothing. The value stays as submitted, with the finding attached.

How LocalMax checks a result

1. Validate the manifest against the published schema.
2. Verify the Ed25519 signature over the canonical manifest.
3. Compare the profile hash with the published profile.
4. Compare each runtime flag with the pinned set.
5. Check the hardware: total VRAM against the tier, architecture against the lane, GPU count against the profile.
6. Read back each evidence file. R2 verified its SHA-256 during upload.
7. Scan text evidence for secrets. A match rejects the submission and deletes the files.
8. Compute each metric again from the raw records. Percentiles, throughput, error rates and accuracy must agree within tolerance.
9. Apply the plausibility bounds. A violation flags the result. It never changes a value.
10. Apply the ranking gates. Then look for a duplicate from the same system.

This work runs on a queue, not during the request. That is why a submission returns at once, even under load.

What this cannot tell you

A signature proves that one runner made the bundle, and that nobody changed it after. It does not prove that the hardware is real. It does not prove that the operator was honest. Verified describes the evidence, not the truth of a number.

What protects the data is the cost of a lie. A false number also needs raw records that agree with it, a telemetry trace, and a value that fits the distribution for that GPU. All of it is public. Anyone can check it.

These are inference measurements under one fixed workload. They say nothing about model quality. They say nothing about your prompts. They say nothing about a workload with a different shape.