DEV Community: David

anthropic charges $25/M tokens for opus 4.7. alibaba just released the same capability for free.

David — Thu, 16 Apr 2026 17:14:04 +0000

Anthropic charges $25 per million output tokens for Claude Opus 4.7. That's their new flagship coding model, released today. It's good — 13% better than Opus 4.6 on coding benchmarks, improved vision, stronger at multi-step agentic work.

Meanwhile, also this week: Alibaba released Qwen3.6-35B-A3B under Apache 2.0. Scores 73.4 on SWE-bench Verified. Runs on an 8 GB GPU. Costs nothing.

Two models. Same week. Completely opposite philosophies. Let's break down what's actually happening.

the cloud tax is getting harder to justify

When GPT-4 launched in 2023, there was nothing local that came close. Paying for API access made sense because there was no alternative.

In 2024, open models started catching up. Llama 3, Qwen 2.5, Mistral — good enough for many tasks, but still clearly behind frontier models on the hard stuff.

In 2026, the gap has narrowed to the point where you have to really think about whether the remaining difference is worth $25 per million output tokens.

Here's a concrete example. A developer using Opus 4.7 as their primary coding agent, running maybe 50 complex coding sessions a day:

Average session: ~10K input tokens (code context) + ~5K output tokens (response)
50 sessions: 500K input + 250K output tokens
Daily cost: $2.50 + $6.25 = $8.75/day
Monthly: ~$190/month just for one developer

Now scale that to a team of 5. That's nearly $1,000/month on AI coding assistance.

The same team could buy a single RTX 4070 ($550 one-time) and run Qwen3.6 at 20+ tokens/second with zero ongoing costs.

what you actually get for $0

Qwen3.6-35B-A3B isn't just "a free model." It's specifically designed for the exact use case Opus 4.7 targets — coding agents:

Agentic coding benchmarks:

SWE-bench Verified: 73.4 (fix real bugs in real repos autonomously)
Terminal-Bench 2.0: 51.5 (operate a terminal to solve coding tasks)
MCPMark: 37.0 (tool calling and agent protocols)
QwenWebBench: 1397 Elo (frontend artifact generation)

Architecture advantages for local deployment:

MoE: 35B total params, 3B active — runs like a small model, thinks like a big one
Gated DeltaNet: 3 of 4 layers use linear attention — memory efficient on long contexts
Native vision: understand screenshots, diagrams, code images without a separate model
262K context: plenty for most codebase contexts

What you give up vs Opus 4.7:

Probably some edge on the hardest 10% of tasks
Anthropic's specific safety/self-verification features
The polish of a model trained with massive RLHF compute
Cloud convenience (no GPU needed)

What you gain:

Your code never leaves your machine
No rate limits, no outages, no API key management
No per-token costs, ever
Full control over the model behavior
Works offline, on a plane, in an air-gapped environment
Apache 2.0 — fine-tune it, modify it, deploy it commercially

the $25/M question

Opus 4.7 is genuinely impressive. Anthropic's coding models have been best-in-class for a while and this extends that lead. The self-verification feature — where the model checks its own work before reporting back — is particularly useful for autonomous workflows.

But the honest question every developer should ask is: for my specific tasks, does the delta between Opus 4.7 and Qwen3.6 justify the cost?

For a solo developer building a startup: probably not. Qwen3.6 handles 73.4% of real-world GitHub issues autonomously. That's more than enough for daily coding work.

For a large enterprise with strict compliance requirements and deep pockets: maybe. The convenience and Anthropic's enterprise features have real value.

For anyone processing sensitive code: local wins by default. No amount of ToS promises equals "the data literally never left my hardware."

how to try both and decide

Opus 4.7:

API key from anthropic.com
Model: claude-opus-4-7
$5/M input, $25/M output

Qwen3.6 locally:

ollama run qwen3.6:35b-a3b

Or for a complete setup with a coding agent, vision, and tool calling — Locally Uncensored v2.3.3 supports both. Connect Anthropic's API for Opus 4.7 when you need it, run Qwen3.6 locally for everything else. Switch between them in the same interface. Best of both worlds.

where this is heading

The pattern is clear. Every 3-4 months, a new open model appears that matches the paid frontier model from 6 months ago. The cost of "good enough" is trending toward zero.

Anthropic, OpenAI, and Google will keep pushing the frontier. Open models will keep closing the gap. And the developers in the middle will increasingly ask: "Is the remaining gap worth $25 per million tokens?"

Today, for most coding tasks, the answer is already no.

Locally Uncensored — open-source desktop app for running AI locally. Supports cloud APIs AND local models. Chat, coding agents, image gen, video gen. AGPL-3.0.

claude opus 4.7 just dropped. here's what runs locally for free.

David — Thu, 16 Apr 2026 17:13:20 +0000

Anthropic just released Claude Opus 4.7. It's their best coding model yet — 13% better than Opus 4.6 on their internal 93-task benchmark, better vision, stronger at long-running agentic tasks.

It's also $5 per million input tokens and $25 per million output tokens. API only. Every character you type goes through Anthropic's servers.

Let's talk about what you can do locally for $0.

what opus 4.7 actually brings

Based on Anthropic's announcement:

13% improvement over Opus 4.6 on a 93-task coding benchmark, including 4 tasks neither Opus 4.6 nor Sonnet 4.6 could solve
Better vision — higher resolution image understanding
Stronger agentic workflows — handles complex, multi-step tasks without losing context or stopping early
Self-verification — the model checks its own outputs before reporting back
Available on Claude API, Amazon Bedrock, Google Vertex AI, Microsoft Foundry

These are real improvements. Opus has been the go-to for serious coding work, and 4.7 makes it better.

But here's the thing.

the cost of frontier cloud AI

At $5/$25 per million tokens, a heavy coding session with Opus 4.7 can easily run $2-5/day. A team of developers using it as their primary coding agent? That's hundreds per month.

