GLM-4.7: 84.9% on LiveCodeBench for $3/Month

Z.ai dropped GLM-4.7 coding model on December 24, 2025, and the benchmarks tell a story incumbents won’t like: 84.9% on LiveCodeBench V6, crushing Claude Sonnet 4.5’s 64.0%. That’s frontier-class coding intelligence for $3/month—or free if you run it locally. The model hit 73.8% on SWE-bench Verified, matching proprietary systems that charge 7x more.

This isn’t iterative improvement. It’s a pricing disruption backed by architectural choices that optimize for real development workflows. Z.ai built a 355B-parameter Mixture-of-Experts system that activates only 32B parameters per task, delivering Claude-level performance at Cursor-crushing economics.

The release coincides with broader market pressure on AI coding tools. Companies are demanding ROI, and $200/month Cursor subscriptions face scrutiny when open-source alternatives deliver 73.8% SWE-bench scores. GLM-4.7 lands at the inflection point where performance meets economic reality.

Architecture: 355B Parameters, 32B Active Intelligence

GLM-4.7’s Mixture-of-Experts architecture activates 32B parameters per request from a 355B total parameter pool. This design choice trades dense computation for selective activation, reducing inference costs without sacrificing capability. The result: faster token generation and lower energy consumption than dense models of equivalent intelligence.

The model supports a 200,000-token context window with 128,000-token output capacity. That’s repository-scale context depth—enough to ingest entire codebases and maintain coherence across multi-file refactoring tasks. For comparison, GPT-5.2-Codex relies on context compaction to handle similar workloads.

Z.ai released model weights on HuggingFace and ModelScope with support for vLLM and SGLang inference frameworks. Self-hosting eliminates API costs entirely for teams with existing GPU infrastructure. The licensing permits commercial use without revenue-share constraints.

Benchmark Performance: Where GLM-4.7 Wins and Loses

SWE-bench Verified measures a model’s ability to fix real GitHub issues from production repositories. GLM-4.7 scored 73.8%, a 5.8-percentage-point jump from GLM-4.6. That’s the highest open-source result, though Claude Sonnet 4.5 maintains a slight edge in absolute terms.

LiveCodeBench V6 tells a different story. GLM-4.7’s 84.9% demolishes Claude Sonnet 4.5’s 64.0%, suggesting superior generalization on novel coding tasks. The benchmark tests real-world problem-solving rather than pattern-matching on training data leakage—a cleaner signal of production utility.

Additional benchmarks reinforce coding dominance. GLM-4.7 hit 66.7% on SWE-bench Multilingual (+12.9% vs. GLM-4.6) and 41% on Terminal Bench 2.0 (+16.5%). On τ²-Bench, which evaluates interactive tool invocation, it scored 87.4—the highest among open-source models and ahead of Claude Sonnet 4.5.

Mathematical reasoning improved 12.4 percentage points on HLE (Humanity’s Last Exam) to 42.8%. Code Arena rankings place GLM-4.7 first among open-source models and sixth overall. The model ranks #1 open-source on WebDev benchmarks.

Weaknesses exist. Pure reasoning tasks lag GPT-5.1 and Gemini 3 Flash, particularly on chain-of-thought depth. Latency on self-hosted deployments varies with hardware—cheap inference comes with optimization overhead.

Pricing Disruption: $3 vs $200 Cursor Economics

GLM-4.7 costs $3/month for cloud access via chat.z.ai. API pricing runs $0.40 per 1M input tokens and $1.50 per 1M output tokens. Cursor charges $200/month for its AI-powered IDE. Copilot Pro sits at $10/month but relies on older GPT-4 variants. Claude’s API costs $15 per 1M output tokens—10x GLM-4.7’s rate.

The GLM Coding Plan delivers Claude-level performance at 1/7th the price with 3x usage quotas. For enterprise teams spending $20,000/month on AI coding tools, switching to GLM-4.7 could cut costs to $3,000 without sacrificing SWE-bench performance. That’s $204,000 annual savings per 10-developer team.

