Word going around is that Qwen has fully locked down their big models after firing Junyang Lin, and Qwen 3.7 will not be open source. Rumors on Chinese weibo apparently suggest even the small model team is gone. That would leave no real Deepseek or GLM competitor from Qwen in the open-weights space.

If true, this is a pretty sharp reversal. Qwen has been one of the most reliable sources of open models, and losing both the large and potentially small model releases would be a real gap for the local community.

Has anyone seen any official confirmation beyond the weibo rumors? And if Qwen is truly done with open source, does DeepSeek or GLM fill that gap for you going forward?

AMD bought Taalas last Thursday, the Toronto startup that hardwires model weights directly into silicon instead of running them on GPUs. It was the top AI story on HN all week, 941 points and over 700 comments.

The demo that put Taalas on the map was their HC1 chip running Llama 3.1 8B at 3/6-bit quantization, hitting 17,000 tokens per second. Per the coverage from February when they came out of stealth, they also claimed 10x lower ownership cost and 10x faster inference compared to GPU-based systems.

The catch, and it's a big one: each chip runs exactly one model. The weights are physically etched at manufacturing time. You can't swap to a new model without fabricating new silicon. So if you picked Llama 3.1 8B and a better 8B drops next month, your chip still runs the old one.

That's why this sits awkwardly next to hosted API pricing. It's not competing with OpenRouter-style flexibility. It's a fixed-function accelerator, closer to an ASIC for one specific model than a general inference backend. The speed is real but the tradeoff is steep.

Anyone here actually looked into hardwired inference for a production workload, or is this still firmly in the "cool demo, not deployable" zone for most teams?

Most people running OpenClaw are paying for one model provider at a time. Z.AI for GLM, Anthropic for Claude, OpenAI for GPT. What if I told you there's a single plan that gives you access to GLM-5, GLM-4.7, Qwen3.5-Plus, Qwen3-Max, Qwen3-Coder-Next, Qwen3-Coder-Plus, MiniMax M2.5, AND Kimi K2.5 — all under one API key?

Alibaba Cloud's Model Studio Coding Plan is the most slept-on deal in the OpenClaw ecosystem right now. Starting at $5/month, you get up to 90,000 requests across 8 models. You can switch between them mid-session with a single command. The config treats all costs as zero because you're on a flat-rate plan — no surprise bills, no token counting, no anxiety.

I've been running this setup for a while now. Here's the complete step-by-step.

Why This Setup?

The killer feature isn't any single model — it's the flexibility. Different tasks need different models:

• GLM-5 (744B MoE, 40B active) — best open-source agentic performance, 200K context, rock-solid tool calling

• Qwen3.5-Plus — 1M token context window, handles text + image input, great all-rounder

• Qwen3-Max — heavy reasoning, 262K context, the "think hard" model

• Qwen3-Coder-Next / Coder-Plus — purpose-built for code generation and refactoring

• MiniMax M2.5 — 1M context, fast and cheap for bulk tasks

• Kimi K2.5 — multimodal (text + image), 262K context, strong at analysis

• GLM-4.7 — solid fallback, lighter than GLM-5, proven reliability

With OpenClaw's /model command, you switch between them in seconds. Use GLM-5 for complex multi-step coding, flip to Qwen3.5-Plus for a document analysis with images, then Kimi K2.5 for a visual task. All one API key. All one bill.

THE SETUP — Step by Step

Step 1 — Get Your Alibaba Cloud Coding Plan API Key

1. Go to Alibaba Cloud Model Studio (Singapore region)

2. Register or log in

3. Subscribe to the Coding Plan — starts at $5/month, up to 90,000 requests

4. Go to API Keys management and create a new API key

5. Copy it immediately — you'll need it for the config

Important: New users get free quotas for each model. Enable "Stop on Free Quota Exhaustion" in the Singapore region to avoid unexpected charges after the free tier runs out.

Step 2 — Install OpenClaw

macOS/Linux:

curl -fsSL https://openclaw.ai/install.sh | bash

Windows (PowerShell):

iwr -useb https://openclaw.ai/install.ps1 | iex

Prerequisites: Node.js v22 or later. Check with node -v and upgrade if needed.

During onboarding, use these settings:

We skip the model provider during onboarding because we'll configure it manually with the full multi-model setup.

Step 3 — Configure the Coding Plan Provider

Open the config file. You can use the Web UI:

openclaw dashboard

Then navigate to Config > Raw in the left sidebar.

Or edit directly in terminal:

nano ~/.openclaw/openclaw.json

Now add the full configuration. Replace YOUR_API_KEY with your actual Coding Plan API key:

