What if I told you you could get Opus level reasoning at a fraction of the cost? That's what we're going to see and test today when I take a look at GLM 5.2. This is our first of many reviews of OpenWeight and Open source models to see if we should all be paying the tax to anthropic and OpenAI or if we can run these models locally and get the same results. Let's dive in.

GLM stands for general language model and this is a model that's put out by the Beijing based startup Z.AI. So yes, this is a Chinese trained model. Now this model is open weight. You may have heard that term before but not exactly known what it means. And all it means is that the trained model weights are publicly available for download which allows you to run it on your own hardware. You can fine-tune that model on your own data and you can kind of inspect how it works. Now, the licenses for open weight models kind of depends. So, it doesn't necessarily mean you can use it quote unquote for free. But why this matters for GLM 5.2 is you can self-host this. So, let's say you have one of those chunky Mac studios at home where you want to run some models locally. You could potentially run GLM 5.2 locally. You can fine-tune it, which means you can adapt it to your purpose. And then the thing that people really love about these openweight models is they're cheap. You can run your own inference and so it can be much more affordable than API cost from anthropic or open AAI and two you're not logged into a vendor so if a specific vendor changes their API terms you can actually change what provider you use.

Now why should you be paying attention to GLM 5.2? Well, this is what I'm hearing from the breathless AI bros, and I guess again I am a breathless AI brother, is that GLM 5.2 is getting people sort of opus level intelligence or GPT5 whatever intelligence for a fraction of the cost and the ability to be self-hosted. If this is true, this is a very big deal. As we've seen, we can't always rely on the big model providers for consistent model access. And these hyper intelligent models from the frontier labs are getting very very expensive. And so any models where open weights models are catching up to the intelligence of open AI models, anthropic models, especially for coding use cases which can be quite expensive is something to pay attention to.

Now, let's look at the benchmarks and capabilities of the model and then I'm going to dive right into actually using them. So, a couple of things you should know about GLM 5.2 just to pay attention to is its context window is big. It has a million token context window. So, that's sufficient. But one limitation is it only takes text in and only takes text out. So, you can't put an image, you can't get out images. It is a text-to-text model. That is one constraint of this model. That being said, it has all the capabilities that you should expect from a modern-day model interface. It has reasoning or thinking mode. It can stream its outputs. It can call functions. It can do context caching to make things more efficient. And it can output structured output and use MCPS. So, at the end of the day, this is a very capable model with the right ergonomics that we've gotten used to.

Now, what do we see from the market benchmarks on this model? So, as you see here on Frontier, SUI, Post Train Bench, and SU Marathon, it's inching up there to Opus and right above GPT 5.5 on a lot of these benchmarks. And if you look at Swebench Pro, you can see it's about on par with GPT 5.5 and almost up to Claude Opus 4.8, certainly beating Gemini 3.1 Pro. So, if you look at it against these models that we've all come to know and love, it's in the arena. It's definitely worth testing out. And the external benchmarks say this is a model with enough intelligence to attack some of our hardest coding problems. So, what I'm telling you is you can get this openweight model where you can inspect how it's actually built. You can run it locally or at least more cost-efficiently on your own inference or your selected provider's inference and it's going to code just as well as Opus4.

So, how do you actually get GLM5 in your coding stack? Let's say you're completely new to all this openweight model stuff and you want to figure out how to run these in cla or in cursor. I'm going to show you cloud code and cursor. It basically applies to codecs as well. I'm just going to give you those two examples because I think that's going to cover most of your use cases. So, first you need to choose where you're going to get your model from. And I'm still using a hosted API version of GLM 5.2. My little laptop's not going to run this thing locally. And so, I've chosen to use Open Router, which is a unified interface for getting access to a lot of different models, both commercial and open weight and open source. So, I signed up for an open router account. And then all you need to do after you've signed up for an open router account, give them your credit card, set a limit if you want to, and just set up an API key. So, I set up an API key and now I have access to this model via open router.

Okay, setting GLM 5.2 up in cursor is super easy, though it took me truly about 30 minutes to figure out the nuance here. No one has documented it. We'll put in the blog post and the show notes for you. But all you have to do is go into your cursor settings and click the models tab. And then you need to do two things. First, you need to put your API key from Open Router here in the OpenAI API key field and toggle that on. And then secondarily, you need to override openai base URL with this very specific URL. So it's open router.ai/v1/cursor. I could not find anything for a really long time that told me it had to be /cursor, but it is /cursor. And you need to toggle that change on. The second thing you need to do is add Z-IGLM-5.2 to your models. So you simply click view all models, you add a custom model, you add that field in and you will be able to access this model.