Free self-hosting changes the cost equation entirely. Teams with existing GPU infrastructure pay only inference compute—typically $0.10-$0.30 per 1M tokens depending on hardware utilization. H100 clusters run GLM-4.7 at 40-60 tokens/second, making real-time code generation economically viable.

The catch: integration maturity. Cursor’s $200 includes polished IDE integration, context management, and multi-file editing UX. GLM-4.7 works with Claude Code, Cline, Roo Code, and Kilo Code, but setup requires more configuration. The price gap compensates for friction—for now.

Three Thinking Modes: Preserved, Interleaved, and On-Demand

GLM-4.7 introduces thinking modes that adjust reasoning transparency and persistence across multi-turn conversations. “Preserved Thinking” retains all reasoning blocks across sessions, reducing information loss in complex, long-horizon tasks. Previous turns’ logic remains accessible, preventing context collapse in 50+ message threads.

“Interleaved Thinking” alternates between reasoning and output generation within a single response. The model explains its approach, generates code, then reflects on potential issues—all in one turn. This mode suits rapid prototyping where developers want inline rationale without separate reasoning artifacts.

“On-Demand Thinking” activates only when explicitly requested or when task complexity triggers automatic reasoning. This reduces token consumption on straightforward queries while preserving deep analysis for debugging or architectural decisions. Models waste 30-40% of tokens on unnecessary chain-of-thought—on-demand mode reclaims that efficiency.

The implementation mirrors chain-of-thought research but optimizes for interactive coding sessions. Developers using Claude Code or Cline can toggle thinking modes per task, balancing token costs against reasoning depth. Preserved mode costs 15-20% more tokens but prevents the “forgetting” that plagues long refactoring sessions.

Integration: Works With Claude Code, Cline, Roo Code, Kilo Code

GLM-4.7 supports mainstream agentic coding frameworks through OpenAI-compatible API endpoints. Point Claude Code, Cline, or Roo Code at Z.ai’s API, swap the model parameter, and existing workflows transfer without code changes. Kilo Code and TRAE offer native GLM-4.7 integrations with optimized prompt templates.

Self-hosted deployments use vLLM or SGLang for inference serving. vLLM supports tensor parallelism across multi-GPU setups, enabling 8xA100 clusters to serve GLM-4.7 at 200+ requests/second. SGLang optimizes for memory efficiency, running the model on 2×4090 systems with 24GB VRAM per GPU.

IDE plugins require manual configuration. VSCode extensions like Continue.dev and Cline work with GLM-4.7 via custom model endpoints. JetBrains IDEs support it through third-party plugins, though IntelliJ’s AI Assistant doesn’t natively recognize Z.ai models. Expect plugin fragmentation until market share forces native support.

Terminal-based workflows see immediate gains. GLM-4.7 scored 41% on Terminal Bench 2.0, outperforming Claude on shell scripting and command-line tool generation. Developers using Warp or Cursor’s terminal features can swap models and access superior bash/zsh generation.

Market Implications: Open-Source Pressure on Proprietary Pricing

GLM-4.7 forces a reckoning on AI coding tool economics. If an open-source model delivers 73.8% SWE-bench performance at $3/month, how do $200 subscriptions justify 67x price premiums? Cursor’s integration polish and UX sophistication create defensibility, but the margin shrinks as open-source tooling matures.

Enterprise procurement teams now have leverage. “Why not GLM-4.7?” becomes a board-level question when AI coding budgets hit $500K/year. Vendors must justify costs with measurable productivity gains—integration ease, reduced debugging time, faster onboarding—rather than benchmark bragging rights.

Z.ai’s timing capitalizes on 2025’s AI hype correction. Companies demand ROI evidence, not GPT-5 promises. GLM-4.7 offers quantifiable cost reduction with transparent benchmarks. That value proposition resonates louder than incremental frontier model improvements.

