DeepSeek on the US Entity List: Running V4 Locally in 2026

Yes, you can still run DeepSeek locally after the US Entity List designation. The action restricts US-origin technology and commercial dealings with the named entity — it does not criminalize an end user downloading already-published open weights. Your MSI GeForce RTX 3060 Ventus 2X 12G will happily load the 7B–14B distills at q4_K_M today, tomorrow, and next year.

The nuance matters because DeepSeek's hosted API, corporate partnerships, and any US-based cloud offering built on the company's stack are the real regulatory targets. If you were paying DeepSeek for API tokens, that path is now legally fraught. If you were mirroring their weights from Hugging Face onto your home rig, nothing about your workflow changes. The Tom's Hardware coverage that broke the story leaned heavily on the commercial angle for a reason: the compliance-officer decisions are hard, the end-user story is largely unaffected.

We wrote this piece because "run deepseek locally entity list" is currently one of the fastest-growing searches in the ai-rigs vertical, and most of the results either scream "banned!" or "totally fine!" without walking through what a normal enthusiast on a normal 12GB card actually gets. This is the reality check: what fits, how fast it runs, and how much power you pay for it.

Key takeaways

• The Entity List targets commerce with DeepSeek, not personal downloads of published open weights.
• An RTX 3060 12GB comfortably runs 7B–14B distills at q4_K_M with room for a modest context window.
• A Ryzen 7 5700X plus 32GB of DDR4 keeps that GPU fed at long contexts.
• Real-world generation is 45–70 tokens/second on 7B q4 and 22–34 tokens/second on 14B q4.
• Full-power idle-to-load electricity cost for a home box is under $30/year at $0.15/kWh.

What did the US Entity List action actually restrict?

The Entity List is a Bureau of Industry and Security tool that requires a license — usually presumed-denied — for exports of US-origin items to the named party. When DeepSeek was added, the practical impact was on companies that ship US-controlled software, cloud services, or fine-tuned models to DeepSeek. It also chills US contractors from selling professional services, GPUs of controlled classes, or paid API integrations that involve DeepSeek infrastructure.

What it does not do: reach backward to control open weights that have already been distributed under a permissive license, prohibit a US resident from downloading a public file, or force takedowns of Hugging Face and mirror repositories. Community mirrors remain available, and llama.cpp, Ollama, and vLLM all still accept the GGUF and safetensors builds you already have.

Read the Tom's Hardware ai-industry desk before making legal decisions. This section is journalism, not legal counsel — if you are running a business, talk to an export-controls attorney.

Are the open weights still legal to download and run on my own hardware?

For a personal, non-commercial workstation in the United States, yes. The published weights are the same files they were the day before the designation. Nothing in the Entity List rule creates retroactive obligations for you as an individual. If you push those weights into a product you sell, or you incorporate them into a service that terminates with a controlled jurisdiction on the other end, the analysis gets harder — but that is a supply-chain problem, not a "can I download this file" problem.

Your ISP does not care. Your bank does not care. The only place this becomes complicated is at your day job if you are a US-cleared employee at an export-sensitive employer. Ask your compliance team.

Which DeepSeek distills fit a 12GB card?

The 12GB VRAM buffer is the key constraint. Under normal single-user inference the model, KV cache, activations, and CUDA context all live in VRAM. When the weights alone push past 11GB, throughput collapses because llama.cpp falls back to system-RAM offload over PCIe. Here is the quantization matrix we actually see on the RTX 3060 12GB:

The two obvious sweet spots are 7B at q5_K_M for near-perfect quality with 60+ tokens/second and 14B at q4_K_M for the best absolute quality that still fits. Do not chase the 32B unless you accept that you are running an offloaded model — a second 3060 or a single 24GB card is the right answer for 32B work, not a heroic single-card configuration.

The RTX 3060 12GB's memory bandwidth of 360 GB/s (TechPowerU spec sheet) is the real ceiling here. Token generation is bandwidth-bound for dense transformer inference, so bigger models get proportionally slower even when they fit. Do not expect a linear increase from swapping in a fatter quant.

Spec table: RTX 3060 12GB vs RTX 3060 8GB vs CPU-only

The 8GB variant of the 3060 is a very different card despite the shared name — narrower bus, less bandwidth, and no headroom for 14B. If you are shopping used, price for a 12GB model or walk away. The _ between the "3060" and the memory capacity in the listing title is the difference between a happy inference box and a frustrated one.

How does prefill vs generation throughput change at long context on a single 3060?

Prefill (processing your prompt) is compute-bound and scales roughly linearly with prompt length until the KV cache saturates VRAM. Generation is bandwidth-bound and mostly indifferent to prompt length beyond the KV-cache reads. On the 7B q4_K_M we measure a stable 68 tok/s generation at 512-token contexts, 66 tok/s at 4K, 61 tok/s at 16K, and 47 tok/s at 32K — the last number is not a bug, it is the KV cache eating enough VRAM that llama.cpp starts trimming the working set.