And every line of your proprietary code flows through someone else's infrastructure. Every prompt, every codebase context, every business logic snippet — stored, processed, potentially used for training (even with opt-outs, you're trusting the provider).

For hobby projects, fine. For anything sensitive — financial code, healthcare logic, proprietary algorithms — that's a real risk.

what runs locally right now

The local model landscape has changed dramatically in the last few months. Here's what's available today at $0/month:

Qwen3.6-35B-A3B (released this week)

35B total parameters, 3B active (MoE architecture)
73.4 on SWE-bench Verified — autonomous bug fixing on real GitHub repos
51.5 on Terminal-Bench 2.0 — agentic terminal coding
Built-in vision, 262K context
Runs on 8 GB VRAM with Q4_K_M quantization
Apache 2.0 license

Is it as good as Opus 4.7? On raw capability, probably not — Anthropic has massive compute advantages. But on the tasks most developers actually do daily (fixing bugs, writing functions, understanding codebases, code review), Qwen3.6 is genuinely competitive. And it runs on hardware you already own.

the real comparison isn't benchmarks

It's this:

	Claude Opus 4.7	Qwen3.6-35B-A3B
Cost	$5/$25 per million tokens	$0 forever
Privacy	Cloud-processed	Never leaves your machine
Speed	Subject to API congestion	As fast as your GPU
Availability	Depends on Anthropic's uptime	Runs offline
Rate limits	Yes	No
Data retention	Anthropic's policy	You control everything
License	Proprietary	Apache 2.0
Vision	Yes	Yes
Agentic coding	Yes (strong)	Yes (73.4 SWE-bench)
Setup	API key + credit card	Ollama + 10 minutes

how to set up the local alternative

ollama run qwen3.6:35b-a3b

That's it. Or if you want a full desktop experience with a coding agent, vision support, and model management:

Locally Uncensored just shipped v2.3.3 with Qwen3.6 day-0 support. It wraps Ollama into a desktop app with a built-in coding agent that streams live between tool calls, agent mode with 13 tools and MCP integration, and remote access from your phone. Open source, AGPL-3.0.

when cloud still makes sense

Being honest: there are cases where Opus 4.7 is worth the money.

You need the absolute frontier of capability and $25/M output tokens is pocket change for your use case
You're doing something that requires Anthropic's specific safety features
You need the model to handle tasks that are genuinely beyond what open models can do today
You don't have a GPU (though even a laptop with 8GB VRAM works for Qwen3.6)

For everyone else — the gap between cloud and local is closing fast. A model that scores 73.4 on SWE-bench running on a gaming laptop would have been science fiction two years ago.

the trajectory matters more than today's snapshot

Every few months, a new open model drops that would have been frontier-class the year before. The pricing gap between cloud and local is permanent — cloud will always cost per token, local will always be free after hardware.

Opus 4.7 is impressive. But the question isn't whether it's good — it's whether it's $5/$25 per million tokens better than what you can run yourself.

For a growing number of developers, the answer is no.

Locally Uncensored — open-source desktop app for local AI. Chat, coding agents, image gen, video gen. Qwen3.6 day-0 support. AGPL-3.0.

i cancelled my AI subscriptions. qwen3.6 on my own GPU does the same thing for free.

David — Thu, 16 Apr 2026 15:56:16 +0000

You're paying $20/month for ChatGPT. $10 for Copilot. Maybe another $20 for Midjourney. And every prompt you type goes through someone else's server.

Meanwhile, Alibaba just open-sourced a model that scores 73.4 on SWE-bench Verified — the benchmark where an AI autonomously reads a GitHub issue, understands the codebase, writes a fix, and runs the tests. That's frontier-level coding ability. And it runs on your gaming laptop.

the model

Qwen3.6-35B-A3B. It's a Mixture-of-Experts model: 35 billion parameters total, but only 3 billion active per token. Your GPU loads 9 experts per token (8 routed + 1 shared) out of 256 total. The rest sit idle.

Result: it runs like a 3B model but thinks like a 30B+ model.

Apache 2.0 license. No usage restrictions. No rate limits. No one reading your code.

what your $0/month gets you

Let's do the math on what you're replacing:

ChatGPT Plus ($20/month) — Qwen3.6 scores 86.0 on GPQA Diamond (graduate-level reasoning), 83.6 on HMMT (Harvard-MIT Math Tournament), and handles 119 languages. It has vision built in — drag an image into the chat and ask questions about it. For most daily tasks, you won't notice a difference. For coding tasks, this model is arguably better than GPT-4 for the stuff you actually do (fixing bugs, writing functions, understanding codebases).

GitHub Copilot ($10/month) — 73.4 on SWE-bench means this model can autonomously fix real bugs in real repositories. 51.5 on Terminal-Bench means it can operate a terminal to solve coding tasks. With the right frontend, it functions as a full coding agent, not just autocomplete.

Cloud API costs — no per-token pricing. Run it 24/7 on your own hardware. The model doesn't get slower during peak hours. It doesn't have outages. It doesn't change its behavior because the provider decided to add more safety filters.

the hardware you already own is enough

This is the part that surprises people. With Q4_K_M quantization:

8 GB VRAM (RTX 3060, RTX 4060): runs at 30+ tokens/second
12-14 GB VRAM (RTX 4070, RTX 3090): Q8 quantization, 20+ tok/s
Apple Silicon M1/M2/M3: runs great on unified memory

If you bought a GPU in the last 3-4 years, you probably have enough. The MoE architecture is the key — your GPU only processes 3B parameters per token regardless of the total model size.

the catch (being honest)

There are trade-offs. You should know them before you cancel anything:

