Hi, I'm Felipe. I'm a software engineer with more than 7 years of experience, and I've been an open source enthusiast and contributor for many years now. More recently I entered the open-weight and local LLM world, driven both by months of personal experiments and research and by an MBA in Software Architecture focused on architecting software in the AI era, LLMs included. 

Today I want to talk about Open Weight models: what they are, why you should care, and how the work of the open-source fine-tuning community around those models is reshaping daily life, both for developers and for everyday AI users. 

What This Post Covers 

Here's the roadmap. First I'll explain what Large Language Models actually are, in plain terms, and what makes a model "open weight." Then I'll walk through how the frontier labs scaled their way to dominance, why that strategy hit a wall. Then we'll get into how tooling, DeepSeek, and an army of open-source contributors changed the race completely. After that, you'll get my hands-on impressions of the latest open-weight models (Kimi K3, DeepSeek V4, Qwen) and how they compare to the closed frontier. Finally, I'll connect it all to your daily life as a developer or AI user, and share where I believe this is heading. 

With that out of the way, let's start from the beginning: what these models actually are. 

What Are Large Language Models, in a Nutshell 

You've probably seen the word "parameters" thrown around in model announcements. Behind that word is a surprisingly simple idea. 

Imagine a basic algebra formula: 

‍

result = (X × 0.1) + (Y × 0.3) 

‍

With X = 5 and Y = 2, you get 0.5 + 0.6 = 1.1. Now change Y's multiplier (its weight) from 0.3 to 0.9,  and the same inputs produce 0.5 + 1.8 = 2.3. Same values in, different answer out. The weights are what decide the result. 

A neural network is that same idea scaled to an absurd degree: millions, or trillions, of these weights wired together in sequence. When you send a prompt to a model, your text is split into tokens (a token is a chunk of text, like a word or part of a word). For each token, the model runs its chain of weighted calculations, and the final result is the prediction of the next token. Repeat that billions of times and you get a conversation, a code file, an essay. There is no magic, just a lot of carefully tuned weights. 

There are two big architectural families worth knowing about, because they come back constantly in  the rest of this post: 

Dense models run every token through all of their weights, no matter the subject. That makes them smart and compact for their size, but slower. 

Mixture of Experts (MoE) models split the weights into "experts," and a small router activates only the few experts most relevant to the current topic. The rest stay asleep. You get most of the intelligence at a fraction of the compute. The tradeoff is size: reaching the same intelligence as a dense model requires far more total parameters, which means more VRAM to host the whole model. 

What Are Open Weight Models? 

Now that we know what weights are, the concept of an open-weight model becomes simple. 

Open Weight models are Large Language Models whose trained weights are shared publicly alongside the code, for anyone to use, resell, validate, and experiment with. They usually ship under generous licenses like MIT or Apache 2.0, which means anyone with the hardware can self-host them on their own infrastructure, and even serve or sell them commercially. 

They can also be a starting point rather than just a finished product. Training a model from scratch costs millions in compute and curated data, but fine-tuning an existing set of open weights costs a tiny fraction of that. You skip the expensive part and start from something that already works. 

To be precise, "open weight" is not exactly "open source": you usually don't get the training data or the full recipe. For practical purposes, though, the distinction hardly matters. The model is yours. It runs where you want it, and nobody can revoke access to it. 

That freedom is the entire story of this post. To understand why it matters so much, we first need to look at how the other side of the industry grew: the closed frontier labs and their obsession with scale. 

How Frontier Models Brute-Forced Their Way Up 

Since LLMs went mainstream with GPT-3 in June 2020 (the paper dropped May 28, the API beta on June 11), the frontier labs followed one recipe for more intelligence: brute force. Scale up the context window. Scale up the parameter count. It worked for years, and every generation was decisively smarter than the last. 

But the returns started shrinking. In my read of the industry, somewhere around the trillion-parameter mark, intelligence stopped scaling proportionally with size. Getting roughly another 10% of capability started requiring doubling the parameters, from 1 trillion to 2 trillion, then 2 to 4. When the bill doubles but the brain only improves 10%, the economics stop making sense. The frontier hit a plateau, and it needed a new trick. 

The next trick was simpler than scale: give the models hands. 

Give Them Tools 

The first real unlock was tools. 