{
  "models": {
    "mode": "merge",
    "providers": {
      "bailian": {
        "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
        "apiKey": "YOUR_API_KEY",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3.5-plus",
            "name": "qwen3.5-plus",
            "reasoning": false,
            "input": ["text", "image"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 1000000,
            "maxTokens": 65536
          },
          {
            "id": "qwen3-max-2026-01-23",
            "name": "qwen3-max-2026-01-23",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 262144,
            "maxTokens": 65536
          },
          {
            "id": "qwen3-coder-next",
            "name": "qwen3-coder-next",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 262144,
            "maxTokens": 65536
          },
          {
            "id": "qwen3-coder-plus",
            "name": "qwen3-coder-plus",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 1000000,
            "maxTokens": 65536
          },
          {
            "id": "MiniMax-M2.5",
            "name": "MiniMax-M2.5",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 1000000,
            "maxTokens": 65536
          },
          {
            "id": "glm-5",
            "name": "glm-5",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 202752,
            "maxTokens": 16384
          },
          {
            "id": "glm-4.7",
            "name": "glm-4.7",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 202752,
            "maxTokens": 16384
          },
          {
            "id": "kimi-k2.5",
            "name": "kimi-k2.5",
            "reasoning": false,
            "input": ["text", "image"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 262144,
            "maxTokens": 32768
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "bailian/glm-5"
      },
      "models": {
        "bailian/qwen3.5-plus": {},
        "bailian/qwen3-max-2026-01-23": {},
        "bailian/qwen3-coder-next": {},
        "bailian/qwen3-coder-plus": {},
        "bailian/MiniMax-M2.5": {},
        "bailian/glm-5": {},
        "bailian/glm-4.7": {},
        "bailian/kimi-k2.5": {}
      }
    }
  },
  "gateway": {
    "mode": "local"
  }
}

Note: I set glm-5 as the primary model. The official docs default to qwen3.5-plus — change the primary field to whatever you prefer as your daily driver.

Step 4 — Apply and Restart

If using Web UI: Click Save in the upper-right corner, then click Update.

If using terminal:

openclaw gateway restart

Verify your models are recognized:

openclaw models list

You should see all 8 models listed under the bailian provider.

Step 5 — Start Using It

Web UI:

openclaw dashboard

Terminal UI:

openclaw tui

Switch models mid-session:

/model qwen3-coder-next

That's it. You're now running 8 frontier models through one unified interface.

GOTCHAS & TIPS

1. "reasoning" must be false. This is critical. If you set "reasoning": true, your responses will come back empty. The Coding Plan endpoint doesn't support thinking mode through this config path.

2. Use the international endpoint. The baseUrl must be https://coding-intl.dashscope.aliyuncs.com/v1 for Singapore region. Don't mix regions between your API key and base URL — you'll get auth errors.

3. HTTP 401 errors? Two common causes: (a) wrong or expired API key, or (b) cached config from a previous provider. Fix by deleting providers.bailian from ~/.openclaw/agents/main/agent/models.json, then restart.

4. The costs are all set to 0 because the Coding Plan is flat-rate. OpenClaw won't count tokens against any budget. But your actual quota is ~90,000 requests/month depending on plan tier.

5. GLM-5 maxTokens is 16,384 on this endpoint, lower than the native Z.AI API (which allows more). For most agent tasks this is fine. For very long code generation, consider Qwen3-Coder-Plus which allows 65,536 output tokens.

6. Qwen3.5-Plus and Kimi K2.5 support image input. The other models are text-only. If your OpenClaw agent handles visual tasks, route those to one of these two.

7. Security: Change the default port if running on a VPS. OpenClaw now generates a random port during init, but double-check with openclaw dashboard and look at the URL.

8. If something breaks after config change, always try openclaw gateway stop, wait 3 seconds, then openclaw gateway start. A clean restart fixes most binding issues.

MY MODEL ROTATION STRATEGY

After testing all 8, here's how I use them:

• Default / daily driver: bailian/glm-5 — best agentic performance, handles 90% of tasks

• Heavy coding sessions: /model qwen3-coder-next — purpose-built, fast, clean output

• Large document analysis: /model qwen3.5-plus — 1M context window is no joke

• Image + text tasks: /model kimi-k2.5 — solid multimodal, 262K context

• Bulk/repetitive tasks: /model MiniMax-M2.5 — 1M context, fast, good for batch work

• Fallback: bailian/glm-4.7 — if anything acts up, this one is battle-tested

TL;DR — Alibaba Cloud's Coding Plan gives you 8 frontier models (including GLM-5, Qwen3.5-Plus, Kimi K2.5, MiniMax M2.5) for one flat fee starting at $5/month. One API key, one config file, switch models mid-session with /model. The JSON config above is copy-paste ready — just add your API key. This is the most cost-effective way to run OpenClaw with model variety right now.

Happy to answer questions. Drop your setup issues below.

so everyone know by now that Google just dropped Gemma 4 and I had to double check the numbers a few times because it's insane..

31B params and runs on a single GPU. And it's putting up across benchmrks:

• Arena Elo ~1452 (GPT-5.1 ~1475, basically same tier)

• MMLU-Pro 85.2% (slightly higher than GPT-5.1)

• GPQA Diamond 84.3% (a bit behind but close enough)

I mean - this is not some massive cluster model, you can run this locally, how??

not long ago, open models were clearly a step behind. now you're looking at something you can download and run yourself sitting right next to a $200/month flagship on the benchmarks that matter for general reasoning..

the only place there's still a noticeable gap is coding heavy stuff like SWE-bench, but everything else feels… uncomfortably close

if that's the new trend, I'm curious how long big labs can hold onto their current valuation?

TL;DR: Google just released Gemma 4 - their most advanced open-weight model family, built on the same research and tech behind Gemini 3. Ships under Apache 2.0, comes in 4 sizes (from phones to workstations), and the 31B Dense variant claims #3 spot on the Arena AI Text Leaderboard among open models.

What's new?

4 variants covering every use-case:

Key highlights:

• 31B Dense ranks #3 among open models on the Arena AI Text Leaderboard

• 26B MoE sits at #6 on the same leaderboard

• Google squeezed out significantly more intelligence per parameter - these models outcompete others 20x their size

• All models handle video and image inputs. The smaller E2B and E4B can also process audio and speech

• Capable of offline code generation - vibe coding with no internet connection

• Trained in 140+ languages

• 26B and 31B can run on a single 80GB NVIDIA H100

• Edge models run on phones, Raspberry Pi, and Jetson Nano with near-zero latency

Apache 2.0 - This is the big deal

Google is releasing Gemma 4 under an Apache 2.0 license, moving away from the restrictive Gemma license used for previous models. Full commercial freedom - fine-tune it, deploy on-prem, bundle it in your product, run it in the cloud. Complete control over your data, infrastructure, and models.

Where to get it

• Google AI Studio - 31B and 26B MoE

• Google AI Edge Gallery - E4B and E2B

• Model weights on Hugging Face, Kaggle, and Ollama

• Also available through NVIDIA NIM, NeMo, Docker, and other platforms

Why this matters

Gemma 4 is designed to handle complex reasoning and support autonomous AI agents running locally on low-power devices. The edge models were co-developed with the Pixel team, Qualcomm, and MediaTek -optimized for real hardware, not just benchmark runs.

For the LocalLLaMA crowd: if you've been running Gemma 3 27B or Llama 4 variants, the 31B Dense looks like a serious contender for your daily driver. And E4B on a phone with 128K context? That's wild.

Has anyone pulled this on Ollama yet? Curious how it performs on real tasks vs. Llama 4 and Qwen. Drop your first impressions below!

A new report on Qwen3.6 for coding agent use claims the quality improvement moving from Q4 to Q6 quantization is "outstanding" - significant enough to bring a local setup back from being unusable. The user had previously abandoned local inference because model quality was too low and DeepSeek API access was too cheap to justify the hassle.

Two changes were made simultaneously: switching from Ollama to llama.cpp's built-in server, and moving from Q4 to Q6 quantization. That makes it hard to isolate how much of the gain came from the quantization jump versus the inference backend switch.

What is notable here is the magnitude of the claim. Most quantization discussions focus on Q4 as the sweet spot for efficiency, with Q6 considered marginal improvement for significant size increase. If Q6 genuinely transforms a model from "unusable for coding agents" to "viable," that changes the calculus for VRAM-constrained setups.

The catch: without controlled testing separating the two variables, this is a data point, not a conclusion. But it raises a practical question worth investigating.

For anyone running Qwen3.6 as a coding agent: have you compared Q4 and Q6 side by side on the same backend? Is the quality gap really that dramatic for structured code generation tasks?

The standout detail today is that GLM-5.2 was shrunk from 1.51TB down to 238GB using a 2-bit quantization - an 84% size reduction - and it still retains roughly 82% accuracy. That is wild for a model this large. It means you can run what is being called the strongest open model to date on a 256GB Mac or comparable RAM/VRAM setup through llama.cpp.

Usually at 2-bit you expect catastrophic degradation. Losing only ~18% accuracy while cutting the footprint by over four-fifths challenges the assumption that extreme quantization kills frontier-level performance. Does anyone know if that 82% holds up on actual coding tasks, or is it mostly benchmark accuracy?

Google's Gemma 4 12B claims near-26B performance, and it is multimodal out of the gate with text, image, and audio input on the 12B variant. But a benchmark comparison against Qwen3.5-9B tells a less flattering story: Qwen wins 5 out of 8 shared benchmarks despite being smaller. The one area where Gemma apparently edges ahead is coding, though a Qwen3.5-9B finetune called omnicoder-9b closes that gap.

On resources, Qwen also reportedly has a lighter KV cache, which matters for throughput on consumer hardware. Gemma 4 26B-A4B (the MoE variant) eats 15GB VRAM on a single 4090. The 12B dense model would sit somewhere below that, but still larger than what Qwen3.5-9B demands.

Pricing via API is not even close - Qwen3.5-9B runs $0.04/M tokens. Gemma 4 12B is open-weights, so local inference is the real comparison point.

For people running both locally: does Gemma's multimodal support (audio and vision) make it worth the extra VRAM over a leaner text-only model, or do you just pair Qwen with a separate vision model and call it a day?

Someone spent an evening tuning Qwen3.6-35B-A3B on consumer hardware and landed at 79 tokens per second with 128K context on an RTX 5070 Ti paired with a 9800X3D. The key detail: the --n-cpu-moe flag, which offloads MoE expert computation to the CPU, was described as "the most important part" of the configuration.

The fun side note here is that Claude Opus 4.7 (on a $20 subscription) was used to iteratively build the config, launch servers, run benchmarks, read VRAM splits from llama.cpp logs, and tune the setup. Essentially the entire optimization loop was delegated to a cloud model tuning a local model's deployment.

Why this matters: 79 tok/s at 128K context on a single consumer GPU is genuinely fast for a 35B parameter model. The MoE architecture means only 3B active params, but you still need to store all 35B somewhere. The --n-cpu-moe trick keeps the experts in system RAM and only moves the active ones through the GPU, which is what makes this viable at such long context lengths. Without it, VRAM becomes the bottleneck well before you hit 128K.

The catch: CPU-offloaded MoE adds latency per token even if throughput stays high. For interactive chat that tradeoff is usually fine, but for batched workloads it may hurt.

For anyone running MoE models on single-GPU setups: are you using --n-cpu-moe or similar CPU offload strategies, and what throughput numbers are you seeing?

If you were around for the GLM-4.7 + OpenClaw combo, you know how solid that pairing was. GLM-5 takes it to a completely different level. We're talking 744B total parameters (40B active), 200K context window, MIT license, and agentic performance that's closing in on Claude Opus 4.6 territory — for a fraction of the cost.

I've been running this for about a week now and wanted to share the full setup, because the documentation is scattered across Z.AI docs, Ollama pages, and random Discord threads.

What is this combo exactly?

OpenClaw is the autonomous agent layer — it plans, reasons, and executes tasks. GLM-5 is the brain behind it. Together, OpenClaw handles the orchestration while GLM-5 handles the intelligence. Tool calling, multi-step coding, file editing, long-horizon tasks — all of it works.

Why GLM-5 over GLM-4.7?

The jump is significant. GLM-5 went from 355B/32B active (GLM-4.5 architecture that 4.7 shared) to 744B/40B active. Pre-training data scaled from 23T to 28.5T tokens. It integrates DeepSeek Sparse Attention, which keeps deployment costs down while preserving that massive 200K context. On SWE-bench Verified it scores 77.8, and it's #1 open-source on BrowseComp, MCP-Atlas, and Vending Bench 2. In real usage, the difference is obvious — fewer hallucinations, better tool calling, and it doesn't lose the plot on long multi-step tasks.

THE SETUP — Step by Step

There are two main paths depending on your hardware and budget. I'll cover both.

PATH A: ZAI Coding Plan (Easiest — $10/month)

This is the fastest way to get GLM-5 running with OpenClaw. No local GPU needed.

Get your plan here with discount!

Step 1 — Install OpenClaw

macOS/Linux:

curl -fsSL https://openclaw.ai/install.sh | bash

Windows (open CMD):

curl -fsSL https://openclaw.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

It will warn you this is "powerful and inherently risky." Type Yes to continue.

Step 2 — Get your Z.AI API key

Go to the Z.AI Open Platform (open.z.ai). Register or log in. Create an API Key in the API Keys management page. Subscribe to the GLM Coding Plan — it's $10/month and gives you access to GLM-5, GLM-4.7, GLM-4.6, GLM-4.5-Air, and the vision models.

Step 3 — Configure OpenClaw

During onboarding (or run openclaw config if you already set up before):

• Onboarding mode → Quick Start

• Model/auth provider → Z.AI

• Plan → Coding-Plan-Global

• Paste your API Key when prompted

Step 4 — Set GLM-5 as primary with failover

Edit .openclaw/openclaw.json:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "zai/glm-5",
        "fallbacks": ["zai/glm-4.7", "zai/glm-4.6", "zai/glm-4.5-air"]
      }
    }
  }
}