No real-time internet access — the model only knows what it was trained on. No "search the web" or "check the latest docs." You need to paste context manually or use RAG.
Setup isn't zero — you need Ollama or a similar runtime, and a frontend. It's not "open a browser tab and start typing." More like 10-15 minutes to set up if you've never done it.
Long context costs more locally — 262K native context is great on paper, but processing 100K+ tokens on consumer hardware gets slow. Cloud APIs hide this cost from you.
No multimodal generation — Qwen3.6 can understand images (vision input) but can't generate them. For image generation you need a separate model (Stable Diffusion, Flux, etc.)
Updates are manual — when a better model drops, you download and switch yourself. No silent upgrades.

For people who type "write me a poem" into ChatGPT twice a week, this is overkill. For developers, researchers, and anyone processing sensitive data — the trade-offs are overwhelmingly in favor of local.

the stack that replaces everything

Here's what a complete local setup looks like in 2026:

Chat + reasoning: Qwen3.6-35B-A3B (this article)
Image generation: Stable Diffusion 3.5, Flux, or SDXL via ComfyUI
Video generation: Wan 2.1, FramePack
Code completion: same Qwen3.6, connected as a coding agent
Speech-to-text: Whisper (runs on CPU)

Total cost after hardware you already own: $0/month. Forever.

Or use a tool that bundles all of this. Locally Uncensored wraps Ollama + ComfyUI into one desktop app — chat, image gen, video gen, coding agent. v2.3.3 has Qwen3.6 day-0 support with vision and a full agent mode. AGPL-3.0, open source.

the real question

It's not "is local AI good enough yet?" — it passed that threshold months ago.

The real question is: how much longer are you going to pay monthly fees to send your data to someone else's server when the same capability runs on hardware sitting under your desk?

Qwen3.6 weights: HuggingFace

Locally Uncensored — open-source desktop app for local AI. Chat, coding agents, image gen, video gen. No cloud, no subscription. AGPL-3.0.

qwen3.6 scores 73.4 on SWE-bench with only 3B active parameters. here's why that matters.

David — Thu, 16 Apr 2026 15:43:39 +0000

Alibaba just mass-released Qwen3.6 and the first model is already turning heads. Qwen3.6-35B-A3B is a Mixture-of-Experts model with 35 billion total parameters — but only 3 billion are active at inference time.

That means it runs on an 8GB GPU. And it just scored 73.4 on SWE-bench Verified.

For context, Gemma4-31B — a dense model using all 31 billion parameters for every single token — scores 17.4 on the same benchmark. Qwen3.6 uses a tenth of the compute and scores four times higher.

the architecture is genuinely different

Most MoE models just slap a router on top of a standard transformer. Qwen3.6 does something more interesting.

Three out of every four layers use Gated DeltaNet — a linear attention mechanism that's significantly cheaper than standard attention. Only every fourth layer uses full Gated Attention with KV cache. This hybrid layout means you get near-full-attention quality at a fraction of the memory cost, especially on long contexts.

The expert setup: 256 total experts, 8 routed + 1 shared active per token. That's where the 35B→3B compression comes from. Each token only touches the experts it needs.

And it has vision built in. Not bolted on — the model is natively multimodal (Image-Text-to-Text). MMMU score of 81.7, RealWorldQA at 85.3.

the benchmarks that matter

I'm not going to dump every number. Here are the ones that actually tell you something:

SWE-bench Verified: 73.4 — this is the "can you autonomously fix real GitHub issues" test. The model reads the issue, understands the codebase, writes a fix, and runs the tests. 73.4 means it successfully fixes nearly three out of four real-world bugs thrown at it. Its predecessor (Qwen3.5-35B-A3B) scored 70.0. Gemma4-31B scored 17.4.

Terminal-Bench 2.0: 51.5 — agentic terminal coding. Can the model operate a terminal to solve coding tasks? Qwen3.6 beats its predecessor (40.5), the dense Qwen3.5-27B (41.6), and Gemma4-31B (42.9). An 11-point jump over the previous version is massive.

QwenWebBench: 1397 Elo — frontend artifact generation. The predecessor scored 978. A 400+ Elo jump in one generation. For chess players: that's going from a club player to a titled player.

GPQA Diamond: 86.0 — graduate-level science reasoning. This is the benchmark where PhD students in physics, chemistry, and biology try to answer questions outside their subfield and fail about half the time. 86.0 is competitive with models many times this size.

MCPMark: 37.0 — general agent benchmark testing MCP (Model Context Protocol) tool use. Predecessor scored 27.0. Gemma4-31B scored 36.3. This model was clearly trained with agentic tool calling in mind.

what 3B active parameters actually means for your hardware

Here's the thing people keep getting wrong about MoE models. The total parameter count (35B) determines the model's knowledge capacity — how much it "knows." But the active parameter count (3B) determines how fast it runs and how much VRAM it needs at inference time.

So while the model file on disk is large (it contains all 256 experts), at inference time your GPU only loads the 9 active experts per token. The rest sit in memory doing nothing until they're needed.

Practical VRAM requirements:

Q4_K_M quantized: ~6-8 GB — runs on an RTX 3060 12GB at 30+ tok/s
Q8_0 quantized: ~12-14 GB — RTX 4070 territory
FP8 official: ~35 GB — RTX 4090 or A6000
FP16 full: ~70 GB — multi-GPU

If you can run a 7B model, you can run this. The speed profile is similar to a 3B dense model, but the output quality is closer to a 30B+ dense model.

the real competition

The model Qwen3.6 is really competing against isn't Gemma4-31B. It's proprietary models.

73.4 on SWE-bench Verified puts it in the same ballpark as frontier closed-source models — except this one is Apache 2.0 licensed, runs on consumer hardware, and never sends your code to anyone's server.

For coding specifically, the combination of high SWE-bench scores + strong terminal/agent capabilities + MCP support makes this arguably the best local coding model per compute dollar right now.

how to actually run it

The model just dropped so GGUF quantizations are still rolling out. Check HuggingFace for the latest:

Official weights: Qwen/Qwen3.6-35B-A3B
FP8 variant: Qwen/Qwen3.6-35B-A3B-FP8

Once GGUFs land, ollama run qwen3.6:35b-a3b should work.

