Cerebras Code Now Supports Glm 4.6 at 1000 Tokens/sec
Postedabout 2 months agoActiveabout 2 months ago
cerebras.aiTechstoryHigh profile
calmmixed
Debate
60/100
AI Coding AssistantsLLM PerformanceCerebras Code
Key topics
AI Coding Assistants
LLM Performance
Cerebras Code
Cerebras Code now supports GLM 4.6 at 1000 tokens/sec, sparking discussion about the model's performance, pricing, and potential applications in coding workflows.
Snapshot generated from the HN discussion
Discussion Activity
Very active discussionFirst comment
4h
Peak period
45
6-12h
Avg / period
11.6
Comment distribution128 data points
Loading chart...
Based on 128 loaded comments
Key moments
- 01Story posted
Nov 7, 2025 at 7:00 PM EST
about 2 months ago
Step 01 - 02First comment
Nov 7, 2025 at 10:31 PM EST
4h after posting
Step 02 - 03Peak activity
45 comments in 6-12h
Hottest window of the conversation
Step 03 - 04Latest activity
Nov 11, 2025 at 6:11 PM EST
about 2 months ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
ID: 45852751Type: storyLast synced: 11/20/2025, 4:35:27 PM
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
They've claimed repeatedly in their discord that they don't quantize models.
The speed of things does change how you interact with it I think. I had this new GLM model hooked up to opencode as the harness with their $50/mo subscription plan. It was seriously fast to answer questions, although there are still big pauses in workflow when the per-minute request cap is hit.
I got a meaningful refactor done, maybe a touch faster than I would have in claude code + sonnet? But my human interaction with it felt like the slow part.
This is important because their premium $50 (as opposed to $20 on Claude Pro or ChatGPT Plus) should be justified by the speed. GLM 4.6 is fine but I don't think it's still at the GPT-5/Claude Sonnet 4.5 level, so if I'm paying $50 for it on Cerebras it should be mainly because of speed.
What kind of workflow justifies this? I'm genuinely curious.
It's more expensive to get the same raw compute as a cluster of nvidia chips, but they don't have the same peak throughput.
As far as price as a coder, I am giving a month of the $50 plan a shot. I haven't figured out how to adapt my workflow yet to faster speeds (also learning and setting up opencode).
Every local model I've used and even most open source are just not good
https://github.com/musistudio/claude-code-router
quantization ruins models and some models aren't that smart to begin with.
Think about waiting for compilation to complete: the difference between 5 minutes and 15 seconds is dramatic.
Same applies to AI-based code-wrangling tasks. The preserved concentration may be well worth the $50, especially when paid by your employer.
https://github.com/MoonshotAI/K2-Vendor-Verifier
It's one of the lowest rated on that table.
Any workflow where verification is faster / cheaper than generation. If you have a well tested piece of code and want to "refactor it to use such and such paradigme", you can run n faster model queries and pick the fastest.
My colleagues that do frontend use faster models (not this one specifically, but they did try fast-code-1) to build components. Someone worked out a workflow w/ worktrees where the model generates n variants of a component, and displays them next to each other. A human can "at a glance" choose which one they like. And sometimes pick and choose from multiple variants (something like passing it to claude and say "keep the styling of component A but the data management of component B"), and at the end of the day is faster / cheaper than having cc do all that work.
Of course we do. Just run a benchmark with Cerebras/Groq and compare to the results produced in a trusted environment. If the scores are equal, the model is is either unquantized, or quantized so well that we can not tell, in which case it does not matter.
For example, here is a comparison of different providers for gpt-oss-120b, with differences of over 10 % for best and worst provider.
https://artificialanalysis.ai/models/gpt-oss-120b/providers#...
Takeaway is that this is sonnet-ish model at 10x the speed.
It's like saying Llama 3.2 3B and Gemma 4B are fine tunes of each other because they run at similar speeds on NVidia hardware.
The reason for their speed is this chip: https://www.cerebras.ai/chip
Good luck. Maybe it’ll do well in some self-directed agent loop.
For reference, each new request needs to send all previous messages - tool calls force new requests too. So it's essentially cumulative when you're chatting with an agent - my opencode agent's context window is only 50% used at 72k tokens, but Cerebra's tracking online shows that I've used 1M input tokens and 10k output tokens already.
This is how every "chatbot" / "agentic flow" / etc works behind the scenes. That's why I liked that "you should build an agent" post a few days ago. It gets people to really understand what's behind the curtain. It's requests all the way down, sometimes with more context added, sometimes with less (subagents & co).
Stalin used to say that in war "quantity has a quality all its own". And I think that in terms of coding agents, speed is quality all its own too.
Maybe not for blind vibe coding, but if you are a developer, and is able to understand the code the agent generates and change it, the fast feedback of fast inference is a game changer. I don't care if claude is better than GLM 4.6, fast iteractions are king for me now.
It is like moving from DSL to gigabit fiber FTTH
Plenty of people will agree with you. [1]
[1] https://blog.codinghorror.com/performance-is-a-feature/ (2011)
I've been using GLM 4.6 on Cerebras for the last week or so, since they began the transition, and I've been blown away.
I'm not a vibe coder; when I use AI coding tools, they're in the hot path. They save me time when whipping up a bash script and I can't remember the exact syntax, or for finding easily falsifiable answers that would otherwise take me a few minutes of reading. But, even though GLM 4.6 is not as smart as Sonnet 4.5, it is smart enough. And because it is so fast on Cerebras, I genuinely feel that it augments my own ability and productivity; the raw speed has considerably shifted the tipping point of time-savings for me.
YMMV, of course. I'm very precise with the instructions I provide. And I'm constantly interleaving my own design choices into the process - I usually have a very clear idea in my mind of what the end result should look like - so, in the end, the code ends up how I would have written it without AI. But building happens much faster.
No affiliation with Cerebras, just a happy customer. Just upgraded to the $200/mo plan - and I'll admit that I was one that scoffed when folks jumped on the original $200/mo Claude plan. I think this particular way of working with LLMs just fits well with how I think and work.
Do you suggest that this thing is so fast its simpler now to quickly work on one thing at a time instead of the 5 background tools running in parallel which might have been a pattern we invented because these things are so slow?
you’ll need to try it and see what the speed does to your workflow.
i gave the bash script to claude code, which immediately started implementing something in the zig language. after a few iterations, i had zig source code that compiled in linux , produced a windows exe and perfectly mimicked the bash script.
I know nothing about zig programming.
This is clearly the future of Software Development, but the models are so good atm that the future is possible now. I'm still getting used to and having to rethink my entire dev workflow for maximum productivity, and whilst I wouldn't unleash AI Agents on a decade old code base, all my new Web Apps will likely end up being AI-first unless there's a very good reason why it wouldn't provide a net benefit.
You are doing embedded development or anything else not as mainstream as web dev? LLMs are still useful but no longer mind blowing and often produce hallucinations. You need to read every line of their output. 1000t/s is crazy but no longer always in a good way.
You are doing stuff which the LLMs haven't seen yet? You are on your own. There is quite a bit of irony in the fact that the devs of llama.cpp barely use AI - just have a look at the development of support for Qwen3-Next-80B [1].
[1] https://github.com/ggml-org/llama.cpp/pull/16095
Is likely why no one takes you seriously, as it's a good indication you don't have much experience with them.
I experienced this with Claude 4 Sonnet and, to some extent, gpt-5-mini-high.
When able to run tests against its output, Claude produces pretty good Rust backend and TypeScript frontend code. However, Claude became borderline unproductive once I started experimenting with uefi-rs. Other LLMs, like gpt-5-mini-high, did not fare much better, but they were at least capable of admitting lack of knowledge. In particular, GPT-5 would provide output akin to "here is some pseudocode that you may be able to adapt to your choice of UEFI bindings".
Testing in a UEFI environment is quite difficult; the LLM can't just run `cargo test` and verify its output. Things get worse in embedded, because crates like embedded_hal made massive API changes between 0.2 and 1.0 (the latest version), and each LLM I've tried seems to only have knowledge of 0.2 releases. Also, for embedded, forget even thinking about testing harnesses (which at least exist in some form with UEFI, it's just difficult to automate the execution and output for an LLM). In this case, you cannot really trust the output of the LLM. To minimize risk of hallucination, I would try maintaining data sheets and library code in context, but at that point, it took more time to prompt an LLM than handwrite code.
I've been writing a lot of embedded Rust over the past two weeks, and my usage of LLMs in general decreased because of that. Currently planning to resume development on some of my "easier" projects, since I have about 300 Claude prompts remaining in my Zed subscription, and I don't want them to go to waste.
I think this doesn't have to be like this and we can do better for this. If LLMs keep this up, good testing infrastructure might become more important.
Overall, I agree with your point. LLMs feel a lot more reliable when a codebase has thorough, easy-to-run tests. For a similar reason, I have been drifting towards strong, statically-typed languages. Both Rust and TypeScript have rich type systems that can express many kinds of runtime behavior with just types. When a compiler can make strong guarantees about a program's behavior, I assume that helps nudge the quality of LLM output a bit higher. Tests then help prevent silly regressions from occurring. I have no evidence for this besides my anecdotal experience using LLMs across several programming languages.
In general, I've had the best experience with LLMs when there's plenty of static analysis (and tests) on the codebase. When a codebase can't be easily tested, then I get much less productivity gains from LLMs. So yeah, I'm all for improving testing infrastructure.
[0] https://x.com/jarredsumner/status/1944948478184186366
"Shifting bugs left" is even more important for LLMs than it is for humans. There are certain tests LLMs can't run, so if we can detect bugs at compile time and run the LLM in a loop until things compile, that's a significant benefit.
Counterpoint, but also kind of reinforcing your point. It depends on the kind of embedded development. I did a small utility PCB with an ESP32, and their libs are good there is active community, they have test frameworks. LLM's did a great job there.
On the other hand, I wanted to drive a timer and a pwm module and a DMA dma engine to generate some precise pulses. The way I chained hw was... Not typical, but it was what I needed and the hw could do it. At that, Claude failed miserably and it only led me to waste my time, so I had to spend the time to do it manually.
Even llama.cpp is not a truly novel thing to LLMs, there are several performant machine learning model executors available in their training sets anyway, and I'm sure llama.cpp can benefit from LLMs if they want; they just chose not to.
[1] https://github.com/lifthrasiir/wah/
You could argue that that's the bulk of all software jobs in tech, and you'd likely be correct... But depending on what your actual challenge is, LLM assistance is more of a hindrance then help. However creating a web platform without external constraints makes LLM assistance shine, that's true
E.g. Victor Taelin is implementing ultra-advanced programming language/runtime writing almost all code using LLM now. Runtime (HVM) is based on Interaction Calculus model which was only an obscure academic curiosity until Taelin started working on it. So a hypothesis that LLMs are only capable of copying bits of code from Stack Overflow shall be dismissed.
[1] https://github.com/HigherOrderCO/HVM
From my understanding, main problem there is a compilation into (optimal) CUDA code and CUDA runtime, not language or internal representation per se. CUDA is hard to debug, some help can be warranted.
BTW, this HVM thing smells strange. The PAPER does not provide any description of experiments where linear parallel speedups were achieved. What were these 16K cores? What were these tasks?
Currently he's working on a different thing: a code synthesis tool. AFAIK he got something better than anything else in this category, but whether it's useful is another question.
[1] https://en.wikipedia.org/wiki/Id_(programming_language)
Id [1] was run on the CM-5 (then) supercomputer and demonstrated superlinear parallel speedups on some of the tasks. That superlinear speedup was due to better cache utilization on individual nodes.
In some of the tasks the amount of parallel execution discovered by Id90 would lead to overflow of content-addressable memory and Id90's runtime implemented throttling to reduce available parallelism to make things to be done at all.
Does the PAPER of HVM refers to Id (Id90 to be precise)? No, it does not.
This is serious negligence of Taelin.
I dunno why you choose to be so critical. Taelin isn't really selling his stuff, and his previous stuff was just an open source experiment. It's not an academic paper which claims something. And HVM1 is irrelevant now.
Their new stuff isn't about general performance but code synthesis
https://github.com/GoogleCloudPlatform/aether
Note: the syntax is ugly as a trade-off to make it explicit and unambiguous for LLMs to use.
> There's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper so I barely even touch the keyboard. I ask for the dumbest things like "decrease the padding on the sidebar by half" because I'm too lazy to find it. I "Accept All" always, I don't read the diffs anymore. When I get error messages I just copy paste them in with no comment, usually that fixes it. The code grows beyond my usual comprehension, I'd have to really read through it for a while. Sometimes the LLMs can't fix a bug so I just work around it or ask for random changes until it goes away. It's not too bad for throwaway weekend projects, but still quite amusing. I'm building a project or webapp, but it's not really coding - I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works.
— https://x.com/karpathy/status/1886192184808149383
"verified vivisection development" when you're working with older code :D
- keyboard princess
- Robin to the Batman
- meatstack engineer
- artificial manager
As it should, it's about writing code on vibes, not looking at the code, it's literally the definition of the term:
https://x.com/karpathy/status/1886192184808149383
And when I say literally I'm including dictionaries:
https://blog.collinsdictionary.com/language-lovers/collins-w...
Cerebras makes a giant chip that runs inference at unreal speeds. I suspect they run their cloud service more as an advertising mechanism for their core business: hardware. You can hear the founder describing their journey:
https://podcasts.apple.com/us/podcast/launching-the-fastest-...
Yes, Qwen3 made more mistakes than GLM, around 15% more in my quick throwaway evals, but it was a more professional model overall, more polished in some aspects, better with international languages, and being non-reasoning, ideal for a lot of tasks through the API that could be ran instantaneously. I think the Qwen line of models is a more consistent offering, with other versions of the model for 32B and VL, now a 80B one, etc. I guess the problem was that Qwen Max was closed source, signalling that Qwen may not have a way forward for Cerebras to evolve. GLM 4.6 covers precisely that hole. Not that Cerebras is a model provider of any kind, their service levels are "buggy" (right now it's been down for 1h and probably won't be fixed until California wakes up at 9am PST). So it does feel like we are not the customers, but the product, a marketing stunt for them to get visibility for their tech.
GLM feels like they (Z.ai) are just distilling whatever they can get into it. GLM switches to Chinese sometimes, or just cuts off. It does have a bit of more "intelligence" than Q3C, but not enough to say it solves the toughest problems. Regardless, for tough nuts to crack I use my Codex Plus plan.
Ex: In one of my evals, it took 15 turns to solve an issue using Cerebras Q3C. I took 12 turns with GLM, but overall GLM takes 2x the time, so instead of doing a full task from zero-to-commit in say 15 minutes, it takes 24 minutes.
In another eval (Next.js CSS editing), my task with Q3C coder was done in 1:30 minutes. GLM 4.6 took 2:24. The same task in Codex took 5:37 minutes, with maybe 1 or 2 turns. Codex DX is that of working unattended: prompt it and go do something else, there's a good chance it will get it right after 0, 1 or 2 nudges. With CC+Cerebras it's a completely different DX, given the speed it feels just like programming, but super-fast. Prompt, read the change, accept (or don't), accept, accept, accept, test it out, accept, prompt, accept, interrupt, prompt, accept, and 1:30 min later we're done.
Like I said I use Claude Code + a proxy (llmux). The coding agent makes a HUGE difference, and CC is hands-down the best agent out there.
It seems to have been fine-tuned on Claude Code interactions as well. Though unfortunately not much of Claude's coding style itself? (I wish!)
(I have both and haven't run into any limits yet, so I'm probably not a very heavy user.)
I'm quite impressed with the model. I have been using GLM-4.6 in Claude Code instead of Sonnet, and finding it fine for my use cases. (Simple scripting and web stuff.)
(Note: Z.ai's GLM doesn't seem to support web search (fails) or image recognition (hallucinates). To fix that I use Claude Code Router and hooked up those two features to Gemini (free) instead.)
I find that Sonnet produces much nicer code. I often find myself asking Sonnet to clean up GLM's code. More recently, I just got the Pro plan for Claude so I'm mostly just using Sonnet directly now. (Haven't had the rate limits yet but we'll see!)
So in my experience if you're not too fussy you can currently get "80% of Claude Code" for like $3/month, which is pretty nuts.
GLM also works well in Charm Crush, though it seems to be better optimized for Claude Code (I think they might have fine tuned it.)
---
I have tested Kimi K2 at 1000 tok/s via OpenRouter, and it's bloody amazing, so I imagine this supercharged GLM will be great too. Alas, $50!
Quite funny, actually.
https://docs.z.ai/devpack/tool/claude
tldr
Although if you want an Actually Good Experience I recommend using Claude Code Routerhttps://github.com/musistudio/claude-code-router
because it allows you to intercept the requests and forward them to other models. (e.g. GLM doesn't seem to support search or images, so I use Gemini's free tier for that.)
(CCR just launches Claude with the base url set to a local proxy. The more adventurous reader can also set up his own proxy... :)
Humans : 1
AI : 0
Fast forward to now, when GLM 4.6 has replaced Qwen3 coder in their subscription plan. My subscription was still active so I wanted to give this setup another shot. This time though, I decided to give Cline a try. I’ve got to say, I was very pleasantly surprised - it worked really well out of the box. I guess whatever Cline does behind the scenes is more conducive to Cerebra’s API. I used Claude 4.5 + Thinking for “Plan” mode and Cerebras/GLM 4.6 for “Act”.
The combo feels solid. Much better than GPT-5 Codex alone. I found codex to be very high quality but so godawful slow for long interactive coding sessions. The worst part is I cannot see what it’s “thinking” to stop it in its tracks when it’s going in the wrong direction.
In an essence, Cerebras + GLM 4.6 feels like Grok Fast 1 on steroids. Just couple it with a frontier + thinking model for planning (Claude 4.5/GPT-5/Gemini Pro 2.5).
One caveat: sometimes the Cerebras API starts choking “because of high demand” which has nothing to do with hitting subscription limits. Just an FYI.
Note: For the record, I was coding on a semi-complex Rust application tuned for low-latency mix of IO + CPU workload. The application is multi-threaded and makes extensive use of locking primitives and explicit reference counting (Arc). All models were able to handle the code really well given the constraints.
Note2: I am also evaluating Synthetic's (synthetic.new) open-source model inference subscription and I like it a lot. There's a large number of models to choose from, including gpt-oss-120 and their usage limits are very very generous. To the point that I don't think I will ever hit them.
Clicking buttons, reading values from fields, etc
it's different than claude code
I have a lot of questions about how models are run at scale; so curious to know more. With such a massive wafer as chip as Cerebras, it feels like perhaps switching might be even more consuming. Or maybe there's some brilliant strategy to have multiple contexts all loaded that it can flip between! Inventorying & using so much ram so spread out is it's own challenge!
It is definitely fun playing with these models at these speeds. The question is just how far from real pricing is 500M tokens for $50?
Either way the LLM usage will grow for some time to come and so will grow energy usage. Good times for renewables and probably fusion and fission.
Selling shovels in a gold rush was always reliable business. Cerebras is only rated at $8.1B as of one month ago. Compared to Nvidia that seems pocket change.
I write what I want, the LLM responds with edits, my 100 lines of Python implement them in the project. It can edit any number of files in one LLM call, which is very nice (and very cheap and fast).
I tested this with Kimi K2 on Groq (also 1000 tok/s) and very impressed.
I want to say this is the best use case for fast models -- that frictionlessness in your workflow -- though it burns tokens pretty fast working like that! (Agentic is even more nuts with how fast it burns tokens on fast models, so the $50 is actually pretty great value.)
Currently on the 50 USD tier, very much worth the money, am kinda considering going for the 200 USD tier, BUT GPT-5 and Sonnet 4.5 and Gemini 2.5 Pro still feel needed occasionally, so it'd be stupid to go for the 200 USD tier and not use it fully and still have to pay up to around 100 USD for tokens in the other models per month. Maybe that will change in the future, when dealing with lots of changes (e.g. needing to make a component showcase of 90 components, but with enough differences between then to make codegen unviable) Cerebras is already invaluable.
Plus the performance actually makes iterating faster, to a degree where I believe that other models should also eventually run this fast. Oddly enough, the other day their 200 USD plan showed as "Sold out", maybe they're scaling up the capacity gradually. I really hope they never axe the Code plans, they literally have no competition for this mode of use. Maybe they'll also have a 100 USD plan some day, one can hope, but maybe offering just the 200 plan is better from an upsell perspective for them.
Oh also, when I spill over my daily 24M limits, please let me use the Pay2Go thing on top of that, if instead of 24M tokens some day I need 40M, I'd pay for those additional ones.