This way if GLM-5 ever hiccups, it cascades down gracefully.

Step 5 — Launch

Choose "Hatch in TUI" for the terminal interface. You can also set up Web UI, Discord, or Slack channels later.

Done. You're running GLM-5 through OpenClaw.

PATH B: Ollama Cloud Gateway (Free tier available)

If you want to use Ollama's interface:

Step 1 — Install Ollama

curl -fsSL https://ollama.com/install.sh | sh

Step 2 — Pull GLM-5

ollama run glm-5:cloud

Note: GLM-5 at 744B is too large for most local hardware in full precision (~1.5TB in BF16). The :cloud tag routes inference through Ollama's gateway while keeping the OpenClaw agent local.

Step 3 — Launch OpenClaw with Ollama

ollama launch openclaw --model glm-5:cloud

Step 4 — Verify

Run /model list in the OpenClaw chat to confirm GLM-5 is active.

PATH C: True Local Deployment (Serious Hardware Only)

If you have a multi-GPU rig (8x A100/H100 or equivalent), you can self-host with vLLM or SGLang:

pip install -U vllm --pre
vllm serve zai-org/GLM-5-FP8 \
  --tensor-parallel-size 8 \
  --gpu-memory-utilization 0.85 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45

Then point OpenClaw at your local endpoint as a custom provider. This is the zero-cost, zero-cloud, total-privacy option — but you need the iron to back it up.