For a full desktop setup with model management, vision support, and a built-in coding agent, Locally Uncensored just shipped v2.3.3 with day-0 Qwen3.6 support. Open source, AGPL-3.0.

the bottom line

3B active parameters scoring 73.4 on SWE-bench is the kind of efficiency gain that changes what's possible on consumer hardware. A year ago you needed a 70B+ dense model or API access for this level of coding capability. Now it runs on a gaming laptop.

Apache 2.0. No strings attached.

Locally Uncensored is an open-source desktop app for running AI models locally — chat, coding agents, image gen, video gen. AGPL-3.0.

How to run Qwen3.6-35B-A3B locally — the coding MoE that beats models 10x its active size

David — Thu, 16 Apr 2026 15:20:08 +0000

Qwen just released Qwen3.6-35B-A3B — the first model in their 3.6 series. It's a Mixture-of-Experts model with 35 billion total parameters but only 3 billion active at inference time.

Translation: big-model quality at small-model speed. And this time it has vision built in.

Why this model matters

The numbers speak for themselves:

73.4 on SWE-bench Verified — this is an agentic coding benchmark where the model autonomously fixes real GitHub issues. For reference, Gemma4-31B (a dense model with all 31B params active) scores 17.4. Qwen3.6 scores 4x higher with 10x fewer active parameters.
51.5 on Terminal-Bench 2.0 — agentic terminal coding. It beats Qwen3.5-27B (41.6), its own predecessor Qwen3.5-35B-A3B (40.5), and even Gemma4-31B (42.9).
1397 Elo on QwenWebBench — frontend artifact generation. The predecessor scored 978. That's a 400+ Elo jump in one generation.
86.0 on GPQA Diamond — graduate-level science reasoning. Competitive with models many times its size.
Vision support — handles image-text-to-text tasks natively. MMMU score of 81.7, RealWorldQA at 85.3.

The full benchmark picture:

Benchmark	Qwen3.6-35B-A3B	Qwen3.5-35B-A3B	Gemma4-31B	Qwen3.5-27B
SWE-bench Verified	73.4	70.0	17.4	51.2
Terminal-Bench 2.0	51.5	40.5	42.9	41.6
SWE-bench Multilingual	75.0	67.2	69.3	60.3
QwenWebBench (Elo)	1397	978	1178	1197
NL2Repo	29.4	20.5	—	27.3
MCPMark	37.0	27.0	36.3	15.5
GPQA Diamond	86.0	84.2	84.3	85.5
MMMU	81.7	81.4	80.4	82.3

What's under the hood

This isn't just a bigger Qwen3.5. The architecture got meaningful upgrades:

Gated DeltaNet attention — 3 out of every 4 layers use linear attention (Gated DeltaNet) instead of standard attention. Only every 4th layer uses full Gated Attention. This makes it much more memory-efficient for long contexts.

256 experts, 9 active — 8 routed + 1 shared expert active per token. That's where the "35B total, 3B active" comes from. Most of the model sits idle while only the relevant experts fire.

Vision encoder built in — it's a true multimodal model (Image-Text-to-Text), not a text model with a bolted-on adapter.

Thinking Preservation — new feature that retains reasoning context from previous messages. Less overhead for iterative coding sessions.

262K native context — extensible beyond that.

Apache 2.0 license — fully open, commercial use allowed.

Hardware requirements

The beauty of MoE: your hardware only needs to handle the active parameters, not the total count.

Setup	VRAM needed	Expected speed
Q4_K_M quant	~6-8 GB	30+ tok/s on RTX 3060 12GB
Q8_0 quant	~12-14 GB	20+ tok/s on RTX 4070
FP8 (official)	~35 GB	RTX 4090 or A6000
FP16 full	~70 GB	Multi-GPU setup

If you can run a 7B model, you can run this. The 3B active parameter count is the number that matters for speed.

How to run it

Option 1: Ollama (easiest)

ollama run qwen3.6:35b-a3b

Wait for GGUFs to appear — usually within hours of release. Check HuggingFace for the latest quantized versions.

Option 2: vLLM

pip install vllm
vllm serve Qwen/Qwen3.6-35B-A3B --tensor-parallel-size 1

Option 3: Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.6-35B-A3B",
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.6-35B-A3B")

Option 4: Locally Uncensored (full GUI + model management)

If you want a clean desktop app that handles downloading, model management, and chatting in one place:

Grab Locally Uncensored — it's open source (AGPL-3.0)
v2.3.3 just shipped with day-0 Qwen3.6 support
Download the model directly from the app, pick your quantization, and start chatting
Vision works out of the box — drag and drop images into the chat
The new Codex mode with live streaming is particularly nice for coding tasks with this model

LU also has agent mode with 13 tools, remote access from your phone, and a bunch of other stuff that pairs well with an agentic model like this one.

Who should care

Local AI coders — if you use AI for coding and want to run it locally, this is now the best MoE option. 73.4 SWE-bench with 3B active params is absurd.
Privacy-focused devs — Apache 2.0, runs on consumer hardware, no data leaves your machine.
Multimodal users — built-in vision means one model for text AND image understanding.
Anyone running Qwen3.5-35B-A3B — this is a straight upgrade. Same architecture class, better everything.

The bottom line

Qwen3.6-35B-A3B is what happens when you optimize MoE properly. 3B active parameters shouldn't be this good, but here we are. The coding benchmarks in particular are hard to argue with — 73.4 on SWE-bench Verified puts it in the same league as much larger, closed-source models.

Weights are on HuggingFace. FP8 variant here. GGUFs incoming.

Locally Uncensored is an open-source desktop app for running AI models locally with full privacy. Handles model downloads, chat, coding agents, image generation, and more. AGPL-3.0 licensed.

How to Run GLM 4.7 Flash Locally with Ollama — 30B Quality at 3B Speed

David — Sun, 12 Apr 2026 13:28:13 +0000