There is luckily a little bit more instruction on how to do this for cloud code. And so there is this page on open router the docs page that shows you how to connect claude to open router and then I'll show you how to connect your specific model for cloud code. It's pretty simple as well. You need to get your open router API key and that URL which they have here and you need to add to your shell profile. So for people who are not super technical who have just cla coded their way into terminal, your shell profile is the file that manages your settings in the terminal. It's going to like instantiate a bunch of environment variables. It's going to set a bunch of settings. And so you need to edit your shell profile. It's usually zrc or bash rc depending on what profile you use. And add these lines right here to that file. You can also, this says open it in nano. If you're not feeling fancy, you can just find this file in your finder or in your file directory and open it in whatever code editor of choice and add these lines which include your open router API key, the base URL which does not contain /cursor. It's just open router.ai/ API and your off token here. And then you clear the default off token for anthropic. The second thing you need to do is edit your quad settings.json which is includ settings.json. You can open up again in whatever code editor you want and change your model to the GLM 5.2 string from open router. So here I've put it in. And so with those two things, any cloud code session that I open up will have the open router API key. It will route all requests through that open router API key and it will set the model to GLM 5.2. There's a very similar process that you'd follow for codeex, but the TLDR of setting up your cursor cla codeex with a new open weights model is to find a provider, switch out your API key and route all your model calls to that new model.

So, the first thing I'm going to do is just see how good it is at exploring an existing codebase and telling me a little bit about it. So, I'm in the chat pd codebase and I'm just going to say here, this is the chat PRD codebase. Please explore it and tell me a little bit about its architecture and the most recent things we have been shipping on this codebase. So this is going to go through my codebase and we're just going to explore how good it is at independently auditing, reviewing, and understanding the structure of a codebase from zero. This is one of the most common tasks that you would do as a software engineer is really getting oriented. And it's a good reflection of its ability to run autonomously, its ability to use its context window effectively, and its general sense as a software engineer. It was actually pretty fast and it came back with a pretty good overview. So, it is a next app. It's got the full stack. It's got a nice architecture here of what it looks like. It's talked about different integrations we have and what we've been shipping in the last six week, which is our chat v2 stability. Absolutely. And then some billing and Lenny promo stuff that we've been working on as well as security and dependency hygiene. So this is actually pretty correct. It was very fast and very accurate.

Let's make it something that we can visualize a little bit more and see if it does a good job communicating agent to human. And we all know that this is the year of HTML. So I'm going to say turn this into an HTML page that can communicate the overall architecture of the app and give a sense of the upcoming road map. You can use whatever components you want to make this look good and communicate to me the end developer the major pieces of the architecture and product strategy. Give me a page to pull up when it's ready to review. Okay, it's creating this HTML page for me. It's told me to approve the HTML. I'm going to pull it over cuz it does not look bad, you guys. Um, so this is the chat purity architecture and road map review. Right out the gate, it's like slop adjacent. We have blurpal on here. That's that blue purple indigo color that we love, but it's not ugly. So, let's take a look at the content. Well, at the high level, it does look correct. Wow, we've merged almost 3500 PRs. We've done a lot of PRs. It's giving me a good overview of the core pieces. Oh, this is really great. This is the anatomy of a chat turn. So how the core piece of our application actually works, some product pillars which are our chat, our integrations, documents and collaboration as well as billing which also sounds correct. And then it's given me a list of recently shipped things and then road map and direction. This is actually the piece where I'm most uh impressed. One, this looks real cute and it got the chat PRD pink which not all models get. GPT wants to give me these like ugly green and navy colors. Claude wants to give me clawed orange all the time. But look at this GLM gaming chat PR pink. I'm very happy. And so it's given me what we're working on in flight. And then let's see what it suggests should be up next for our road map. Integrations partnership and enterprise motion cost and performance and then knowledge and retrieval. Spoiler alert, these are actually the things that we're working on and a couple conventions about writing our code. Um, which is quite nice. So, I don't know guys, this is pretty good. This is the first time I've run an open weights model inside Claude Code and I have to say I am quite happy about it.

So what I have up here is the ChatPD website, but specifically our how II landing page and blog where we put every single episode and a summary of those episodes up on our chat PRD blog. So, this is a pretty highly trafficked part of our site. And we redesigned this a couple times using AI, but I want to do it again. And there's a specific piece of this page I don't really love, which is this header section. And so, we're going to have GLM 5.2 just make a pass at redesigning this header section. And let's see how it does. So, I'm going to say here, let's redesign the header hero section of the How I AI landing page where all the How I AI blogs are the part that says AI workflows and stories from the experts through the cursor credit claim. I want to redesign it so it is higher quality design. It is a better call to action to workflows and it helps with anything we need on SEO. Design whatever you like. Looking forward to what you make. Now, I've told it to redesign this hero section. It's going to run it through this new model, and we're going to see if its ability to redesign even a small section of the page will give us AI slop or if it will give us something a little higher quality. And the reason I like to test on the chatd marketing site is it has an existing design system and there are specific things that we really like to see in chaturd design. So this will be a good test to see whether or not it can match to an existing design system versus generating a completely novel design like we saw in the architecture overview.

