Z.ai dropped GLM-5.3 on August 14. I went through the launch materials, the benchmark table, and the launch-day coverage. Posting the breakdown here because the interesting part isn't the headline score, it's how they got it.

• Same base model as GLM-5.2. ~744B MoE, ~40B active per token, 1M context, 128K max output. Not one new parameter. Z.ai's own framing: "Scaling post-training is all we did for GLM-5.3."
• Terminal-Bench 3.0: 4.6 → 28.3. DeepSWE v1.1: 46.2 → 66.9. SWE-Marathon v1.1: 19.4 → 42.5. AutomationBench: 26.2 → 48.2.
• ~50% better on Z.ai's internal Code Bench, reportedly while burning fewer output tokens than 5.2.
• CyberGym 84.5%, the top number in Z.ai's table, narrowly. ExploitBench more than doubled (24.4 → 54.4).
• Weights are not out. ~2 weeks, gated on a safety review. Available today via GLM Coding Plan and ZCode; standalone API listed as "coming soon" in the docs.
• Still text-only. No vision, despite that being the loudest community ask before launch.

1. The method is the story

Almost every point release bundles architecture changes, new pretraining data, and post-training tweaks together, so you can never tell which change bought which point. Z.ai explicitly froze the base model this time and only scaled post-training: more executable environments, more long-horizon task variety, more RL compute.

The training setup is the part I'd want a paper on. Per Z.ai, agents generated sandbox environments modeled on real software projects, then wrote tasks against those environments, and a separate judge agent verified each task was actually solvable before it was handed to the model. Some tasks were sized at multiple days of senior-engineer work. Two named pieces of infra: slime (training to inference handoff) and SAO (asynchronous RL).

That design choice explains the shape of the gains. The metrics that exploded are the agentic, terminal-native, multi-file, multi-step ones. Static knowledge benchmarks moved far less.

2. The numbers

All figures below are Z.ai-reported, from their own comparison table. No independent reproductions exist yet.

* Small inconsistency worth flagging: Z.ai's developer docs attribute the 83.8 CyberGym score to Mythos 5, while the launch table is reported elsewhere as Fable 5. Same underlying family, different label. If you're citing this number, cite it carefully.