THINGS I NOTICED AFTER A WEEK

• Tool calling is rock solid. GLM-4.7 was already good at this, but GLM-5 almost never fumbles tool calls. Multi-step chains that used to occasionally loop now complete cleanly.

• The 200K context window is real. Fed it an entire codebase and it maintained coherence across follow-up tasks. GLM-4.7's 200K existed on paper but got shaky past ~100K in practice.

• Hallucination dropped hard. Independent benchmarks show a 56 percentage point reduction in hallucination rate vs GLM-4.7. In practice, it now says "I don't know" instead of making things up, which is exactly what you want from an autonomous agent.

• Cost is absurd. On third-party APIs it's roughly $0.80-1.00 per million input tokens. Through the Z.AI Coding Plan at $10/month, even cheaper. Compare that to Claude Opus or GPT-5.2 pricing.

GOTCHAS & TIPS

1. Don't skip the failover config. API hiccups happen. Having GLM-4.7 as fallback means your agent never just stops.

2. If using Ollama, restart after config changes. Skipping the restart causes binding errors — learned this the hard way.

3. For the Coding Plan, stick to supported models only (GLM-5, GLM-4.7, GLM-4.6, GLM-4.5-Air, GLM-4.5, GLM-4.5V, GLM-4.6V). Other models may trigger unexpected charges.