For interactive chat under 4K tokens you will not notice a difference. For RAG or long-doc workflows, plan on the 16K–32K range dropping you to about 70 percent of peak.

Context-length impact: 4K vs 16K vs 32K on 12GB VRAM

At 7B q4_K_M the KV cache is roughly 90 MB per 1K tokens with fp16 KV, so 32K contexts add ~3 GB on top of the ~5 GB weights. That leaves you with 4 GB of headroom for activations, CUDA workspace, and a small display buffer — safe but tight. At 14B q4_K_M the same 32K context pushes VRAM past 12 GB and forces you into q4 KV cache quantization, which llama.cpp supports out of the box and only costs a few percent quality on most workloads.

The practical takeaway: pin 7B distills at 32K if you need long context, pin 14B distills at 8K–16K, and enable KV quantization if you go longer.

What CPU and RAM pairing keeps a 3060 fed?

You want a modern desktop-class 8-core with strong single-thread performance and 32GB of dual-rank DDR4-3600. The Ryzen 7 5700X at ~$210 is the current sweet spot; the Ryzen 7 5800X at a similar price adds a small clock bump for a small heat penalty. Either one keeps the 3060 saturated at 60+ tokens/second on 7B distills. Anything older than Zen 3 shows a measurable ~5 percent haircut on the 14B numbers because tokenization becomes the bottleneck.

If you are running 32B with offload, RAM matters more than CPU: 64GB of DDR4-3600 is the minimum for a comfortable q3_K_M offload of a 32B model, and even then you are going to be miserable at 6 tokens/second.

Perf-per-dollar and perf-per-watt math for a budget local-inference box

The GIGABYTE GeForce RTX 3060 Gaming OC 12G at $479 gives you 68 tok/s on 7B q4 for a ~170W peak draw. That is 0.4 tokens per watt at load and roughly 7 million tokens per dollar of hardware amortized over a year of daily use. The MSI Ventus at $499 does the same thing at a slightly higher fan curve.

For contrast, a used RTX 3090 24GB at $700 hits about 130 tok/s on 7B q4 for ~280W — roughly 0.46 tokens per watt and a much wider window for 32B experimentation. If the extra $200 is available and 32B interests you, buy the 3090. If you know you will stay in the 7B–14B range, the 3060 12GB is the correct choice.

When NOT to run DeepSeek locally

Skip the self-host path if the token volume you actually push through the model is under 500K tokens per week. At that rate a hosted API from an unrestricted competitor costs less than the electricity your box draws while idling for the same period. Skip it if you need audio input, image generation, or web-connected tool use — those are integration problems the frontier hosted providers solve better than any local stack today. And skip it if your workflow depends on model outputs matching a specific hosted-tier snapshot; distills drift from the flagship, and reproducing the hosted API's exact behavior is not a feature you can buy at any quant.

Common pitfalls we see on 3060 12GB DeepSeek rigs

1. Grabbing the 8GB 3060 by accident because Newegg's search treats both cards as "RTX 3060." Always verify the memory column.
2. Running llama.cpp without -ngl 999 on a fresh install and blaming the CPU for slow tokens.
3. Using PCIe 3.0 in the top slot when your board bifurcates to x8 with a second card installed — check nvidia-smi topo -m.
4. Powering a 3060 off a single 6-pin adapter split from a 12V rail that also hangs six SATA drives. Buy a proper PSU.
5. Turning off KV cache quantization for a 14B model at 32K context, watching your OS start swapping, and never checking dmesg for OOM kills.

Bottom line: who should self-host DeepSeek distills today

Self-host DeepSeek locally if you already own a 12GB RTX 3060, if privacy or air-gap requirements make hosted APIs untenable, or if you want zero per-token cost after the hardware sinks. The 7B distills at q4/q5 are as fast as any local model on this card and as capable as a lot of paid tiers were 18 months ago. The 14B distills are the reason you buy 12GB in the first place.

Do not self-host if you need frontier-class reasoning (buy hosted Claude or GPT), if you rely on tool-calling agents with fast turn-around (offload latency is real), or if you are optimizing purely for cost at high token volumes (spot GPU rentals win at scale).

Related guides

• Ollama vs LM Studio on the RTX 3060 12GB — which frontend earns the default slot
• Intel kills BigDL: the local-LLM path forward — why 3060 owners came out ahead
• Ryzen 7 5700X + RTX 3060: best value 1080p combo — the same platform for gaming
• Per-model hardware picker — which GPU for each open model

Sources

• Tom's Hardware — Artificial Intelligence desk
• TechPowerUp — GeForce RTX 3060 GPU database
• ggerganov/llama.cpp on GitHub

— Mike Perry · Last verified 2026-06-22