The competitive response will segment markets. Consumer developers (indie hackers, startups) migrate to GLM-4.7’s free tier. Mid-market teams ($50-500K revenue) adopt the $3 plan. Enterprises stick with Cursor or Copilot for support contracts and compliance guarantees. Proprietary vendors must move downmarket or add enterprise features open-source can’t replicate.

Limitations: Where GLM-4.7 Falls Short

Pure reasoning tasks expose gaps. GPT-5.1 and Gemini 3 Pro outperform GLM-4.7 on multi-step logical inference and abstract problem decomposition. If your workflow emphasizes system design over code generation, frontier proprietary models maintain advantages.

Latency on self-hosted deployments varies widely. A 2×4090 setup generates 25-35 tokens/second—usable but not instant. H100 clusters hit 60+ tokens/second, matching cloud APIs, but cost $30K/GPU. Budget hardware creates perceptible lag in interactive coding sessions.

Integration immaturity creates friction. Cursor users get one-click model switching and context-aware file editing. GLM-4.7 requires manual API configuration, custom prompts, and workaround scripts for multi-file operations. The 10-hour setup tax erodes cost savings for small teams.

Documentation gaps persist. Z.ai’s official blog covers benchmarks thoroughly, but deployment guides lack production-readiness details. Scaling to 100+ developers requires custom infrastructure work—expertise proprietary vendors bundle into support contracts.

Training data recency remains opaque. Z.ai hasn’t disclosed knowledge cutoffs or training corpus composition. Models trained on pre-2024 code miss recent framework updates (Next.js 15, React 19, Python 3.13 features). Proprietary APIs update training data quarterly—GLM-4.7’s refresh cadence is unclear.

Decision Framework: When to Choose GLM-4.7

Choose GLM-4.7 if you optimize for cost and have technical capacity for setup. Teams spending $10K+/month on AI coding tools see immediate ROI. Self-hosting makes sense for organizations with existing GPU infrastructure and DevOps expertise.

Stick with Cursor or Copilot if integration ease outweighs cost savings. Non-technical founders and small teams (2-5 developers) benefit more from polished UX than $200/month savings. Enterprise compliance requirements (SOC2, data residency) favor vendors with legal guarantees.

Evaluate GLM-4.7 for specific use cases rather than wholesale replacement. High-volume inference tasks (documentation generation, code review bots, customer support agents) benefit most from cost savings. Keep proprietary models for critical path work where integration friction matters.

The hybrid approach wins. Use GLM-4.7 for 80% of routine coding tasks, reserve Claude or GPT-5 for complex architecture decisions. This strategy captures most cost savings while maintaining access to frontier reasoning when needed. The economics work: $3/month GLM + $20/month Claude beats $200/month Cursor.

What This Means for 2026

GLM-4.7 proves open-source models can match proprietary coding performance. That’s not a prediction—it’s a benchmark fact. The question is whether integration ecosystems evolve fast enough to capture enterprise adoption. If VSCode, JetBrains, and terminal tools add native GLM-4.7 support in Q1 2026, proprietary vendors face margin compression.

Expect pricing wars. Cursor, GitHub Copilot, and Claude will respond with discounts, enterprise bundles, or feature differentiation. The $200/month tier can’t survive when $3 alternatives deliver comparable SWE-bench scores. Either prices drop or value-adds increase—likely both.

Z.ai’s move pressures other open-source projects to match coding benchmarks. Llama 4, Mistral Large 3, and Qwen 3 will prioritize SWE-bench scores in 2026 releases. The race isn’t just frontier intelligence anymore—it’s economically viable coding assistance. GLM-4.7 sets the bar at 73.8% for $3/month.

For developers, the calculus is simple: try GLM-4.7 for non-critical workflows. If it works, redirect budget savings toward human engineers or infrastructure. If it fails, the $3 experiment costs less than two hours of developer time. That risk-reward ratio makes testing inevitable.