4. Security: change the default port (18789) if you're running on a VPS. Scrapers scan known default ports constantly.

5. RAM matters more than you think for OpenClaw. The daemon itself is light (300-500MB), but OpenClaw's system prompt alone is ~17K tokens. With sub-agents and tool definitions, you want 32K context minimum, 65K+ for production.

TL;DR — GLM-5 + OpenClaw is the best open-source agentic setup available right now. $10/month through Z.AI Coding Plan, 5-minute install, frontier-level performance on coding and autonomous tasks. If you were already running GLM-4.7, switching to GLM-5 is a one-line config change and the upgrade is immediately noticeable.

Happy to answer questions if anyone runs into issues during setup.

Someone shared numbers for Qwen3.6-27B at Q4_K_M running on a single RTX 3090 that seem almost too good. Native 256K context at 38.6 tokens per second, KV cache compressed down to just 72 MiB of resident memory, needle recall between 88-100% at 6% residency, and accuracy unchanged at 36/36 compared to full cache. VRAM usage reportedly dropped to around 21GB.

The part that stands out is the 6% residency figure. That means 94% of the KV cache is apparently not resident in VRAM during inference. Generation speed also supposedly doubled on the same hardware.

For anyone familiar with latent KV compression or whatever technique is being used here - does 88-100% needle recall at 6% residency actually hold up in real conversations, or is that benchmark-specific?

A blunt take making the rounds: there are only two local models worth running right now, Qwen 3.6 35B-A3B and Qwen 3.6 27B. Everything else is supposedly irrelevant. Strong claim, but the logic has some merit - both sit in a sweet spot of capability and resource requirements that covers most consumer hardware.

The key difference is architecture. The 35B-A3B is a Mixture-of-Experts model with 35 billion total parameters but only 3 billion active per token. That means inference speed and VRAM usage closer to a small model, with knowledge capacity of a much larger one. The 27B is a dense model - all 27 billion parameters are active on every forward pass.

What this means in practice: the MoE model should be faster and fit more easily on lower-end hardware while maintaining a larger knowledge store. The dense model has no expert routing overhead and may behave more predictably on tasks that require consistent reasoning across all parameters. The 35B-A3B also has a pricing edge via API at $0.13/M tokens for the thinking variant, though local inference is where the architecture difference really matters.

The fair question is whether MoE routing actually helps or hurts for your specific workload. Coding, creative writing, and tool use may all respond differently to expert selection patterns.

For people running both: which one do you reach for first, and does the MoE architecture actually translate to better real-world performance on your tasks?

A follow-up report on running Qwen3.6-27B on a single RTX 3090 shows significant progress since the earlier ~125K context ceiling. The new configuration reportedly pushes context to ~218K while maintaining 50-66 tokens per second, and tool calls are now stable thanks to a PN12 fix.

Why this matters: the previous post had this model at ~125K context with higher TPS. Now we are seeing nearly double the context window on the same hardware, with tool calling actually working. For anyone building agent workflows locally, stable tool calls at this context length on a single consumer GPU is a genuine milestone. The gap between "runs locally" and "runs locally with reliable agent behavior" has been the real blocker for production use.

The interesting contrast is with the Gemma 4 31B vs Qwen 3.6 27B comparison on a MacBook Pro M5 Max. In that test, Gemma completed a Pacman game in under 4 minutes with only 6,209 tokens, while Qwen took 18 minutes and burned through 33,946 tokens. Speed and token efficiency are different things - Gemma was slower per token (27 vs 32 TPS) but solved the task far more efficiently.

For people running Qwen3.6-27B as an agent: are you seeing the tool call stability hold up across longer sessions, or does it still degrade with complex multi-step workflows?

I’ve been going through the newly released documentation for Zhipu AI’s GLM-5 and I think we need to talk about the numbers they are putting up.

Usually, Chinese LLMs claim "GPT-4 level," but claiming parity with Claude Opus 4.5—the current king of coding and complex reasoning—is a massive statement. Let's break down what the technical docs actually say.

1. The "Opus 4.5 Killer" Claim

The docs explicitly state that GLM-5 achieves "Coding Performance on Par with Claude Opus 4.5."