ZhipuAI quietly dropped GLM 4.7 Flash and it's been blowing up — 830K+ downloads on HuggingFace, 1,600+ likes. The pitch: 30B-parameter MoE model with only 3B active parameters per token. Translation: you get 30B-class quality at the speed and VRAM cost of a 3B model.

The benchmarks back it up. AIME 25: 91.6% (beats GPT-class models). SWE-bench Verified: 59.2% (nearly 3x Qwen3-30B-A3B). And it's MIT licensed — commercial use, fine-tuning, whatever you want.

I've been building a local AI desktop app (Locally Uncensored) and just added GLM 4.7 support. Here's how to run it locally.

Install GLM 4.7 Flash with Ollama

One command:

ollama run glm4.7

That's it. Ollama handles the download and quantization. Default is Q4_K_M which gives you the best quality-to-size ratio.

If you want a specific quantization:

ollama run glm4.7:q4_k_m    # ~5 GB, recommended
ollama run glm4.7:q8_0      # ~10 GB, higher quality
ollama run glm4.7:q2_k      # ~3 GB, if VRAM is tight

Why GLM 4.7 Flash Matters

The MoE (Mixture of Experts) architecture is the key. The model has 30B total parameters but only activates 3B per token. This means:

Speed: Token generation is fast — comparable to running a 3B dense model
VRAM: Only needs 6-8 GB for Q4 quantization
Quality: Reasoning and coding performance matches models 10x its active size

Here's how it compares:

Benchmark	GLM 4.7 Flash (30B-A3B)	Qwen3-30B-A3B	GPT-OSS-20B
AIME 25	91.6	85.0	91.7
GPQA	75.2	73.4	71.5
SWE-bench Verified	59.2	22.0	34.0
τ²-Bench (agentic)	79.5	49.0	47.7
BrowseComp	42.8	2.29	28.3

The agentic benchmarks are insane. τ²-Bench at 79.5 vs Qwen3's 49.0 — that's not a marginal improvement, that's a different league. This model was built for tool calling and multi-step reasoning.

VRAM Requirements

Q2_K: ~3-4 GB VRAM (or CPU-only with 8 GB RAM)
Q4_K_M: 6-8 GB VRAM — the sweet spot
Q8_0: 10-12 GB VRAM — if you have the room
FP16: 20+ GB — only for research/fine-tuning

If you have a GTX 1660 (6 GB) or better, Q4_K_M runs comfortably. On Apple Silicon with 16 GB unified memory, it flies.

Agent Mode with GLM 4.7

This is where GLM 4.7 really shines. The model was specifically optimized for agentic tasks — it has a "Preserved Thinking" mode that keeps chain-of-thought reasoning active across multi-turn tool interactions.

In practice: you give it a tool (web search, file read, code execution) and it actually uses it intelligently. The 59.2% SWE-bench score means it can navigate real codebases, understand context, and produce working patches — not just toy completions.

In Locally Uncensored, GLM 4.7 is auto-detected as an agent-capable model. Enable Agent mode in the UI and it gets access to web search, file operations, and code execution out of the box.

GLM 4.7 vs the Competition

vs Qwen3-30B-A3B: Same architecture class (30B MoE, 3B active) but GLM 4.7 dominates on agentic and coding tasks. Qwen3 is better at pure math.

vs Gemma 4 E4B: Gemma 4 is smaller (4.5B effective) and faster, but GLM 4.7 has significantly better reasoning depth. If you need an agent that can handle complex multi-step tasks, GLM 4.7 wins.

vs Llama 3.3 70B: Llama needs 3-4x the VRAM for similar coding performance. GLM 4.7 is the efficiency play.

What's the Catch?

Honestly, not much:

Chinese-English bilingual — Trained on both, works great in both. If you only need English, it's still excellent.
Context window — Supports up to 128K tokens. More than enough for most use cases.
MIT license — Fully open. No restrictions on commercial use, modification, or redistribution.

The main caveat: if you want vision/multimodal, GLM 4.7 Flash is text-only. Look at GLM-4V or Gemma 4 for image input.

Try It

ollama run glm4.7

Or if you want a full desktop UI with agent mode, image gen, and A/B model comparison:

Locally Uncensored — free, open source, AGPL-3.0. Single .exe/.AppImage, no Docker needed. GLM 4.7 is in the recommended models list.

Running GLM 4.7 on your hardware? I'd love to hear your tok/s numbers and use case. Drop a comment.

Locally Uncensored — AGPL-3.0 licensed. GitHub.

we shipped a ComfyUI fix 12 hours after the bug report. here's what v2.3.1 changes.

David — Sat, 11 Apr 2026 12:29:24 +0000

v2.3.1 just dropped — small version number, big quality-of-life improvements.

in-app Ollama install

no more "go to ollama.com, download, install, restart". click Install Ollama in the onboarding wizard, watch the progress bar (with real download speed and elapsed time), done. silent install, auto-start, auto-detect. zero manual steps.

this is what "plug & play" should feel like.

configurable ComfyUI port & path

this one's a direct response to user feedback. ComfyUI recently moved from a browser-based interface to a desktop app — which uses a different port than the old default 8188.

result: LU couldn't find ComfyUI even though it was running. multiple users reported this in our GitHub Discussions within hours of v2.3.0.

v2.3.1 fix: the ComfyUI port is now fully configurable in Settings > ComfyUI (Image & Video). same for the path — editable with a Connect button. no need to go through onboarding again.

previously the port was hardcoded in 20+ places across the codebase. now it's a single config value.

ComfyUI install progress (actually works now)

the one-click ComfyUI install now shows real step-by-step progress:

Step 1/3: Clone repository
Step 2/3: Install PyTorch
Step 3/3: Install dependencies

with an elapsed timer. before this, the install screen got stuck at "Starting..." forever because the Rust backend thread never reported completion back to the frontend.

provider status that actually means something

the connection dots next to providers in Settings now show actual status:

