R1 Hardware Engine

Execution authority · local-first · GPL-3.0

The 70B loads.
Then your desktop freezes.

Some runs shouldnever start.

R1 Hardware Engine is a VS Code extension that sits between the model loader and whatever asked for it — you, or your coding agent. It reads live VRAM, system memory and KV cache pressure, then returns ALLOW, DOWNGRADED or DENY. On DENY, the launcher is never called.

Install free via Open VSX Read the source

No account. No license key. No purchase. Every model unlocked on install.

VRAM allocation map RTX 4080 · 16 GB

Weights 4.1 GB KV cache 1.4 GB Runtime 1.1 GB Headroom 9.4 GB

ALLOW
Downloads
3,200+
Model library
21 models
Families
7
Verdict states
3
Telemetry events
0
Price
$0
01

Three answers. Nothing in between.

ALLOW

The configuration fits inside real headroom with margin to spare. Execution proceeds untouched.

Predicted pressure below the safe threshold

DOWNGRADED

The request as written would destabilise the system — so it is rewritten. KV cache quantised, context reduced, CPU offload engaged.

Recovered into a configuration that fits

DENY

No amount of compression makes it fit. Execution is blocked, with the reason stated explicitly.

Hard wall — physical limit, non-negotiable

02

Your agent asks before it runs

A coding agent that decides to run a model locally has no idea what your machine can take. R1 exposes the authority engine as two MCP tools, so it can ask — and be told no.

check_hardware_fit
Returns the verdict for a model and context without launching anything.
run_local_model
Asks for the verdict, then launches only if it passes. There is no code path from DENY to the launcher.

The guarantee is structural, not advisory. runLocalModelGate evaluates first and returns the refusal; launchModel is never reached on a DENY.

Wiring it up

The server ships as a stdio binary. Point any MCP client at it: 

{
  "mcpServers": {
    "r1-hardware": {
      "command": "node",
      "args": ["<extension-path>/out/mcp-server.js"]
    }
  }
}

Works in Claude Code, Cursor, or anything that speaks MCP over stdio. Diagnostics go to stderr, so the protocol stream stays clean.

agent → run_local_model
→ agent requests model Llama 4 Scout context 32K ← r1-hardware-engine required 67.9 GB available 22.0 GB ✗ DENY — insufficient VRAM 109B total parameters; MoE keeps every expert resident. Not recoverable by quantisation or context reduction. launchModel not called.

The agent gets a refusal, not a crash

03

What it would decide, on your card

Plenty of sites will calculate a VRAM number for you. This one runs the engine's own arithmetic — same model matrix, same formula, same salvage order — so what you see here is the verdict the extension would reach.

51.1 tokens / sec
estimated
ALLOW

Weights 7.7 GB KV cache 1.3 GB Runtime 1.1 GB Headroom 5.9 GB

Fits within safe headroom on RTX 4080 — 5.9 GB left for the OS and display.

Weights, layer counts and KV geometry come from the same model matrix the extension ships, and the fit is computed with the engine's own formula. Two differences: this page assumes the whole card is free, where the extension measures real free VRAM — always lower — and it can't see your driver, display or what else is resident. Marginal fits here can still be denied there.

04

Every model, measured against your card

Estimated weights-only footprint at Q4, before context and runtime overhead. Colour follows the verdict for the hardware selected above — change the card and the ladder repaints.

✓ Fits ↓ Tight — needs stabilisation ✗ Exceeds hardware

05

Why local runs fail after they start

A local model does not fail at launch. It fails once weights are resident, the KV cache grows, and the operating system starts swapping to keep up. By then the desktop is already gone. R1 moves that decision to the front.

STEP 01

Request

A local model configuration is requested — model, quantisation, context, batch.

STEP 02

Predict

The authority engine reads live hardware and predicts real memory pressure across VRAM and system RAM.

STEP 03

Stabilise

If the request is close, it is rewritten — quantised KV cache, reduced context, CPU offload — rather than refused outright.

STEP 04

Enforce

If instability remains likely, execution is denied. No GPU reset, no frozen desktop, no forced reboot.

06

In action

R1 Hardware Dashboard

Live hardware dashboard

R1: Validate & Run
Model DeepSeek-R1 7B (Q4) VRAM 4.1 GB / 16 GB Context 8,192 tokens ✓ ALLOW — safe to execute Predicted 28.3 TPS · 12.1% VRAM pressure

Safe execution — ALLOW