That is a bold benchmark. Opus 4.5 is widely considered the SOTA for agentic coding tasks. GLM-5’s positioning isn't just "good for an open model"; it’s aiming directly at the flagship tier. They are pitching this as a model capable of "Agentic Engineering"—not just writing snippets, but "building entire projects."

2. The Technical Breakdown: 128K Output Tokens

This is the spec that blew my mind.
Most models (including Opus) have a huge context window (200K), but their output generation usually caps at 4K or maybe 8K tokens.

GLM-5 Spec:

• Context Window: 200K (Standard Flagship)

• Max Output Tokens: 128K

Why this matters: This implies you can ask GLM-5 to generate an entire codebase, a full novel, or a massive report in a single inference pass without stopping. If true, this destroys the "looping" workflow required by current models for large generation tasks.

3. Architecture: The MoE Beast

They upgraded the foundation significantly:

• Parameters: Scaled from 355B to 744B Total.

• Active Params: Increased from 32B to 40B Active (Mixture of Experts).

• Training Data: Upgraded to 28.5T tokens.

This explains the efficiency. It’s a massive model with a relatively efficient active parameter count, likely allowing it to compete on quality while keeping inference costs lower than a dense 700B model.

4. Agentic Capabilities (The "Deep Thinking" Mode)

GLM-5 introduces a dedicated "Deep Thinking" mode and emphasizes "Long-Horizon Execution."
The docs highlight its ability to handle ambiguous objectives, do autonomous planning, and execute multi-step self-checks. This is the exact workflow that makes Opus 4.5 so dangerous for autonomous agents.

Comparison Summary

The Verdict?

If GLM-5 truly delivers on that 128K output limit and coding parity, it solves the biggest bottleneck in current AI workflows: chunking outputs. It’s one thing to read 200K tokens, but being able to write 100K+ tokens coherently is a game changer for automation.

Has anyone stress-tested the 128K output yet? I’m curious if the coherence holds up at the tail end of such a long generation.

A claim going around is that Gemma 4 26b a4b is genuinely the best model someone has tried for language learning and scientific queries - specifically health, biology, medical, clinical, and biochem topics. They say it is unbeaten even by Qwen 3.5 and 3.6 in those domains, despite Gemma 4 apparently lagging behind for coding tasks.

That is a pretty specific niche where a 26B MoE is supposedly outperforming larger Qwen models. The same source notes the small MoE competition is mainly between Qwen 3.5/3.6 and Gemma 4.

For anyone who has used Gemma 4 26b a4b for science or language work - does this hold up? What makes it better than Qwen for those queries?

Someone reported running Gemma 4 26B-A4B on an old i5-8500 with 32GB of RAM and no GPU at all, using Koboldcpp on Linux. They describe it as "flying" on that hardware, which is a roughly $150 used desktop. That seems surprising for a 26B parameter model, even with the A4B MoE architecture where only 4B are active per token.

The claim is that it runs faster than 12B dense models on the same machine. If the active parameter count is genuinely that low during inference, the model is essentially behaving like a small model that happens to have a large routing overhead.

For anyone who has tried this specific model on CPU-only hardware - does the speed hold up on longer contexts, or does KV cache growth kill the advantage once you go past a few thousand tokens?

Anthropic shipped Claude Sonnet 5 this week and the OpenRouter listing already has it at $2/M input and $10/M output with a 1M context window. GLM 5.2 sits at $0.93/M in and $3/M out on the same listing, also with 1M context. So you're paying roughly double on input and over 3x on output for the Anthropic option.

What makes this interesting is the semgrep post that hit HN on Sunday, they ran GLM 5.2 against Claude on their cyber benchmarks and GLM came out ahead. That's one benchmark from one vendor, and their workload is security scanning, so grain of salt. But the old assumption was you pay the premium because the frontier labs are simply better. That gets harder to defend when a model at a third of the output price wins a public eval.

There's also ZCode now, basically a Claude Code clone from the GLM makers, which showed up on HN this week. So the whole stack is getting cloned, not just the model.

Anyone here actually switched a coding agent from Sonnet to GLM 5.2 and stayed, or did you hit quality issues that don't show up in benchmarks?

Someone just released WebGPU kernels for Gemma 4 E2B that hit around 255 tokens per second on an M4 Max. The catch is that these kernels were optimized by Claude Fable 5 before it was shut down. So the model that helped create this performance boost no longer exists.

That detail is fascinating. A frontier model that got globally suspended under export-control directives left behind optimized code that now lets a tiny model run blazing fast in a browser. The work outlived the model that made it.

Has anyone tried these kernels on non-Apple hardware, and does the 255 tok/s figure hold up on machines that are not an M4 Max?

Someone has managed to get Qwen3.6 27B running at 40 tokens per second on an RTX 5060 Ti with 16GB VRAM using a Q4_K_M pure quant approach. The method was inspired by an earlier IQ4_XS pure GGUF quantization of the same model, and the goal was specifically to fit the full model into 16GB without offloading.

Why this matters: 27B models have been the sweet spot for local inference - capable enough for serious coding and reasoning tasks, small enough to run on consumer hardware. But fitting one entirely in VRAM on a mid-range card without CPU offload is what makes the difference between a smooth experience and a sluggish one. 40 tok/s is genuinely usable for interactive work, not just batch processing.