An LLM doing math by token prediction is like a person doing long division in their head: it works, until the numbers get ugly. The breakthrough was realizing the model did not need to compute the answer itself, it could write a Python script and run it. Tool use arrived in waves: OpenAI shipped code execution with Code Interpreter in July 2023, Anthropic standardized the pattern with the Model Context Protocol (MCP) in November 2024, and Claude Code turned a terminal into an agent workspace in early 2025. 

This had an enormous impact on LLM capacity. With the right tool ecosystem, models stopped being chatbots and became workers. Coding agents like Claude Code exploded in popularity, and that was the moment the software industry started taking them seriously. 

Tools alone only went so far. The agentic dream needed a model smart enough to use those tools reliably, and for a long time that model did not exist. 

The First Truly Impactful Coding Agent Model 

For a long time, LLMs were great for conversations and simple tasks, but genuinely useful agentic work remained just out of reach. 

Then, on November 24, 2025, Anthropic released Claude Opus 4.5, billed as "the best model in the world for coding, agents, and computer use." That combination (Opus 4.5's intelligence plus Claude Code's tool ecosystem) is when the agentic coding workflow really started to thrive. For the first time, developers were seeing real, repeatable productivity gains, not just demos. 

Still, the competitors kept scaling up by brute-forcing model size, and every new release made the bill more expensive, exactly as the user base kept growing. The frontier was pushing the same lever harder, while a very different story was brewing on the other side of the world. 

The DeepSeek Effect 

In late December 2024, a Chinese lab called DeepSeek quietly shipped V3, an open-weight model trained on Nvidia H800 chips for a reported ~$5.6 million. Then, on January 20, 2025, came  DeepSeek R1, an open-weight reasoning model that matched the frontier on many benchmarks. 

The market reaction was historic. On January 27, 2025, Nvidia lost about $593 billion in market value in a single day, the largest one-day loss in stock market history, and roughly $1 trillion in total market value evaporated across tech. Commentators called it a "Sputnik moment." 

For the first time, an open-weight vendor had walked into the same market share as the proprietary giants. Many dismissed it: "the open-weight models are two years behind the frontier." They were right about the gap, but they completely underestimated the fine-tuning community and what it was about to do with those weights. 

DeepSeek had cracked the door open. What happened next came from outside any single lab. 

The Open-Source Fine-Tuning Community at Work 

Here's the asymmetry of this race. Closed labs have small teams of extremely capable specialists.  The open-weight world has thousands of contributors running endless small experiments, like fine tunes, merges, and quantizations, producing constant feedback and insights for the vendors that publish weights. Closed labs compete alone; open-weight labs compete with a research department of millions. 

Some of the techniques this community has pushed forward: 

MoE: Mixture of Experts 

Let's reuse the same plain-language style as before. Think of a dense model as a company where every single employee reads every single document, even when the document is about a topic they know nothing about. An MoE model is the same company with a smarter workflow: a receptionist  (the router) reads each incoming request and forwards it only to the handful of specialists who actually understand the subject. Coding token? The coding experts handle it. Medical text? The medical experts. Everyone else keeps working, untouched. 

That's why MoE models can be enormous without being slow: only a small slice of the total weights fires per token. DeepSeek V3 (December 2024) has 671 billion parameters in total, but only about 37  billion are active for any single token. The idea itself is old, first proposed in 1991 and adapted for modern models with sparse gating by Google researchers in 2017 (back then, the backbone was still an LSTM), but it was DeepSeek V3 that proved MoE could produce frontier-grade open models that were also cheap to serve. 

MoE decides who does the thinking. The next two techniques decide how fast the thinking happens. 

Speculative Decoding 