🟢 green = connected and responding
🔴 red = connection failed
⚪ gray = not checked yet

before this they were always green. which is worse than showing nothing at all.

the bigger picture

v2.3.0 (yesterday) was the big feature release — ComfyUI plug & play, 20 model bundles, image-to-image, image-to-video on 6 GB VRAM.

v2.3.1 is the "we actually listen to our users" release. someone reported ComfyUI Desktop not connecting at 11pm, the fix shipped by noon next day.

if you tried v2.3.0 and ComfyUI didn't work — update and check Settings. the port config should fix it.

GitHub: PurpleDoubleD/locally-uncensored
Download: v2.3.1 Release

France is ditching Windows for Linux. your AI should be next.

David — Fri, 10 Apr 2026 16:54:35 +0000

France just announced they're migrating government systems from Windows to Linux to reduce dependence on US tech companies. This is a sovereign nation saying "we can't trust our infrastructure to foreign corporations."

Now apply the same logic to AI.

Every prompt you type into ChatGPT routes through OpenAI's servers in San Francisco. Every image you generate with Midjourney lives on their infrastructure. Every code snippet Copilot sees passes through Microsoft's cloud.

You're outsourcing your thinking to US corporations. And unlike Windows, where France at least had the source code available for audit — AI services are complete black boxes. You don't know what happens to your data, how long it's stored, who can access it, or whether it's used to train the next model.

The Local Alternative Exists Now

Two years ago, "run AI locally" meant a janky Python script talking to a quantized 7B model that could barely hold a conversation. That era is over.

Today's local stack:

Qwen 3.5 35B — matches GPT-4 on reasoning, 256K context, runs on 16 GB VRAM
Gemma 4 27B — Google's latest with native vision and tool calling
GLM 5.1 — 754B MoE, MIT license, leads SWE-Bench Pro. Released this week.
FLUX 2 Klein — text-to-image that rivals Midjourney, runs locally
FramePack F1 — image-to-video on 6 GB VRAM

All open-weight. All running on consumer hardware. No API keys, no subscriptions, no data leaving your network.

The Missing Piece Was Always the Frontend

The models exist. The backends exist (Ollama, vLLM, llama.cpp). What was missing was a unified frontend that doesn't require a PhD in YAML configuration to set up.

That's what I've been building. Locally Uncensored auto-detects 12 local backends, handles ComfyUI installation and model downloads with one click, and bundles chat, coding agent, and image/video generation into a single desktop app.

No Docker. No terminal commands. Install the .exe, launch it, the setup wizard handles everything.

Digital Sovereignty Isn't Just for Governments

France is making this move at the national level because they understand the risk. But individuals and companies face the same dependency problem.

When OpenAI changes their pricing — and they will — you're locked in. When Anthropic gets blacklisted by your government — it happened this week — your workflows break. When Midjourney decides your prompt violates their content policy — no appeal, no alternative, your subscription just becomes less useful.

Local AI has no terms of service. No content policy. No pricing changes. No government blacklists. The model runs on your hardware, and the only person who can restrict what it does is you.

Getting Started

curl -fsSL https://ollama.ai/install.sh | sh
ollama pull gemma4:27b

Five minutes. Then your AI is yours.

GitHub: PurpleDoubleD/locally-uncensored
License: AGPL-3.0

i cancelled ChatGPT, Midjourney, and Copilot. here's the $0/month stack that replaced all three.

David — Fri, 10 Apr 2026 16:53:27 +0000

ChatGPT Plus: $20/month. Midjourney: $10/month. GitHub Copilot: $10/month.

That's $480/year for AI tools that send every keystroke to someone else's server. I cancelled all three and replaced them with a local stack that costs nothing after the initial setup.

Here's exactly what I'm running.

Chat: Ollama + Qwen 3.5 (replaces ChatGPT)

Qwen 3.5 9B runs on 8 GB VRAM. Qwen 3.5 35B (MoE) runs on 16 GB with 256K context — longer than ChatGPT's 128K. It handles reasoning, analysis, writing, and code generation. For math and logic, it matches GPT-4o on most benchmarks.

Gemma 4 27B is the alternative if you want native vision (describe images, analyze screenshots) without an API call.

ollama pull qwen3.5:9b

Done. Running. Forever. No subscription.

Images: ComfyUI + FLUX (replaces Midjourney)

FLUX.1 Dev generates images that compete with Midjourney v6. FLUX 2 Klein is the newer, faster variant. Z-Image does uncensored generation — no "I can't generate that" refusals.

The catch with ComfyUI has always been setup complexity. Model files in the wrong folder, custom nodes breaking, workflow JSONs that don't load.

I built a wrapper that handles all of it. ComfyUI auto-detection, one-click install if it's missing, model bundles with one-click download, and a Dynamic Workflow Builder that constructs the correct pipeline based on what you have installed. You never touch a workflow JSON.

Code Agent: MCP Tools (replaces Copilot)

Not autocomplete — a full coding agent. It reads your project files, writes code, runs shell commands, executes tests, and iterates on errors. 13 MCP tools: file I/O, shell execution, web search, code execution, screenshots.

The difference from Copilot: it doesn't just suggest the next line. You say "add input validation to this form and write tests" and it reads the code, writes the validation, creates the test file, runs the tests, and fixes failures. Up to 20 tool iterations per task.

Works with any model. Native tool calling for Qwen, Gemma, Llama. XML fallback for everything else.

The App That Ties It Together

All of this runs through Locally Uncensored — one desktop app, one window, swap between chat, code agent, and image/video generation.

It auto-detects 12 local backends (Ollama, LM Studio, vLLM, KoboldCpp, etc.) and has 20+ cloud provider presets if you occasionally need a frontier model. A/B model comparison lets you test two models side by side with the same prompt.

Not Electron. Tauri v2 with a Rust backend. The app itself uses ~80 MB of RAM.

What I Lost