Okay, it says it has a plan and executed that plan. Let's look at it. You know, I don't hate it. I don't quite love it yet, but it's not bad. What do I like about it? Well, I like the fact that the AI workflows as requested are a much better call to action. It also has this nice hover effect on it. I do like that it put sort of some metadata here and some value propositions on who it's for, how frequently we drop, and how many episodes we have. And I do really like this little sidebar widget um that makes the listen to the show, the calls to action to YouTube, Spotify, and podcasts, Apple Podcasts, look a little bit more like a player. I'm not sure what this little square in the corner is. And then I do think this copy here is it might be what it was before, but looks pretty good. I would just say I don't love fully all these colors in the sidebar player. So, I'm going to give it that feedback and say I really like this except for the listen to the show sidebar. YouTube, Spotify, and Apple Podcast are very bright buttons. They're super overwhelming and they're very wide for the text that's in it. I think this component could look a lot higher quality and a lot better for our specific design system. Can you take another pass? Let's see what it comes up with. But I will say for the speed and for certainly the cost, this does not make me unhappy. And I think we would all question how much intelligence do we need to put towards this specific problem. And as long as the model has good taste, I don't need to be fancy and use the most expensive one. So, I would say just first glance, first pass. GLM 5.2 is pretty good at design stuff. And maybe we should all be switching over to it, especially if you're anchoring in something like a design.md or other design guideline or design system where the model can really anchor on it. I do like this a little bit better. It went with a sort of black uh call to action, a lot more subtle and a lot smaller, but there's some misbalance between the left and right. But again, it's pretty fast. In fact, it's almost as fast as Composer is, which is a model by Cursor that I use really frequently. And so, I think this is pretty good. And I would definitely put GLM 5.2 in the rotation for design work.

Let's wrap with a much more complicated use case though which is a longrunning autonomous use case. So part of how GLM 5.2 has been advertised is that it is a very agentic model that is capable of handling very longrunning autonomous tasks and solving those over time very similar to the claims about opus and GPT 5.5 or whatever. And so I gave it a common task that I like to give a lot of my longrunning models, which is pulling issues and error logs and then making a plan for fixing those error logs and ultimately shipping those fixes themselves. And so before I started this podcast, I started with this specific prompt, which is pull the last 72 hours of century errors and versel error logs and build a prioritized plan of bug fixes based on observed issues. And so this has been running the entire time I've been recording this podcast, probably about 30 45 minutes, even though you all will get a much shorter cut of this episode. And you can see here it did the thing that most models do, which is it built a to-do plan. It ran tool calls and MCP calls. It read the output. It actually asked me to off into versel. So that was great. It ran several versell calls. And now it is putting together a plan in HTML I believe for us to review and decide if these are the priorities for chat purity.

Okay. quick intermediary peak from the reasoning minds. It is really struggling to write TypeScript. So while it can do a long running task, it is having some TypeScript errors. So we may be sitting here for a while waiting for it to write the plan as opposed to its intelligence on getting the plan. So hold tight. We will be right back and I will give you my opinion whether all this waiting was worth it. Oh my god, guys. It really is having trouble writing JavaScript right now. I can't. So, so okay, we got over the hurdle of it can write HTML. Is very good at writing HTML. The HTML and CSS is welldesigned and looks good. I think it can query tools and look at data very well, but I don't think it can write React, which is 98% of what I do with these models. So, if this is a failure state, we're going to have some trouble. Oh, it compiled cleanly. I spoke too soon. I just had to complain to the model gods. And we are back. It's going to clean this up and hopefully show me its plan on how to fix all the errors in chat beardy.

Okay, here we are. It pulled the last 72 hours from both sources and built a prioritized plan in a canvas. I can open. Here is my canvas. Again, it does not look bad. I love that it's for an engineer. So, they made it in dark mode. It says we have 20th century errors, five versell log signals, 14 planned fixes, and then gave me two P zeros. Not happy about that. This is something that was not coming through on um the signal to noise ratio on some of our Sentry issues. So, we will fix that. And then we need to look at this. I think this is a legacy Google Drive integration, but we will take a look at that as well. It's given me events by volume and then um runtime log signals and whether or not they are high severity or low severity and then gave me this beautiful prioritized fix plan. Y'all, I was really disappointed by its speed in writing React, but this is exactly what I need. This is super helpful. It even looks like it's supposed to be part of cursor, which I really love. And I can go through and start to rock through these fixes. It even gave me suggested sequencing. I'm not mad. So, I spoke too soon being disappointed about the performance on this longrunning task. I actually think it's pretty good and I think I'm going to ship all these fixes.

So, what's my takeaway with GLM 5.2? It's good. I would use it for front-end work. I would use it for longrunning backend tasks. And the test that we were testing is how much did it cost me? And if you pull up Open Router and your usage on this API key, I spent $3.36 on about 6 million tokens. Cash rate was pretty good at 72%. I spent most of those tokens on that 45-minute longrunning task in cursor to find all my issues in century and versel and just a few in claude code. But if you compare this to the cost of an opus or a GPT 5.5, this is a steal. So I think I'm going to keep it running in cursor for a while. Think I'm going to keep it running in cloud code for a while. I'm going to see if it can handle most of my tasks and maybe I'll have to buy some more hardware and start running this stuff locally.