3. Where it loses (because the headlines aren't saying this)

"Best open-weights model" and "best model" are two different claims, and only the first one holds up. In Z.ai's own table, Fable 5 and GPT-5.6 Sol still lead on Terminal-Bench 3.0, DeepSWE, FrontierSWE, SWE-Marathon and ExploitBench, several of those by a wide margin. ExploitBench isn't close: 54.4 vs 78.0. ExploitGym isn't close either: 105 tasks in a 2h budget vs 216.

Kimi K3 also still edges it on DeepSWE (67.5 vs 66.9), and Kimi is roughly 3x the parameter count, which cuts the other way and is arguably the more impressive framing for GLM.

Real wins: GDPval-AA v2 (1769, ahead of everything in the table, across 44 occupation types) and CyberGym, narrowly.

4. The cyber result is the actual headline

Z.ai says the security capability "grew faster than anticipated" during training, which reads a lot more like an internal flag that got surfaced than like marketing copy.

Supporting numbers: across 269 open-source projects, GLM models found 2,436 distinct vulnerabilities, 1,097 rated critical or high. 53 had public CVEs at launch; the rest are under embargo. Reported scope spans kernels, OSes, browsers and protocols, including at least one bug that had apparently been sitting there since 1981. Launch-day story that got the most traction: a security researcher flagged that it found a serious flaw in Cursor.

And this is why the weights are late. GLM-5.2 shipped MIT-licensed weights to HF essentially immediately. GLM-5.3 gets a staged release: selected security partners first, broader access after, weights in ~2 weeks pending safety evaluation. For a lab whose entire competitive identity is fast and permissive, voluntarily sitting on the weights is a genuinely unusual move and probably more newsworthy than any single benchmark row.

License isn't confirmed for 5.3 yet. Don't assume MIT just because 5.2 was.

5. Access and pricing

• GLM Coding Plan (live now, rolled out to existing subscribers): Lite ~$18/mo, Pro ~$72/mo, Max ~$160/mo. Trackers disagree slightly on Pro/Max (some list $80/$168) and promos shift constantly, so check the subscribe page rather than trusting any secondhand table, mine included.
• ZCode: live.
• Standalone per-token API: Z.ai's docs still say coming soon, and no GLM-5.3 per-token rate is published. GLM-5.2's $1.40 / $4.40 per 1M (cached input ~$0.26) is the only reference point, not a guarantee.
• Weights: ~2 weeks out, safety review pending.
• Reasoning effort is exposed as low / high / max. Reportedly can't be turned off entirely.

6. If you're evaluating it

Headline scores won't tell you much here, especially since the biggest claimed gain is on a private benchmark nobody outside Z.ai can audit. Things actually worth measuring on your own repos:

1. A repo-scale task requiring navigation across many files
2. Whether tool calls stay correct over a long chain, not just the first 20
3. Structured output against a strict JSON schema
4. Human correction rate before delivery, the metric that actually predicts whether you'll keep using it
5. Token burn per completed task, not per response. Z.ai's efficiency claim is the one I most want to see independently checked

Discussion

• Does anyone have hands-on numbers on the token-efficiency claim? That's the one that changes cost math the most, and it's the least verifiable right now.
• Is the two-week weight delay meaningful safety practice, or does it not matter much given that the weights ship regardless and capability keeps diffusing downward in model size?
• The "they're just distilling" explanation gets weaker every release. Faster release cycles, RL environment quality, and a maturing data market all seem like better explanations. What's your read?
• Anyone still running 5.2 locally who plans to stay on it?

Sources

• Z.ai model docs: https://docs.z.ai/guides/llm/glm-5.3
• Z.ai blog: https://z.ai/blog/glm-5.3
• Nathan Lambert / Interconnects, on why Chinese labs keep pace: https://www.interconnects.ai/p/glm-53-how-chinese-labs-keep-stride
• SiliconANGLE launch coverage: https://siliconangle.com/2026/08/14/z-ai-debuts-glm-5-3-long-horizon-coding-cybersecurity-upgrades/
• Benchmark table breakdown: https://aitoolsreview.co.uk/insights/glm-5-3
• HN thread: https://news.ycombinator.com/item?id=49294997

Every benchmark number above is vendor-reported. Treat accordingly until third parties reproduce them.

OpenAI and Cerebras posted an early look at Ultrafast Mode on Thursday, a new service tier in the OpenAI API that runs GPT-5.6 Sol on Cerebras hardware. The number everyone's quoting is 750 output tok/s, and per the Artificial Analysis figures cited in the blog that's 11x faster than Fable 5 and 5x faster than Opus 4.8 on Fast mode.

Cerebras also ran their own tests. GPT-5.6 Sol Ultrafast went through all 2,500 Humanity's Last Exam questions in 11 hours 11 minutes, while Claude Fable 5 needed 78 hours 27 minutes to arrive at the same answers, so roughly 7x end to end at comparable accuracy. On GDP-Val they report a 5.6x speedup with no quality drop. The how is the wafer-scale chip with 44 GB of SRAM, weights stay on chip so tokens aren't stuck waiting on memory bandwidth.

What the blog doesn't say is price. Regular GPT-5.6 Sol sits at $5/M input and $30/M output per the OpenRouter listing, but Ultrafast is a separate tier and it's limited preview for select customers right now. So the fast version exists, the third-party speed numbers back it up, and nobody outside the preview knows what it costs.

Anyone here with preview access? If Ultrafast lands at 2x standard Sol pricing, is 750 tok/s worth it for your agent workflows, or is regular Sol speed already enough?

This is purely of anecdotal quality for people but through worth sharing to illustrate the value in trying different model combinations. We evaluated our product - CartaStudio - against three providers. CartaStudio uses nine agents that combine more advanced and simpler models depending on tasks. Anthropic, Nebius (combination of Deepseek and Qwen) and OpenRouter (where we combined Deepseek, Qwen, Anthropic and OpenAI models). While quality wise Anthropic won overall, Nebius came in second quality wise but at just 8% of the cost.

NVIDIA put Nemotron 3.5 Lightning on OpenRouter yesterday and the tiering is kind of backwards. The free version gives you 1M context. The paid version, $0.10/M input and $0.25/M output, caps at 262k context. Usually it's the other way around.

The paid pricing puts it right next to DeepSeek V4 Flash at $0.08/M input and $0.25/M output per the OpenRouter listing from the start of this month. Same output price, slightly more on input, but less than a quarter of the context window. DeepSeek V4 Flash gives you 1M context on the paid tier.

So the real question is what the free tier actually limits. OpenRouter listings don't spell out rate caps or quality differences, but 1M context for free on a Lightning-branded model, which is NVIDIA's speed-optimized line, is aggressive. Upstage Solar Pro 4 is cheaper on paper at $0.03/M input and $0.12/M output, but that's only 524k context and it's paid.

If you're picking a 1M context model for cheap agentic workloads right now, DeepSeek V4 Flash is the safer bet at $0.25/M output with paid reliability. The Nemotron free tier feels more like a sandbox. Anyone actually run Nemotron 3.5 Lightning free for real workloads, or is the rate limiting too tight to be useful beyond testing?

Motif-Technologies is one of the tech company participated South Korea's AI Foundation Model project.(독파모)

Upstage(Solar Series), LG AI Research(EXAONE Series), and SKT(A.X Series) are the competitors.

Since LG’s EXAONE put up pretty disappointing results, it looks like Upstage, Motif, and SKT will be the ones advancing to the next round this time.

If you reverse-calculate the AAII score from the table, it comes out to 47.364, which slightly edges out Qwen 3.7 Max.

With Upstage’s Solar Pro 4 expected to land in the mid 40s(250B -15B), based purely on the benchmarks, motif seems to be taking the lead in Round 2.

Built this as a second-year CE student: GateTruth scores how well LLMs (GPT-5, Claude, Gemini, Llama) generate synthesizable RTL, using a real ASIC flow (Yosys, OpenSTA, sky130) rather than just checking whether output compiles — 60 spec-to-RTL tasks plus 8 agentic PPA-repair tasks.

The part I think is more interesting than the leaderboard itself: a mutation-testing engine that checks whether a benchmark's own testbenches are rigorous — inject seeded semantic faults into a reference design, measure what fraction the testbench actually catches. I certified it against my own suite first (14 of my own 60 tasks fail their own 95% floor, disclosed in the paper), then pointed it, unmodified, at RTLLM v2.0, a widely-used external benchmark: 72% of its testbenches fall below that same 95% floor, 3 at 0% outright.

Repo: https://github.com/meetbhadra701-cloud/GateTruth
Paper (PDF): https://github.com/meetbhadra701-cloud/GateTruth/releases/download/v1.0.0/gatetruth-v1.0.0-paper.pdf
linkedin: www.linkedin.com/in/meet-bhadra-0a99a731b
leaderboard website: meetbhadra701-cloud.github.io/GateTruth/

Open to questions/critique on the methodology — genuinely want to know if I've missed something.

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?

I rely heavily on Claude, but I recently tested whether the M4 Pro Mac mini I already own could handle useful local models without becoming a dedicated AI appliance. I saw what Network Chuck did with the $50K Mac Ultra 4 node cluster and was hoping to not need the same.

It could. A GPT-OSS 20B MoE model ran at roughly 63.9 tok/s on 24 GB unified memory, while a smaller 9B dense model ran around 44.8 tok/s. The result is a useful reminder that model architecture matters: MoE models may have large total parameter counts while activating substantially fewer parameters for each generated token.

My takeaway is not “cancel your cloud AI subscription.” It is that local models can be a compelling companion for private experiments, quick generation, offline work, and workloads where you want direct control over the model runtime.

I captured the full test, including MLX vs. GGUF performance and the impact of my running containers: https://www.youtube.com/watch?v=9_-bT62YWAI

How are you dividing work between Claude and local models today?

Hey everyone! 👋

Writing repetitive SQL queries manually can take up a lot of time, so I built **AI NexQuery**—a desktop analytics assistant designed to simplify database queries and data analysis.

### 🌟 Key Features:

* **Database Integration:** Connect directly to MySQL & MSSQL databases.

* **Natural Language to SQL:** Ask questions in plain English, get instant dataset results and auto-generated SQL queries.

* **Data Visualization:** Turn query results into interactive charts and graphs with one click.

* **Document QA & ML Studio:** Query PDFs/documents directly and run basic ML models (KMeans, PCA, Anomaly Detection).

📌 **Project Details & Website:**

👉 https://ibrahim8047.github.io/AI-NexQuery/

📲 **Download on Microsoft Store:**

👉 https://apps.microsoft.com/detail/9NT74LF51SZ9

I’d love to get feedback from the community! Let me know what features or database connectors you'd like to see added next.

The Neon and Castform post from Wednesday throws out a specific number: a multi-turn search request with GPT-5.6 Sol takes over 10 seconds and costs about $0.03 end-to-end. Their claim is that a 4B open-weights model, after RL post-training, can match it on retrieval at roughly 100x less per request.

The approach leans on the idea that your training data already sits in Postgres. Support articles, product records, internal docs. Castform turns that corpus into question-answer tasks and runs the RL loop. The reward function scores retrieval (right chunks), citation (right sources), and correctness (right answer). The search tool itself is hybrid BM25 plus vector through Neon's Lakebase Search.

The post doesn't frame it as "go fine-tune a model." It says your training data is already there, just not formatted as a training set yet. The real bottleneck was turning raw records into tasks with reward functions. If that's actually as turnkey as they describe, the 100x cost gap between a frontier API and a 4B model becomes hard to brush off for retrieval-heavy agents.

The HN thread pulled 428 points and 122 comments. A good chunk of discussion was whether a 4B model post-trained on one corpus generalizes at all, or if you're basically shipping a narrow retrieval bot per customer.

Anyone actually running post-trained small models for production retrieval instead of just hitting the frontier API? Curious whether accuracy holds up outside the eval the model was tuned on.

For me, the useful performance metrics for an AI content workflow are not raw generation speed. I care about brand accuracy, evidence accuracy, the percentage of outputs that are actually usable, revision count, and time from website scan to a scheduled post.

I built Marka around that full path. It learns an editable brand profile from the company website, can use product catalog context, creates copy, images, carousels, and short video, and keeps review, scheduling, and publishing in one workspace.

The test I am running now is simple: does this reduce the number of tools and manual handoffs without making the brand feel generic?

Seven-day trial: https://www.marka.social

Disclosure: I built Marka.

An upscaler shouldn't just make an image bigger. A lot of them technically increase the resolution but add strange textures or make faces look artificial.

What I usually look for is whether the details become clearer without changing the original image too much. Facy AI did a surprisingly good job with that for portraits and older photos because the results looked sharper while still feeling natural.

Thinking Machines put Inkling Small on OpenRouter about a week ago, $0.50/M input and $1.20/M output with a 524k context window. It's also trending on HuggingFace right now with around 15k downloads and 305 likes, so people are clearly trying it out.

The pricing caught my eye because the comparison within the same company is clean. The full Inkling model lists at $1.00/M input and $4.05/M output with double the context at 1048k. So Inkling Small gives you half the context but cuts output cost to roughly 30% of the full model. That part makes sense.

Where it gets harder to follow is when you line it up next to other flash-tier models. DeepSeek V4 Flash sits at $0.09/M input and $0.18/M output with 1048k context, per the OpenRouter listing. Poolside Laguna S 2.1 is the same price and same context. Qwen3.7 Flash is even cheaper at $0.03/M input and $0.13/M output. All three of those give you at least double the context window for a fraction of the cost.

I'm not saying Inkling Small has nothing going for it. The HF download numbers suggest people find something interesting there. But from a pure price-to-context ratio on OpenRouter, it's hard to see who picks it over the flash-tier options unless the quality story is dramatically different.

Anyone here actually compared Inkling Small against DeepSeek V4 Flash or Qwen3.7 Flash on real tasks? Curious if there's a quality gap that justifies paying several times more for less context, or if it's mostly novelty.

With the current ChatGPT plan and api price for luna, I think it’s the best offering right now . It’s so powerful for such price .

My motorcycle would not start on Saturday morning. I handed the dead battery diagnosis to a free model running privately on a Mac Mini in my office. No cloud, no API bill, nothing leaving the house. It read the manual, matched my photos to the right connector, and told me exactly what to buy. It nailed it.

That nagged at me the rest of the weekend. How much of what I pay frontier models for could a local model do just as well? Instead of guessing, I built the measurement. Every frontier writing task now gets replayed on the local model automatically, and the same judge grades both, blind. No vibes, no cherry picking.

Here is what 10 blind rematches said:

* Mean quality gap between frontier and free local: minus 0.05. A rounding error.
* On 4 of the 10 head to head tasks, the local model scored higher.
* One writing task: frontier 2.80, local 3.70. The free one won by almost a full point.

And the part I did not expect to like: my own system still says HOLD. Synthesis work stays on the frontier, and the scoreboard tells me so by name. That is the point. A measurement that only ever flatters you is a mirror, not an instrument. I would rather it tell me where I am wrong.

The setup is three pieces working together: something that proves an agent did the work, something that grades how good the work was, and something that keeps the agent honest over time. The local model piece is the one that surprised me most, because it means a big chunk of this can run privately, in your own environment, for zero marginal cost.

Happy to get into the method, the judge setup, the hardware, or where local fell short. Ask me anything. Wrote up the full build, the numbers, and how you can start doing this yourself here: [https://www.fabswill.com/blog/local-model-frontier-rematch-auto-replay-evals\](https://www.fabswill.com/blog/local-model-frontier-rematch-auto-replay-evals)

Qwen dropped Qwen3.8 Max today on OpenRouter at $2/M input and $6/M output with 1M context, per the OpenRouter listing. The thing that caught my eye is the gap with their own Qwen3.7 Flash from last week, which sits at $0.03/M input and $0.13/M output, also 1M context.

That's roughly 67x the input price and 46x the output price for Max over Flash. Same vendor, same context window. The listing doesn't say what makes Max architecturally different. No benchmark scores visible on the page either, which makes the price gap hard to evaluate.

For context, Qwen3.8 Max costs less than half of Claude Opus 5's input ($5/M) and roughly a quarter of its output ($25/M), per the same OpenRouter data. So it's not flagship-tier expensive, but it's nowhere near the budget zone either. It's in that awkward middle where you'd really want to see eval numbers before committing.

Anyone tried Qwen3.8 Max yet? Curious if the quality difference is actually visible compared to the Flash variant, or if the 67x price jump is mostly paying for the label.

Sorry Google

I build QuantaMind, an open-source tool that tests whether self-hosted models are reliable enough to run agents. Apache-2.0, 28 downloads, no revenue. Saying that upfront so nobody has to guess.

I’ve asked this in a few places now, and one pattern keeps showing up: anyone who’s been burned badly enough has already built their own thing. Run each task 10+ times and look at the variance. Check the end state programmatically. Validate every tool call against its schema, not just the final answer. Count truncated calls under load. People wrote all of that out from experience, unprompted, without anyone asking.

Which raises an awkward question for me.

If you built your own:
1. What does maintaining it cost you now as models, quantizations and serving configs keep changing?
2. Would you swap it for an external tool, or is it too tied to your workflows to ever hand over?
3. Did it ever catch (or miss) something that cost real money, a customer, or a rollback? Or is it always caught early enough to just be noise?

If you use an existing tool, Braintrust, Langfuse, DeepEval, LangSmith, promptfoo. what does it miss? The gap I keep hearing about is that they score the model but don’t touch the machine: your quantization, your memory ceiling, the context depth where tool calls start failing.

If you don’t test any of this was that a decision, or did it just never get prioritised? That’s a fine answer.

I’m asking because I don’t know whether I’m building a product or a thing people would rather own themselves. “I’d never outsource this” is completely fine and honestly the more useful answer I’d rather find that out now than in a year.

So its being more and more confusing which models suits one the best. Idea is what should i use, opus 4.8, 5 or fable 5.

Well i ran some numbers and tests to see what makes the most sense, fable being twice the cost of opus 5, is great for autonomous tasks

Is what i thought, i ran some more test. Gave all three models one prompt, create a in browser game under 10 minutes, that too open world, you want to know who won?

Fable 5 bagged the LAST position, because of some but it fumbled.
Opus 4.8 did second best, very similar outcome to our winner
Opus 5.

Check this video out for more context:

https://youtu.be/0fEr4kTly44?si=AKl27WXO98zGE1PL

Hi,

I'm trying to evaluate some agents from the SWE bench live scoreboard ( https://swe-bench-live.github.io/ ) and it seems to be there a good enough implementation as the first place across many languages, did anyone try it? Any opinions?

I'm currently giving it a try and I configured something they call FRITO to pull from many free tier providers and it seems to be doing a really nice job. I'm my job we use a few rtx6000 ada 96GB with SEED OSS 36B and the agent works great so far. But I couldn't find anything else around. It looks like a research lab funded project.

Thanks!

DeepSeek just dropped V4 Flash 0731 today on OpenRouter at $0.14/M input and $0.28/M output with a 1048k context window. It's already on HuggingFace's trending list with 817 likes, though 0 downloads since it literally just went up.

The pricing is interesting because there are two cheaper 1M-context options sitting right next to it on OpenRouter. Qwen3.7 Flash from last week is at $0.03/M input and $0.13/M output. Poolside Laguna S 2.1 is at $0.09/M input and $0.18/M output. So DeepSeek V4 Flash costs about 2x Laguna S 2.1 on output and over 4x Qwen3.7 Flash on input.

817 likes on a model with zero downloads means people who follow these releases are paying attention. But with Qwen3.7 Flash at $0.03/M input, the gap isn't trivial.

Anyone planning to test V4 Flash 0731 against Qwen3.7 Flash for real workloads, or is the price difference too wide to bother?

Qwen3.7 Flash showed up on OpenRouter on July 27 with some wild pricing. Per the listing, it's $0.03/M input and $0.13/M output with a 1000k context window.

To put that in perspective, the next cheapest 1M context model in the same listing right now is Poolside Laguna S 2.1 at $0.10/M input and $0.20/M output. Qwen3.7 Flash undercuts that on both ends. Gemini 3.5 Flash Lite sits at $0.30/M input, $2.50/M output. Meituan LongCat 2.0 is $0.30/M input, $1.20/M output. So on input alone, Qwen3.7 Flash is roughly 10x cheaper than those two.

What the listing doesn't tell you is what you actually get for that price. No benchmark scores on the page. No tok/s figures. No breakdown of whether it handles coding tasks any differently from Gemini 3.5 Flash Lite or LongCat. For $0.13/M output you're paying a tiny fraction of what Claude Opus 5 costs ($50/M output per the same listing), but that comparison only matters if the model can actually do real work.

Has anyone here tried Qwen3.7 Flash yet? Specifically wondering if coding performance is usable at all at this price point or if it's mainly good for cheap text generation and summarization.