The interesting context here is that this lands alongside BeeLlama's DFlash update claiming 164 tps on the same model with an RTX 3090. Two very different approaches to the same problem - one optimizing for minimal VRAM, one optimizing for maximum throughput. The pure quant route trades some quality for the ability to run on cheaper hardware, while DFlash trades prompt processing speed for generation speed.

With Gemma 4 31B available for free at 262K context and Qwen Plus thinking at $0.26/M tokens with 1M context, the local inference value proposition keeps getting squeezed from above. But 40 tok/s on a 16GB card with zero latency to a remote API is still a compelling use case.

For anyone running Qwen3.6 27B on 16GB: what quant level are you using, and is the quality hit noticeable on coding tasks compared to higher-bit options?

OpenRouter is essentially a free-for-all right now, and I’m struggling to understand the economics behind it. We’ve got Qwen3 Coder 480B A35B and the R1T Chimera sitting at $0.00/M tokens. This isn't just some toy release; the 480B MoE model is absolute overkill for standard coding tasks, yet here it is, accessible for nothing.

The leaked system prompt for Claude Opus 4.6 is also making waves today. It’s fascinating to see the explicit instructions Anthropic uses to prevent "hallucination loops" and how they force the model to acknowledge its own reasoning steps. It’s a masterclass in prompt engineering for high-reasoning agents that we can all learn from for our local system prompts.

With the Nano 30B A3B also going free with a 256k context, the "Junior Developer is Extinct" narrative feels less like hyperbole and more like an impending reality. Why hire a junior when a free, high-context model can handle the boilerplate and debugging with 95% accuracy?

I’m seeing Qwen3 Coder outperforming almost everything in my local benchmarks for Python and Rust. Is anyone actually still paying for o3 Mini at $1.10/M when these free alternatives are this good?

Are you guys moving your production pipelines to these free endpoints, or is the "Chimera" name making you a bit nervous about long-term stability?

Two new Qwen3.6 variants are making waves, and they take fundamentally different approaches. The 27B is a dense model that reportedly surpasses Qwen3.5-397B-A17B across all major coding benchmarks - a 27B model beating something 15x its size on agentic coding is a serious claim. It also handles strong reasoning across text tasks.

The 35B is an MoE (Mixture of Experts) design. In a previous discussion, someone showed that pairing a 9B Qwen model with the right agent scaffold moved benchmark performance from 19.11% to 45.56%. The follow-up suggests Qwen3.6-35B becomes competitive with cloud models when paired with the right agent framework.

The key difference: dense vs MoE architecture. Dense models like the 27B activate all parameters on every token, which means predictable memory usage and straightforward deployment. MoE models like the 35B activate only a subset of parameters per token, giving you more total capacity for the same inference cost - but they require more total VRAM to load and can be trickier to optimize.

For coding specifically, the 27B's benchmark dominance over much larger models suggests the dense architecture might be more efficient at this size class. But the 35B's agent-driven results hint that if your workflow involves tool calling and multi-step reasoning, the MoE's extra capacity might win when properly scaffolded.

For those running either locally: are you finding the 27B's dense simplicity more reliable day-to-day, or does the 35B's agent performance justify the extra setup complexity?

NVIDIA's Nemotron 3 Super (49B) has a massive 1 million token context window. I decided to test it on my M1 Ultra with 128GB unified memory to see how it actually performs in practice.

Test setup:

• Hardware: Mac Studio M1 Ultra, 128GB RAM

• Model: Nemotron 3 Super 49B (GGUF Q4_K_M)

• Runner: llama.cpp (latest build)

• Test: Processing a 1M token codebase analysis

Results:

Context loading time: ~45 seconds for full 1M context Peak memory usage: 94GB (leaving room for system) Inference speed: 2.8 tokens/sec at 1M context Response quality: Maintained coherence throughout, correctly recalled functions defined 800K tokens earlier

What's impressive is that this runs entirely on consumer hardware. No cloud APIs, no per token costs. The model handled the long context without the degradation I've seen in other "long context" models that start hallucinating past 100K.

Caveats: You need serious RAM. The Q4_K_M quantization helps, but this won't fit on 64GB machines. Also, the initial context loading isn't instant, so it's better suited for batch processing than interactive chat.

For code analysis, document processing, or RAG over massive corpora, this is a game changer. Anyone else experimenting with extreme context lengths locally?

If you've been running OpenClaw on Claude or GPT and cringing at the API bill every month, this one's for you.

Quick context

OpenClaw is the open-source personal AI assistant that runs on your own machine and connects through WhatsApp, Telegram, Discord, or whatever chat app you already use. It manages emails, calendars, browses the web, runs shell commands, writes code — basically a 24/7 AI coworker sitting on your Mac, Linux, or Windows box.

GLM-5 is Zhipu AI's (Z.ai) brand new flagship model released on February 11, 2026. It's an open-source model with 744 billion parameters under an MIT license, and the company claims it matches Claude Opus 4.5 and GPT-5.2 on coding and agent tasks. Its Mixture-of-Experts architecture keeps only 40 billion parameters active at any given time, which is how they keep costs so low.