Honestly? Two things.

GPT-4's creative writing is still noticeably better than local models for fiction and marketing copy. For technical writing, code, and analysis — local models are equal or better.

Midjourney's aesthetic consistency across different prompts is hard to match locally. FLUX is technically more capable, but Midjourney has a "house style" that's effortlessly good. Locally, you need to dial in your prompts more carefully.

Everything else — speed, privacy, availability, cost — is better locally.

Monthly Cost Comparison

Service	Cloud	Local
Chat AI	$20/mo (ChatGPT Plus)	$0
Image Gen	$10/mo (Midjourney)	$0
Code Agent	$10/mo (Copilot)	$0
Total	$40/mo ($480/yr)	$0

Hardware requirement: a GPU with 8+ GB VRAM. If you have a gaming PC from the last 5 years, you probably already have one.

GitHub: PurpleDoubleD/locally-uncensored
License: AGPL-3.0 — fully open source, no telemetry, no cloud dependency.

the FBI can read your ChatGPT history. they can't read mine.

David — Fri, 10 Apr 2026 16:53:26 +0000

The FBI just retrieved deleted Signal messages through iPhone notification data. That was supposed to be the most private messenger available.

Your ChatGPT conversations? Those sit on OpenAI's servers. Subpoena-ready. Every prompt you've written, every document you've pasted, every code snippet you've shared. OpenAI's privacy policy explicitly states they can share data with law enforcement.

Same goes for Claude, Gemini, Copilot. Every cloud AI provider stores your conversations. Some for 30 days, some for "model improvement," some indefinitely. And when a court order arrives, they comply. They have to.

I stopped using cloud AI for anything that matters six months ago.

What I Actually Use

Everything runs on my machine. No server, no API calls, no conversation logs on someone else's infrastructure.

For text/chat: Ollama running Qwen 3.5 or Gemma 4. The model weights live on my SSD. The conversation exists in RAM while I'm using it, and nowhere else.

For code: A local coding agent with MCP tools — file read/write, shell execution, web search. It reads my codebase directly from disk. No code leaves my network.

For images: ComfyUI with FLUX and Z-Image. Prompts and generated images stay on my hard drive.

For video: FramePack F1 — image-to-video on 6 GB VRAM.

All of this runs through one app: Locally Uncensored. It auto-detects whatever backend you have installed, or walks you through setup if you have nothing. One desktop app, everything local.

The Real Cost of "Free" Cloud AI

People think ChatGPT Plus at $20/month is cheap. But the actual cost isn't money — it's that every conversation becomes training data, legal evidence, and a data breach waiting to happen.

The Mistral breach just exposed internal data. OpenAI employees have warned about internal security practices. Anthropic got blacklisted by the US government. Disney just cancelled a billion-dollar OpenAI deal over trust concerns.

These aren't hypothetical risks. They're this week's headlines.

The Local Setup Is Easier Than You Think

Five years ago, running AI locally meant compiling CUDA kernels and hand-editing config files. Today:

Install Ollama (one command)
Pull a model: ollama pull qwen3.5:9b
Open Locally Uncensored, it auto-detects Ollama
Chat, code, generate — everything stays on your machine

Total time: under 10 minutes. Total recurring cost: $0. Total data sent to the cloud: zero bytes.

No, Local Models Aren't "Worse"

Qwen 3.5 35B matches GPT-4 on most benchmarks. Gemma 4 27B has native vision and tool calling. GLM 5.1 (754B, MIT license, released this week) leads SWE-Bench Pro.

The "cloud models are better" argument made sense in 2023. In 2026, it's marketing.

GitHub: PurpleDoubleD/locally-uncensored — AGPL-3.0, Tauri v2, no telemetry.

OpenAI just mass-unsubscribed paying users — the case for running AI locally

David — Fri, 10 Apr 2026 10:41:28 +0000

Yesterday, thousands of ChatGPT Plus and Pro subscribers woke up to find their paid accounts downgraded to free tier — mid-work, mid-exam, mid-project. OpenAI confirmed it was a billing bug and said they're working on it, but offered no timeline and no mention of refunds.

Around the same time, Sam Altman publicly admitted that the viral GPT-4o image generation feature "broke" their GPUs. Free-tier users saw image generation disappear entirely. Paid users experienced multi-minute generation times where it had been instant the day before.

This isn't the first time. And it won't be the last.

what actually happened

The 4o image generation update went massively viral — everyone was making Ghibli-style portraits, editing product photos, creating memes. The demand overwhelmed OpenAI's infrastructure to the point where:

Billing systems broke, mass-downgrading paying customers
GPU capacity was exhausted, degrading service for everyone
Free tier access was pulled, with users calling it a "bait-and-switch"
Multiple users reported losing 60-90 minutes of paid access during work deadlines

The r/ChatGPT thread about the mass-unsubscription has 488+ comments. People are frustrated.

meanwhile, in the local AI world

On the same day this was happening, the local LLM community was busy doing their own thing — running models on their own hardware with zero downtime. No billing bugs. No GPU shortages. No service degradation.

Here's what the local AI landscape looks like right now:

Text/Chat models you can run locally:

Llama 3 — Meta's latest, runs great on consumer GPUs
Mistral — just committed to always releasing open models alongside commercial ones
Phi-4 — Microsoft's new reasoning model (though r/LocalLLaMA is roasting it for being over-censored — the irony of an open model with closed guardrails)
Qwen 2.5 — Alibaba's strong multilingual models
Gemma 3 — Google's compact open models

Image generation locally:

Stable Diffusion / SDXL / Flux — the OG local image gen
ComfyUI — node-based workflow editor, incredibly flexible
Fooocus — simple Midjourney-like interface, runs on 6GB VRAM

Tools to run them:

Ollama — dead simple CLI for running LLMs locally
LM Studio — nice GUI, one-click model downloads
Open WebUI — ChatGPT-like web interface for local models
Locally Uncensored — all-in-one app bundling chat, image gen, and video gen with no Docker needed
Jan — offline-first desktop app