R1: Validate & Run
Model DeepSeek-R1 70B (Q4) VRAM 38.2 GB required Available 16 GB ✗ DENY — insufficient VRAM Would cause GPU OOM + system freeze

Crash prevention — DENY

R1: Validate & Run
Model Qwen3 32B (Q8) Requested 32K context ↓ DOWNGRADED to Q4 + 8K ctx ⚡ ALLOW with stabilisation KV cache quantised · CPU offload active

Stabilisation — DOWNGRADED, then recovered

07

What you get

The full model library — free

  • 21 models across 7 families, unlocked for everyone
  • DeepSeek R1 · Llama 4 · Llama 3 · Qwen3 · Mistral · Phi · Gemma 3
  • VRAM predictions for every model and quantisation tier
  • No account, no license key, no purchase — install and it is all there

Advanced stabilisation

  • 4-bit KV cache quantisation
  • Aggressive context reduction strategies
  • CPU offload fallback for borderline configurations

Stabilisation does not bypass hardware limits. If a configuration cannot be made safe, it is still denied.

08

Datasheet

Telemetry
None. Optional local-only counters never leave your machine.
Network activity
None in the background. Network access occurs only when you explicitly click an external link.
Execution
Fully local. Prompts, models and outputs remain on your hardware.
Cloud dependency
None. No background services, no hidden execution paths.
Decision model
Deterministic. Every request returns ALLOW, DOWNGRADED or DENY with explicit reasoning.
License
GPL-3.0. Packaged inside the extension VSIX.
Source
Available on GitHub.
Registry
Open VSX — compatible with VS Code, VSCodium, Cursor and Windsurf.
09

Questions people actually ask

What is R1 Hardware Engine?

R1 Hardware Engine is a free, open-source VS Code extension that decides whether a local large language model will fit on your hardware before it runs. It reads live VRAM, system memory and KV cache pressure, then returns one of three verdicts: ALLOW, DOWNGRADED or DENY. It is published by BattBotStudios under the GPL-3.0 licence.

Is R1 Hardware Engine free?

Yes. It is free and GPL-3.0 licensed. There is no account, no licence key, no paid tier and no trial. All 21 models across 7 families are unlocked on install.

Does R1 Hardware Engine send data to the cloud?

No. It sends no telemetry and makes no background network requests. Prompts, models and outputs stay on your hardware. Network access happens only when you explicitly click an external link, and any optional counters are local-only.

How much VRAM do I need to run a 70B model?

About 38.5 GB for the weights alone at 4-bit quantisation, before context and roughly 1.1 GB of runtime overhead. A 70B model therefore does not fit a 16 GB or 24 GB consumer GPU at 4-bit, and the engine returns DENY rather than letting the run exhaust the GPU.

Will a 32B model run on a 16 GB GPU?

Not at 4-bit with a normal context window. A 32B model needs roughly 17.6 GB for weights alone, which already exceeds 16 GB before KV cache and about 1.1 GB of runtime overhead are counted. A 14B model at 4-bit needs about 7.7 GB and fits comfortably.

What does the DOWNGRADED verdict mean?

DOWNGRADED means the request as written would destabilise the system, so the engine rewrote it to fit — quantising the KV cache to 4-bit, reducing the context window, or engaging CPU offload — and allowed the run in that recovered configuration.

Can stabilisation make any model fit?

No. Stabilisation does not bypass hardware limits. If a configuration cannot be made safe even under maximum compression and context reduction, it is still denied. True physical limits are non-negotiable.

Can a coding agent use R1 Hardware Engine?

Yes. It exposes two MCP tools: check_hardware_fit returns a verdict without launching anything, and run_local_model asks for the verdict first and launches only if it passes. An agent that would otherwise start a model too large for the machine gets a refusal with a reason instead.

How is R1 Hardware Engine different from a VRAM calculator?

A calculator gives you a number you can ignore. R1 Hardware Engine sits in the execution path: on a DENY the launcher is never called. It also tries to rescue the run first — quantising the KV cache, reducing context, then offloading to CPU — and tells you which of those it did.

Which editors does R1 Hardware Engine work with?

It is distributed through the Open VSX Registry, so it installs into VS Code, VSCodium, Cursor and Windsurf on Windows, macOS and Linux.

Find out before you press run.

Install the extension, open the sidebar, and the engine scans your hardware and unlocks the whole model library immediately.

Install free via Open VSX Read the docs