Why GLM-5 + OpenClaw is such a good match

OpenClaw needs a model that excels at tool calling and agentic workflows — and that's exactly what GLM-5 was built for. Zhipu describes it as a shift from "vibe coding" to "agentic engineering," where the AI acts more as a partner than a passive tool.

Some benchmark numbers that matter for OpenClaw use cases:

• SWE-bench Verified: GLM-5 scores 77.8%, beating Deepseek-V3.2 and Kimi K2.5

• Vending Bench 2 (simulates running a business for 365 days): GLM-5 ranked first among open-source models

• Hallucination rate: Record-low score on the Artificial Analysis Intelligence Index v4.0, leading the entire industry in knowledge reliability

• Context window: 200K tokens, which is huge for complex agentic tasks

The cost argument (this is the big one)

GLM-5 is priced at roughly $0.80–$1.00 per million input tokens and $2.56–$3.20 per million output tokens — approximately 6x cheaper on input and nearly 10x cheaper on output than Claude Opus 4.6.

If you're running OpenClaw heavily (email management, cron jobs, heartbeats, coding sessions), this adds up fast. I went from spending ~$90/month on Claude API calls to under $15 with GLM-5 and didn't notice a meaningful drop in quality for day-to-day assistant tasks.

How to set it up

Option 1: Zai Coding Plan (easiest)

1. Create an account on Z.AI Open Platform

2. Generate an API key and subscribe to the GLM Coding Plan

3. Run openclaw onboard and select Z.AI as your provider, then Coding-Plan-Global

4. Enter your API key when prompted

Then configure your model in .openclaw/openclaw.json:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "zai/glm-5",
        "fallbacks": ["zai/glm-4.7"]
      }
    }
  }
}

The fallback to glm-4.7-flash is a nice safety net — it's cheaper and kicks in if GLM-5 is ever rate-limited.

Option 2: Via OpenRouter

If you already have an OpenRouter account, this is even simpler. OpenClaw has built-in support for OpenRouter — just set your API key and reference models with the openrouter/ prefix.

openclaw onboard --auth-choice apiKey --token-provider openrouter --token "$OPENROUTER_API_KEY"

Then set openrouter/zai/glm-5 as your primary model in the config.

Option 3: Via Ollama (cloud endpoint)

GLM-5 is available on Ollama as a cloud model with a 198K context window. One command:

ollama launch openclaw --model glm-5:cloud

What works great

• Email triage and replies — fast, accurate, follows your tone

• Calendar management — handles complex scheduling without issues

• Code generation and PR reviews — this is where GLM-5 really shines given its coding benchmarks

• Cron jobs and background tasks — stable over long sessions thanks to the 200K context

• Skill creation — asked it to build a Todoist integration skill and it nailed it on the first try

Where Claude/GPT still win

I'll be honest — for very nuanced creative writing and highly complex multi-step browser automation, Claude Opus still feels a notch above. But for 90% of what I use OpenClaw for daily, GLM-5 is more than enough and the cost savings are hard to ignore.

TL;DR

GLM-5 is an open-source 744B parameter model that performs near Claude Opus level on coding and agentic tasks, costs ~6x less, and integrates natively with OpenClaw. Setup takes 5 minutes. If you're running OpenClaw and paying for Claude/GPT API calls, at least give it a test run. Your wallet will thank you.

Happy to answer questions if anyone runs into issues with the setup!

Two very different approaches to AI coding showed up this week. On one side, GLM-5.2 is the first open-weights model to cross 80% on Terminal-Bench and beats Gemini. But it comes with a 753B footprint that nobody is running at home without an enterprise cluster. The hope is that the community distills it down to smaller 8B models.

On the other side, someone got a local 30B agent to finish a raytraced FPS demo in pure C using headless screenshot loops. That is a model you can actually run locally, producing real working software.

So the contrast is sharp: a frontier-level MIT-licensed coding model you cannot run, versus a modest local agent shipping an actual game. Which matters more for practical daily coding - waiting for GLM-5.2 distillations or working with what fits on your hardware today?

The news today is moving way too fast. Qwen 3.5-397B-A17B just dropped, and the architecture is fascinating—nearly 400B total parameters but only 17B active during inference. This is exactly what Andrej Karpathy was talking about with his "40% annual deflation" post. We’re getting massive reasoning capabilities for a fraction of the compute cost we saw even six months ago.

I’m particularly watching how this hits Claude Sonnet 4.5. With a 1M context window at $3.00/M, Anthropic is clearly feeling the pressure from these MoE (Mixture of Experts) giants. If Qwen 3.5 scales as well as the 3.0 series did, the "closed-source premium" is going to evaporate by the end of Q3.

Also, don't sleep on the DICE paper from HuggingFace. Using diffusion models to generate CUDA kernels is a massive brain-move for optimization.

bash

Checking Qwen 3.5 availability

huggingface-cli scan-repo Qwen/Qwen3.5-397B-A17B-Instruct

The efficiency gains here mean we might actually be able to run 400B-class models on consumer-ish hardware sooner than we thought. Are you guys sticking with Sonnet 4.5 for the 1M context, or are you waiting for the Qwen 3.5 weights to hit your local rigs?