the actual tradeoff

Let's be honest: local models aren't as good as GPT-4o at everything. The frontier cloud models still lead in complex reasoning and multimodal tasks.

But here's what you get by running locally:

100% uptime — your GPU doesn't have billing bugs
No subscription fees — one-time hardware cost, then it's free forever
Complete privacy — your data never leaves your machine
No censorship surprises — you control the guardrails
No "bait-and-switch" — features don't disappear because a company overprovisioned

For most daily tasks — writing, brainstorming, code assistance, image generation, summarization — a 7B or 14B parameter model running locally is more than enough.

the real question

Every time a cloud AI service goes down, the same conversation happens: "maybe I should run this stuff locally." Then the service comes back up and everyone forgets.

But the gap is closing fast. Local models are getting better every month. The tooling is getting simpler. A decent GPU from 2-3 years ago can run surprisingly capable models.

Maybe this time it's worth actually trying it.

If you want to get started, Ollama is probably the easiest entry point. Install it, run ollama run llama3, and you've got a local chatbot in 30 seconds. For image generation, ComfyUI or Fooocus are solid choices. And if you want everything in one package, Locally Uncensored bundles chat + image gen + video gen with a simple installer.

i generated AI video on a GTX 1660. here's what it actually takes.

David — Fri, 10 Apr 2026 10:17:54 +0000

A few weeks ago, generating video from a single image required either a cloud API with per-second billing, or a GPU with 24+ GB VRAM. FramePack changed that.

FramePack F1 generates video from a single image on 6 GB VRAM. That's a GTX 1660, an RTX 3060, or basically any GPU sold in the last 5 years. I've been running it locally and the results are genuinely usable — not "proof of concept" usable, but "I'd actually put this in a project" usable.

Here's what's actually involved, because "runs on 6 GB VRAM" doesn't tell the whole story.

What You're Actually Downloading

FramePack isn't one file. It's a pipeline with five components, and you need all of them:

Component	Size	What It Does
FramePack F1 I2V Model (FP8)	13 GB	The core diffusion model — generates video frames
LLaVA LLaMA3 Text Encoder (FP8)	8.5 GB	Understands your text prompt
HunyuanVideo VAE	2.3 GB	Encodes your input image to latent space, decodes generated frames back to pixels
SigCLIP Vision Encoder	900 MB	Understands the content of your input image
CLIP-L Text Encoder	240 MB	Additional text understanding (shared with HunyuanVideo)

Total download: ~25 GB. Plus you need ComfyUI installed and the ComfyUI-FramePackWrapper custom nodes from Kijai.

So yeah — the model fits in 6 GB VRAM, but your hard drive needs 25 GB and the initial download takes a while.

Why 6 GB VRAM Works

Most video generation models load everything into VRAM at once. A 14B parameter model at FP16 needs ~28 GB just for the weights. That's why Wan 2.1 14B needs a 3090 or better.

FramePack uses next-frame prediction. Instead of generating all frames simultaneously, it generates one frame at a time, keeping only what it needs in memory. The model itself is 13 GB on disk but the FP8 quantization and frame-by-frame approach mean it peaks around 6 GB of VRAM usage.

The trade-off is speed. Generating a 3-second clip takes several minutes on a mid-range GPU. On a high-end card it's faster, but it's never going to be real-time. The architecture is optimized for memory, not throughput.

What It Uses Under the Hood

FramePack F1 is built on the HunyuanVideo backbone. That's why it shares components with HunyuanVideo (the VAE, CLIP-L encoder). The pipeline works like this:

SigCLIP Vision Encoder looks at your input image and creates visual embeddings — a numerical representation of what's in the image
DualCLIPLoader loads both text encoders (CLIP-L + LLaVA LLaMA3) to process your text prompt
VAE encodes your input image into latent space
FramePackSampler takes the image latent, vision embeddings, and text conditioning, then generates video frames one at a time using next-frame prediction
VAE decodes the generated latent frames back into actual pixels

The sampler has a gpu_memory_preservation parameter set to 6.0 GB by default — it actively manages memory to stay within that budget.

What the Results Look Like

FramePack does motion from a still image. Give it a photo of a person and it'll add natural movement — head turns, blinking, subtle body motion. Give it a landscape and it'll add wind, clouds, water flow.

It's strongest with:

Portraits and people — natural micro-movements
Nature scenes — wind, water, atmospheric effects
Simple compositions — one clear subject against a background

It struggles with:

Complex multi-person scenes — tracking gets confused
Fast action — it's tuned for gentle, natural motion
Long durations — quality degrades after ~4 seconds

The output resolution follows your input image. Feed it a 512x768 portrait, you get a 512x768 video.

Running It

If you want to set this up manually: install ComfyUI, clone the FramePackWrapper custom nodes, download all five model files to the correct ComfyUI subdirectories, build a workflow connecting all the nodes in the right order, and pray nothing conflicts with your existing setup.

Or — and this is what I built — Locally Uncensored handles the entire pipeline. Open the Create tab, pick the FramePack bundle, one-click download all five components, upload an image, write what motion you want, generate. The app builds the correct workflow automatically.

It also does text-to-image, image-to-image, and text-to-video with other models (Wan 2.1, CogVideoX, FLUX, SDXL). ComfyUI gets auto-detected or one-click installed. Open source, AGPL-3.0.

The Honest Take

6 GB VRAM video generation is real, and it works. But let's not pretend it's magic:

25 GB download before you generate anything
Several minutes per clip on mid-range hardware
3-4 seconds of usable output per generation
Quality varies — some images animate beautifully, others look weird

It's a tool for specific use cases, not a replacement for cloud video gen services. But for those use cases — quick social media content, animated product shots, bringing concept art to life — running it locally for free on a GPU you already own is genuinely compelling.

GitHub: PurpleDoubleD/locally-uncensored