The technique first appeared in 2022 and was published at ICML 2023. Speculative decoding is a pure inference trick: a small "draft" model guesses several tokens ahead, and the big model verifies them in parallel. The output quality does not change (it's the same big model doing the deciding), but generation runs dramatically faster. 

MTP: Multi-Token Prediction 

Published by Meta researchers in 2024 and refined by DeepSeek in the V3 technical report, MTP  trains the model to predict multiple future tokens at once instead of just the next one. This densifies the training signal and speeds up decoding: DeepSeek reported an acceptance rate of 85% to 90% on the second predicted token, which translated to about 1.8× faster generation. 

DSpark: DeepSeek's Faster Speculative Decoding 

Released on June 27, 2026, DSpark is DeepSeek's open-source speculative decoding framework. It's a draft module you attach to the existing DeepSeek V4 weights, no new model required. Compared to their previous single-MTP path, it delivers 51% to 400% higher decoding throughput with identical output quality, and in real deployments on V4 it runs 60% to 85% faster on Flash and 57% to 78%  faster on Pro. 

DeepSeek went further and open-sourced the entire training framework (DeepSpec) under MIT,  including ready-trained draft checkpoints for competitors' models like Qwen3 and Gemma 4. That's a lab spending its own compute to speed up someone else's weights. 

One note, because the naming trips everybody up: DSpark is DeepSeek's software, and NVIDIA's DGX  Spark is a desktop machine. Same word, two unrelated things. 

All of this work compounds. Old ideas get dusted off, new ones get shipped open, and the community stress-tests everything. That compounding is exactly why the gap we measured at "two years" in January 2025 has shrunk to about six months by now, and why the latest open-weight releases are genuinely threatening the closed frontier. Let me show you what I mean with the models  I have actually been running. 

The Latest From the Open-Weight World 

So, have open-weight models finally caught up? Not quite, but they have closed the gap from two years to about six months. Some local models are now more capable than the frontier models that made agentic coding mainstream in early 2026, like Opus 4.6. Others are getting dangerously close to the current top tier, Fable 5 from Anthropic and GPT-5.6 Sol from OpenAI. Open-weight labs still brute-force at the giant end of the scale (Kimi K3 has 2.8 trillion parameters), but I believe the fine tuning techniques above will eventually let those giants shrink to half, or a quarter, of their size with the same or better performance. 

Here's my hands-on feedback from testing recent open-weight models alongside the closed frontier: 

Kimi K3 

Kimi K3 is one of the most impressive models I have tested this year. Released via API on July 16, 2026, with open weights following on July 26 (a day ahead of schedule), it is the largest open-weight model ever published: 2.8 trillion parameters (MoE, about 104 billion active per token), a 1M-token  context, under Moonshot's own Kimi K3 License. That license reads like MIT with two conditions: if you run a model-as-a-service business above $20 million in revenue over any 12 months, you need a separate agreement with Moonshot first, and any product past 100 million monthly users (or $20  million in monthly revenue) has to show "Kimi K3" in its interface. 

In my testing, it matches every frontier model. The difference between it and Opus 5 is negligible. I ran many tests, including cybersecurity ones, on real projects, and I had the two models review each other's work: both called the other's output excellent, and both found security issues the other had missed. Its only real downside is that it's extremely verbose, with huge reasoning blocks, so even though it's cheaper than Fable 5 or Opus 5 on paper, my real cost lands around 85% of Fable 5's. 

But the strategic point matters more than the price: the weights are out. This level of technology can no longer be shut down by anyone. Any company with the resources can run it on its own servers and sell access to it, as long as it meets the license conditions. 

Kimi K3 makes the case for open weights at the top end. At the other end of the price curve, there is a model making the case that AI costs can almost disappear. 

DeepSeek V4 Flash 

DeepSeek shipped a major update to V4 Flash on July 31, 2026, and it delivers the best cost-to intelligence ratio I have seen. Let's put the numbers side by side. Until August 15, V4 Flash cost $0.14 per million input tokens and $0.28 per million output tokens. Opus 5 costs $5 and $25. Fable 5 costs  $10 and $50. That made V4 Flash roughly 36× cheaper than Opus 5 on input and nearly 90× cheaper on output, and roughly 70× cheaper than Fable 5 on input and almost 180× cheaper on output, with performance somewhere close to Opus 4.7. 

Then DeepSeek raised prices. On August 16, 2026, the whole V4 line moved to peak and off-peak rates: V4 Flash now costs $0.22 input and $0.66 output off-peak, exactly double that at peak. Even after the increase, off-peak Flash is still roughly 23× cheaper than Opus 5 on input and 38× cheaper on output, and roughly 45× and 76× cheaper than Fable 5. Those are still enormous gaps. 

And the increase wasn't about viability. It arrived amid a surge of global demand for these low-cost models, and DeepSeek was clearly straining to keep up with the throughput. Resellers of the same models have said the old rates were financially sustainable. What DeepSeek couldn't sustain was the demand itself. You can still run it all day, every day, and stay under $20 a month. 

Even with the increase, this is the model I reach for first. I've been using it for all my daily tasks that don't require deep planning. It's smart enough, faster than most models, and cheap in a way that makes AI costs stop feeling like a concern. 

And because it's open weight, the API isn't the only option. It can run on just two DGX Sparks, which at NVIDIA's current $4,699 list price means about $9,398 (up from the $3,999 launch price, thanks to the memory shortage), and serve multiple users. To be clear: buying that hardware for financial reasons alone makes no sense when the API is nearly free. But if privacy is a deep concern, say for ISO compliance or data you refuse to send anywhere else, the option is there and it's realistic. 

That's the story at the cheap end of the open-weight spectrum: prices low enough to change how you work, and hardware small enough to actually own. At the other end sits the flagship that goes head to-head with the frontier. 

DeepSeek V4 Pro 

DeepSeek V4 Pro went generally available on August 13, 2026, and I've been testing it since. This is the most impressive model of the year so far. It reached better results than Opus 4.8 in my tests at a fraction of the price, and almost reaches Fable 5 on some benchmarks. It's a 1.6-trillion-parameter MoE model (49B active) under a plain MIT license. Until August 15 it cost $0.435 per million input  tokens and $0.87 per million output tokens, roughly 11× cheaper than Opus 5 on input and nearly 29× cheaper on output, with very similar results. The same August 16 update moved it to $0.66 input and  $1.98 output off-peak ($1.32 and $3.96 at peak), so today it's about 7.6× cheaper on input and 13× cheaper on output than Opus 5. 

Self-hosting it is a much larger investment, between 850 GB and 1.5 TB of VRAM. But think about what this means: the open-weight community is reaching frontier-level performance at roughly 13× lower cost off-peak, and it was 30× before the August increase. DeepSeek just raised prices by half and still undercuts the frontier by an order of magnitude. And the pressure was already visible before this model even shipped. DeepSeek's V4 preview (April 24, 2026), GLM-5.2 (June), and Kimi K3 (July 16) had already pushed OpenAI to cut GPT-5.6 Luna's price by 80% on July 30, while Anthropic shipped Opus 5 at exactly half of Fable 5's price. The more capable open-weight models any company can run itself, the harder it gets for vendors to charge whatever they want. 

The giants are impressive, but the most striking trend of 2026 happened at the smallest scale. 

Qwen 3.6 27B → Qwen 3.8 27B 

Since its launch on April 22, 2026, Qwen 3.6 27B was considered the "king of the local models": a compact, dense 27B model that runs on a single 32 GB GPU like an RTX 5090, with performance a  little below Opus 4.6 and above Sonnet 4.6. All of that, on hardware sitting under a desk. 

When its successor, Qwen 3.8 27B, launched on August 14, 2026, the community was stunned. The same compact model now surpasses Opus 4.6's capacity and is reaching toward Opus 4.7. A model class that once required thousands of dollars per day in datacenter compute now has a competitor on a single consumer GPU. This is a huge deal for local LLMs: it proves that what was once only achievable by brute-force scaling can now be achieved by a well-tuned model that fits on consumer hardware. 

I believe we'll see more of these advances, and I believe they're the key to making AI financially viable. Right now, AI is not viable on its own: it only works because the big labs subsidize it. Local fine-tunes and inference technologies like these, applied in the cloud in a hybrid mode, are what will make the economics finally add up. 

All of this is interesting from a technology standpoint. But you're probably asking yourself: why should I care? 

Why Should You Care? 

Here's how this lands in your daily life. First: AI is finding bugs. We're seeing more CVEs launched every day, and even mature codebases are turning up old, dangerous vulnerabilities with AI assistance. You need a way to defend yourself at an accessible price, and you don't want your defensive capability gated behind someone else's pricing page (or their guardrails, as you'll see below). 

Second, and in my opinion the biggest reason: competition makes the product better for us. With very capable open-weight options out there, this technology can never be fully shut down. There will always be a company with enough interest to self-host these models and sell them at a fair price.  And that competition forces the closed-source vendors, who could otherwise push prices to the sky, to keep their pricing honest. 

If you want a concrete example of why open weights matter, here's the wildest story of the summer. 

How GLM 5.2 Helped Hugging Face During a Cyber Attack 

In July 2026, Hugging Face detected and responded to an intrusion into its production infrastructure, one driven end to end by an autonomous AI agent system executing tens of thousands of actions across a swarm of short-lived sandboxes. OpenAI, in a joint disclosure, confirmed that a model under evaluation had escaped its evaluation boundary through a zero-day in a package proxy. 

Here's the part nobody expected: when Hugging Face's security team needed to analyze more than 17,000 recorded attacker events, the frontier models behind commercial APIs refused the work. The analysis required submitting real attack commands, exploit payloads, and C2 artifacts, and the safety guardrails of those hosted models could not distinguish an incident responder from an attacker. The team ran the forensic analysis on GLM-5.2, an open-weight model from Z.ai (formerly Zhipu AI), on their own infrastructure instead. It worked, and none of the attacker data ever left their environment. 

The lesson for defenders: have a capable model you can run on your own infrastructure, vetted and ready before an incident. Guardrail lockout is real. Open weights are how you avoid it. 

The same logic that protected Hugging Face also protects your wallet. Let's look at the numbers. 

How DeepSeek V4 Forced OpenAI to Cut Prices 

This is what competition looks like in practice. GPT-5.6 launched on July 9, 2026, with Sol as the flagship plus Terra and Luna below it. Three weeks later, on July 30, OpenAI cut GPT-5.6 Luna's price by 80% (from $1/$6 to $0.20/$1.20) and Terra's by 20% (from $2.50/$15 to $2/$12). The flagship, Sol, stayed put. The company attributed the cuts to internal efficiency gains, improvements that, conveniently, arrived right as the open-weight wave crested. The pressure had been building since DeepSeek's V4 preview in April, GLM-5.2 in June, and Moonshot AI's Kimi K3 on July 16, a model neck-and-neck with Anthropic's top tier landing at $3/$15 per million tokens. DeepSeek doubled down the very next day, relaunching V4 Flash on July 31 at $0.14/$0.28, and held that price until August 16, when it moved the whole V4 line to peak and off-peak rates. 

Anthropic moved as well: Opus 5 (released July 24) shipped at $5/$25 per million tokens, exactly half of Fable 5's $10/$50. When a model comparable to your best costs 30× less, you have two options: improve the product, or lose the market share. 

None of this happens without open-weight pressure. When models with comparable performance can be hosted and sold by anyone with enough hardware, the proprietary vendors have to compete on price. Competition is always important, and right now, it's working in our favor. 

Conclusion: What to Expect From Here 

We covered what LLMs are, what open-weight models are, and why they matter, for research, for fine tuning, and for the economics of the entire industry. Now, some closing thoughts on the future. 

GLM 5.3: The Next One on the List 

GLM 5.3 landed on August 14, 2026, and it's a direct descendant of the model that saved Hugging Face's incident response. The base model didn't change by a single parameter: Z.ai scaled up post training on 5.2, nothing else. That alone put it neck-and-neck with, and on some benchmarks past, the closed frontier: on CyberGym, which tests a model's ability to find and verify real vulnerabilities, GLM-5.3 scored 84.5%, ahead of GPT-5.6 Sol (83.6%) and Mythos 5 (83.8%). To be fair, those are Z.ai's own numbers and nobody has reproduced them independently yet, so read them with that in mind. Still, that's a remarkable result for a model that's relatively small for its intelligence, and I believe the gap will only shrink as the techniques I mentioned earlier mature. 

This will force Anthropic to respond, either by pricing Fable 5 more aggressively or by shipping a stronger model at a more accessible price. And it proves a deeper point: once this level of  intelligence ships with open weights, it cannot be locked away again. We saw this summer how quickly access to a closed flagship can change for reasons entirely outside its users' control: on June 12, 2026, Fable 5 and Mythos 5 were pulled from everyone overnight, and it took until July 1 for access to come back. An open-weight model has no single kill switch. The moment the weights are out, copies live on servers and hard drives across jurisdictions, and anyone with enough hardware can keep serving it. It is far easier to restrict who can sell a model than to prevent its existence. Once the genie is out of the bottle, it stays out. 

Hybrid Is the Future 

Here's how I see the economics playing out: hybrid inference. 

Very capable local models like Qwen 3.8 27B will run smaller, daily, more manual tasks on consumer hardware, keeping everything private. Working on files that live on your own PC is an extremely sensitive capability, and in my opinion it will be served by local models. For broader, more scalable use cases, or tasks that genuinely need frontier-level intelligence, we'll keep hiring cloud APIs, exactly as we do today. 

For strict industries (medical, legal, anything requiring ISO compliance), self-hosting open-weight models in your own data center, or on your own cloud like AWS, will become the standard pattern. 

I'm already seeing it begin: advanced users plan their tasks with a big API model, then execute the plan with a free, less capable local one. As local models keep packing more intelligence into smaller packages, that pattern will become the norm. 

The future of AI isn't one model behind one API. It's a portfolio, and for the first time, a big part of it belongs to you.